![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pc-parts.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / packages|
Return to pc-parts.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / packages |
1.1 root 1: /*
2: * pc partition support
3: *
4: * Copyright (C) 2004 Stefan Reinauer
5: *
6: * This code is based (and copied in many places) from
7: * mac partition support by Samuel Rydh ([email protected])
8: *
9: * This program is free software; you can redistribute it and/or
10: * modify it under the terms of the GNU General Public License
11: * version 2
12: *
13: */
14:
15: #include "config.h"
16: #include "libopenbios/bindings.h"
17: #include "libopenbios/load.h"
18: #include "libc/byteorder.h"
19: #include "libc/vsprintf.h"
20: #include "packages.h"
21:
22: //#define DEBUG_PC_PARTS
23:
24: #ifdef DEBUG_PC_PARTS
25: #define DPRINTF(fmt, args...) \
26: do { printk(fmt , ##args); } while (0)
27: #else
28: #define DPRINTF(fmt, args...)
29: #endif
30:
31: typedef struct {
32: xt_t seek_xt, read_xt;
33: ucell offs_hi, offs_lo;
34: ucell size_hi, size_lo;
35: phandle_t filesystem_ph;
36: } pcparts_info_t;
37:
38: DECLARE_NODE( pcparts, INSTALL_OPEN, sizeof(pcparts_info_t), "+/packages/pc-parts" );
39:
40: #define SEEK( pos ) ({ DPUSH(pos); call_parent(di->seek_xt); POP(); })
41: #define READ( buf, size ) ({ PUSH(pointer2cell(buf)); PUSH(size); call_parent(di->read_xt); POP(); })
42:
43: /* three helper functions */
44:
45: static inline int has_pc_valid_partition(unsigned char *sect)
46: {
47: /* Make sure the partition table contains at least one valid entry */
48: return (sect[0x1c2] != 0 || sect[0x1d2] != 0 || sect[0x1e2] != 0);
49: }
50:
51: static inline int has_pc_part_magic(unsigned char *sect)
52: {
53: return sect[0x1fe]==0x55 && sect[0x1ff]==0xAA;
54: }
55:
56: static inline int is_pc_extended_part(unsigned char type)
57: {
58: return type==5 || type==0xf || type==0x85;
59: }
60:
61: /* ( open -- flag ) */
62: static void
63: pcparts_open( pcparts_info_t *di )
64: {
65: char *str = my_args_copy();
66: char *argstr = strdup("");
67: char *parstr = strdup("");
68: int bs, parnum=-1;
69: int found = 0;
70: phandle_t ph;
71: ducell offs, size;
72:
73: /* Layout of PC partition table */
74: struct pc_partition {
75: unsigned char boot;
76: unsigned char head;
77: unsigned char sector;
78: unsigned char cyl;
79: unsigned char type;
80: unsigned char e_head;
81: unsigned char e_sector;
82: unsigned char e_cyl;
83: u32 start_sect; /* unaligned little endian */
84: u32 nr_sects; /* ditto */
85: } *p, *partition;
86:
87: unsigned char buf[512];
88:
89: DPRINTF("pcparts_open '%s'\n", str );
90:
91: /*
92: Arguments that we accept:
93: id: [0-7]
94: [(id)][,][filespec]
95: */
96:
97: if( str ) {
98: if ( !strlen(str) )
99: parnum = -1;
100: else {
101: /* Detect the boot parameters */
102: char *ptr;
103: ptr = str;
104:
105: /* <id>,<file> */
106: if (*ptr >= '0' && *ptr <= '9' && *(ptr + 1) == ',') {
107: parstr = ptr;
108: *(ptr + 1) = '\0';
109: argstr = ptr + 2;
110: }
111:
112: /* <id> */
113: else if (*ptr >= '0' && *ptr <='9' && *(ptr + 1) == '\0') {
114: parstr = ptr;
115: }
116:
117: /* ,<file> */
118: else if (*ptr == ',') {
119: argstr = ptr + 1;
120: }
121:
122: /* <file> */
123: else {
124: argstr = str;
125: }
126:
127: /* Convert the id to a partition number */
128: if (strlen(parstr))
129: parnum = atol(parstr);
130: }
131: }
132:
133: DPRINTF("parstr: %s argstr: %s parnum: %d\n", parstr, argstr, parnum);
134: free(parstr);
135:
136: if( parnum < 0 )
137: parnum = 0;
138:
139: di->filesystem_ph = 0;
140: di->read_xt = find_parent_method("read");
141: di->seek_xt = find_parent_method("seek");
142:
143: SEEK( 0 );
144: if( READ(buf, 512) != 512 )
145: RET(0);
146:
147: /* Check Magic */
148: if (!has_pc_part_magic(buf)) {
149: DPRINTF("pc partition magic not found.\n");
150: RET(0);
151: }
152:
153: /* Actual partition data */
154: partition = (struct pc_partition *) (buf + 0x1be);
155:
156: /* Make sure we use a copy accessible from an aligned pointer (some archs
157: e.g. SPARC will crash otherwise) */
158: p = malloc(sizeof(struct pc_partition));
159:
160: bs = 512;
161:
162: if (parnum < 4) {
163: /* primary partition */
164: partition += parnum;
165: memcpy(p, partition, sizeof(struct pc_partition));
166:
167: if (p->type == 0 || is_pc_extended_part(p->type)) {
168: DPRINTF("partition %d does not exist\n", parnum+1 );
169: RET( 0 );
170: }
171:
172: offs = (long long)(__le32_to_cpu(p->start_sect)) * bs;
173: di->offs_hi = offs >> BITS;
174: di->offs_lo = offs & (ucell) -1;
175:
176: size = (long long)(__le32_to_cpu(p->nr_sects)) * bs;
177: di->size_hi = size >> BITS;
178: di->size_lo = size & (ucell) -1;
179:
180: DPRINTF("Primary partition at sector %x\n", __le32_to_cpu(p->start_sect));
181:
182: found = 1;
183: } else {
184: /* Extended partition */
185: int i, cur_part;
186: unsigned long ext_start, cur_table;
187:
188: /* Search for the extended partition
189: * which contains logical partitions */
190: for (i = 0; i < 4; i++) {
191: if (is_pc_extended_part(p[i].type))
192: break;
193: }
194:
195: if (i >= 4) {
196: DPRINTF("Extended partition not found\n");
197: RET( 0 );
198: }
199:
200: DPRINTF("Extended partition at %d\n", i+1);
201:
202: /* Visit each logical partition labels */
203: ext_start = __le32_to_cpu(p[i].start_sect);
204: cur_table = ext_start;
205: cur_part = 4;
206:
207: while (cur_part <= parnum) {
208: DPRINTF("cur_part=%d at %lx\n", cur_part, cur_table);
209:
210: SEEK( cur_table * bs );
211: if( READ(buf, sizeof(512)) != sizeof(512) )
212: RET( 0 );
213:
214: if (!has_pc_part_magic(buf)) {
215: DPRINTF("Extended partition has no magic\n");
216: break;
217: }
218:
219: /* Read the extended partition, making sure we are aligned again */
220: partition = (struct pc_partition *) (buf + 0x1be);
221: memcpy(p, partition, sizeof(struct pc_partition));
222:
223: /* First entry is the logical partition */
224: if (cur_part == parnum) {
225: if (p->type == 0) {
226: DPRINTF("Partition %d is empty\n", parnum+1);
227: RET( 0 );
228: }
229:
230: offs = (long long)(cur_table+__le32_to_cpu(p->start_sect)) * bs;
231: di->offs_hi = offs >> BITS;
232: di->offs_lo = offs & (ucell) -1;
233:
234: size = (long long)__le32_to_cpu(p->nr_sects) * bs;
235: di->size_hi = size >> BITS;
236: di->size_lo = size & (ucell) -1;
237:
238: found = 1;
239: break;
240: }
241:
242: /* Second entry is link to next partition */
243: if (!is_pc_extended_part(p[1].type)) {
244: DPRINTF("no link\n");
245: break;
246: }
247:
248: cur_table = ext_start + __le32_to_cpu(p[1].start_sect);
249: cur_part++;
250: }
251:
252: if (!found) {
253: DPRINTF("Logical partition %d does not exist\n", parnum+1);
254: RET( 0 );
255: }
256: }
257:
258: free(p);
259:
260: if (found) {
261: /* We have a valid partition - so probe for a filesystem at the current offset */
262: DPRINTF("pc-parts: about to probe for fs\n");
263: DPUSH( offs );
264: PUSH_ih( my_parent() );
265: parword("find-filesystem");
266: DPRINTF("pc-parts: done fs probe\n");
267:
268: ph = POP_ph();
269: if( ph ) {
270: DPRINTF("pc-parts: filesystem found with ph " FMT_ucellx " and args %s\n", ph, argstr);
271: di->filesystem_ph = ph;
272:
273: /* If we have been asked to open a particular file, interpose the filesystem package with
274: the passed filename as an argument */
275: if (strlen(argstr)) {
276: push_str( argstr );
277: PUSH_ph( ph );
278: fword("interpose");
279: }
280: } else {
281: DPRINTF("pc-parts: no filesystem found; bypassing misc-files interpose\n");
282: }
283:
284: free( str );
285: RET( -1 );
286: } else {
287: DPRINTF("pc-parts: unable to locate partition\n");
288:
289: free( str );
290: RET( 0 );
291: }
292: }
293:
294: /* ( block0 -- flag? ) */
295: static void
296: pcparts_probe( pcparts_info_t *dummy )
297: {
298: unsigned char *buf = (unsigned char *)cell2pointer(POP());
299:
300: DPRINTF("probing for PC partitions\n");
301:
302: /* We also check that at least one valid partition exists; this is because
303: some CDs seem broken in that they have a partition table but it is empty
304: e.g. MorphOS. */
305: RET ( has_pc_part_magic(buf) && has_pc_valid_partition(buf) );
306: }
307:
308: /* ( -- type offset.d size.d ) */
309: static void
310: pcparts_get_info( pcparts_info_t *di )
311: {
312: DPRINTF("PC get_info\n");
313: PUSH( -1 ); /* no type */
314: PUSH( di->offs_lo );
315: PUSH( di->offs_hi );
316: PUSH( di->size_lo );
317: PUSH( di->size_hi );
318: }
319:
320: static void
321: pcparts_block_size( __attribute__((unused))pcparts_info_t *di )
322: {
323: PUSH(512);
324: }
325:
326: static void
327: pcparts_initialize( pcparts_info_t *di )
328: {
329: fword("register-partition-package");
330: }
331:
332: /* ( pos.d -- status ) */
333: static void
334: pcparts_seek(pcparts_info_t *di )
335: {
336: long long pos = DPOP();
337: long long offs, size;
338:
339: DPRINTF("pcparts_seek %llx:\n", pos);
340:
341: /* Seek is invalid if we reach the end of the device */
342: size = ((ducell)di->size_hi << BITS) | di->size_lo;
343: if (pos > size)
344: RET( -1 );
345:
346: /* Calculate the seek offset for the parent */
347: offs = ((ducell)di->offs_hi << BITS) | di->offs_lo;
348: offs += pos;
349: DPUSH(offs);
350:
351: DPRINTF("pcparts_seek parent offset %llx:\n", offs);
352:
353: call_package(di->seek_xt, my_parent());
354: }
355:
356: /* ( buf len -- actlen ) */
357: static void
358: pcparts_read(pcparts_info_t *di )
359: {
360: DPRINTF("pcparts_read\n");
361:
362: /* Pass the read back up to the parent */
363: call_package(di->read_xt, my_parent());
364: }
365:
366: /* ( addr -- size ) */
367: static void
368: pcparts_load( __attribute__((unused))pcparts_info_t *di )
369: {
370: /* Invoke the loader */
371: load(my_self());
372: }
373:
374: /* ( pathstr len -- ) */
375: static void
376: pcparts_dir( pcparts_info_t *di )
377: {
378: if ( di->filesystem_ph ) {
379: PUSH( my_self() );
380: push_str("dir");
381: PUSH( di->filesystem_ph );
382: fword("find-method");
383: POP();
384: fword("execute");
385: } else {
386: forth_printf("pc-parts: Unable to determine filesystem\n");
387: POP();
388: POP();
389: }
390: }
391:
392: NODE_METHODS( pcparts ) = {
393: { "probe", pcparts_probe },
394: { "open", pcparts_open },
395: { "seek", pcparts_seek },
396: { "read", pcparts_read },
397: { "load", pcparts_load },
398: { "dir", pcparts_dir },
399: { "get-info", pcparts_get_info },
400: { "block-size", pcparts_block_size },
401: { NULL, pcparts_initialize },
402: };
403:
404: void
405: pcparts_init( void )
406: {
407: REGISTER_NODE( pcparts );
408: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.