![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fsys_affs.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 / fs / grubfs|
Return to fsys_affs.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs |
1.1 root 1: #ifdef FSYS_AFFS
2: #include "shared.h"
3: #include "filesys.h"
4:
5: /******************************** RDB definitions */
6: #define RDB_LOCATION_LIMIT 16
7: #define IDNAME_RIGIDDISK 0x5244534B /* 'RDSK' */
8:
9: struct RigidDiskBlock
10: {
11: unsigned long rdb_ID;
12: unsigned long rdb_SummedLongs;
13: long rdb_ChkSum;
14: unsigned long rdb_HostID;
15: unsigned long rdb_BlockBytes;
16: unsigned long rdb_Flags;
17: unsigned long rdb_BadBlockList;
18: unsigned long rdb_PartitionList;
19: unsigned long rdb_FileSysHeaderList;
20: unsigned long rdb_DriveInit;
21: unsigned long rdb_Reserved1[6];
22: unsigned long rdb_Cylinders;
23: unsigned long rdb_Sectors;
24: unsigned long rdb_Heads;
25: unsigned long rdb_Interleave;
26: unsigned long rdb_Park;
27: unsigned long rdb_Reserved2[3];
28: unsigned long rdb_WritePreComp;
29: unsigned long rdb_ReducedWrite;
30: unsigned long rdb_StepRate;
31: unsigned long rdb_Reserved3[5];
32: unsigned long rdb_RDBBlocksLo;
33: unsigned long rdb_RDBBlocksHi;
34: unsigned long rdb_LoCylinder;
35: unsigned long rdb_HiCylinder;
36: unsigned long rdb_CylBlocks;
37: unsigned long rdb_AutoParkSeconds;
38: unsigned long rdb_HighRDSKBlock;
39: unsigned long rdb_Reserved4;
40: char rdb_DiskVendor[8];
41: char rdb_DiskProduct[16];
42: char rdb_DiskRevision[4];
43: char rdb_ControllerVendor[8];
44: char rdb_ControllerProduct[16];
45: char rdb_ControllerRevision[4];
46: char rdb_DriveInitName[40];
47: };
48:
49: struct PartitionBlock
50: {
51: unsigned long pb_ID;
52: unsigned long pb_SummedLongs;
53: long pb_ChkSum;
54: unsigned long pb_HostID;
55: unsigned long pb_Next;
56: unsigned long pb_Flags;
57: unsigned long pb_Reserved1[2];
58: unsigned long pb_DevFlags;
59: char pb_DriveName[32];
60: unsigned long pb_Reserved2[15];
61: unsigned long pb_Environment[20];
62: unsigned long pb_EReserved[12];
63: };
64:
65: #define DE_TABLESIZE 0
66: #define DE_SIZEBLOCK 1
67: #define DE_BLOCKSIZE 2
68: #define DE_NUMHEADS 3
69: #define DE_SECSPERBLOCK 4
70: #define DE_BLKSPERTRACK 5
71: #define DE_RESERVEDBLKS 6
72: #define DE_PREFAC 7
73: #define DE_INTERLEAVE 8
74: #define DE_LOWCYL 9
75: #define DE_HIGHCYL 10
76: #define DE_UPPERCYL DE_HIGHCYL
77: #define DE_NUMBUFFERS 11
78: #define DE_BUFMEMTYPE 12
79: #define DE_MEMBUFTYPE DE_BUFMEMTYPE
80: #define DE_MAXTRANSFER 13
81: #define DE_MASK 14
82: #define DE_BOOTPRI 15
83: #define DE_DOSTYPE 16
84: #define DE_BAUD 17
85: #define DE_CONTROL 18
86: #define DE_BOOTBLOCKS 19
87:
88:
89: /******************************** AFFS definitions */
90: #define T_SHORT 2
91: #define T_LIST 16
92:
93: #define ST_FILE -3
94: #define ST_ROOT 1
95: #define ST_USERDIR 2
96:
97: struct BootBlock{
98: int id;
99: int chksum;
100: int rootblock;
101: int data[127];
102: };
103:
104: struct RootBlock{
105: int p_type; //0
106: int n1[2]; //1-2
107: int hashtable_size; //3
108: int n2; //4
109: int checksum; //5
110: int hashtable[72]; //6-77
111: int bitmap_valid_flag; //78
112: int bitmap_ptrs[25]; //79-103
113: int bitmap_extension; //104
114: int root_days; //105
115: int root_mins; //106
116: int root_ticks; //107;
117: char diskname[32]; //108-115
118: int n3[2]; //116-117
119: int volume_days; //118
120: int volume_mins; //119
121: int volume_ticks; //120
122: int creation_days; //121
123: int creation_mins; //122
124: int creation_ticks; //123
125: int n4[3]; //124-126
126: int s_type; //127
127: };
128:
129: struct DirHeader {
130: int p_type; //0
131: int own_key; //1
132: int n1[3]; //2-4
133: int checksum; //5
134: int hashtable[72]; //6-77
135: int n2; //78
136: int owner; //79
137: int protection; //80
138: int n3; //81
139: char comment[92]; //82-104
140: int days; //105
141: int mins; //106
142: int ticks; //107
143: char name[32]; //108-115
144: int n4[2]; //116-117
145: int linkchain; //118
146: int n5[5]; //119-123
147: int hashchain; //124
148: int parent; //125
149: int n6; //126
150: int s_type; //127
151: };
152:
153: struct FileHeader {
154: int p_type; //0
155: int own_key; //1
156: int n1[3]; //2-4
157: int checksum; //5
158: int filekey_table[72]; //6-77
159: int n2; //78
160: int owner; //79
161: int protection; //80
162: int bytesize; //81
163: char comment[92]; //82-104
164: int days; //105
165: int mins; //106
166: int ticks; //107
167: char name[32]; //108-115
168: int n3[2]; //116-117
169: int linkchain; //118
170: int n4[5]; //119-123
171: int hashchain; //124
172: int parent; //125
173: int extension; //126
174: int s_type; //127
175: };
176:
177: struct FileKeyExtension{
178: int p_type; //0
179: int own_key; //1
180: int table_size; //2
181: int n1[2]; //3-4
182: int checksum; //5
183: int filekey_table[72]; //6-77
184: int info[46]; //78-123
185: int n2; //124
186: int parent; //125
187: int extension; //126
188: int s_type; //127
189: };
190:
191: struct Position {
192: unsigned int block;
193: short filekey;
194: unsigned short byte;
195: unsigned int offset;
196: };
197:
198: struct ReadData {
199: unsigned int header_block;
200: struct Position current;
201: unsigned int filesize;
202: };
203:
204: //#warning "Big vs. little endian for configure needed"
205: #define AROS_BE2LONG(l) \
206: ( \
207: ((((unsigned long)(l)) >> 24) & 0x000000FFUL) | \
208: ((((unsigned long)(l)) >> 8) & 0x0000FF00UL) | \
209: ((((unsigned long)(l)) << 8) & 0x00FF0000UL) | \
210: ((((unsigned long)(l)) << 24) & 0xFF000000UL) \
211: )
212:
213: struct CacheBlock {
214: int blocknum;
215: unsigned short flags;
216: unsigned short access_count;
217: unsigned int blockbuffer[128];
218: };
219: #define LockBuffer(x) (((struct CacheBlock *)(x))->flags |= 0x0001)
220: #define UnLockBuffer(x) (((struct CacheBlock *)(x))->flags &= ~0x0001)
221:
222: #define MAX_CACHE_BLOCKS 10
223:
224: struct FSysBuffer {
225: struct ReadData file;
226: struct CacheBlock blocks[MAX_CACHE_BLOCKS];
227: };
228:
229: #define bootBlock(x) ((struct BootBlock *)(x)->blockbuffer)
230: #define rootBlock(x) ((struct RootBlock *)(x)->blockbuffer)
231: #define dirHeader(x) ((struct DirHeader *)(x)->blockbuffer)
232: #define fileHeader(x) ((struct FileHeader *)(x)->blockbuffer)
233: #define extensionBlock(x) ((struct FileKeyExtension *)(x)->blockbuffer)
234:
235: #define rdsk(x) ((struct RigidDiskBlock *)(x)->blockbuffer)
236: #define part(x) ((struct PartitionBlock *)(x)->blockbuffer)
237:
238: static struct FSysBuffer *fsysb;
239: static int blockoffset; /* offset if there is an embedded RDB partition */
240: static int rootb; /* block number of root block */
241: static int rdbb; /* block number of rdb block */
242:
243: static void initCache(void)
244: {
245: int i;
246:
247: for (i=0;i<MAX_CACHE_BLOCKS;i++)
248: {
249: fsysb->blocks[i].blocknum = -1;
250: fsysb->blocks[i].flags = 0;
251: fsysb->blocks[i].access_count = 0;
252: }
253: }
254:
255: static struct CacheBlock *getBlock(unsigned int block)
256: {
257: struct CacheBlock *freeblock;
258: int i;
259:
260: /* get first unlocked block */
261: i = 0;
262: do
263: {
264: freeblock = &fsysb->blocks[i++];
265: } while (freeblock->flags & 0x0001);
266: /* search through list if block is already loaded in */
267: for (i=0;i<MAX_CACHE_BLOCKS;i++)
268: {
269: if (fsysb->blocks[i].blocknum == block)
270: {
271: fsysb->blocks[i].access_count++;
272: return &fsysb->blocks[i];
273: }
274: if (!(fsysb->blocks[i].flags & 0x0001))
275: if (freeblock->access_count>fsysb->blocks[i].access_count)
276: freeblock = &fsysb->blocks[i];
277: }
278: freeblock->blocknum = block;
279: devread(block+blockoffset, 0, 512, (char *)freeblock->blockbuffer);
280: return freeblock;
281: }
282:
283: static unsigned int calcChkSum(unsigned short SizeBlock, unsigned int *buffer)
284: {
285: unsigned int sum=0,count=0;
286:
287: for (count=0;count<SizeBlock;count++)
288: sum += AROS_BE2LONG(buffer[count]);
289: return sum;
290: }
291:
292: int affs_mount(void) {
293: struct CacheBlock *cblock;
294: int i;
295:
296: if (
297: (current_drive & 0x80) &&
298: (current_partition != 0xFFFFFF) &&
299: (current_slice != 0x30)
300: )
301: return 0;
302: fsysb = (struct FSysBuffer *)FSYS_BUF;
303: blockoffset = 0;
304: initCache();
305: /* check for rdb partitiontable */
306: for (i=0;i<RDB_LOCATION_LIMIT;i++)
307: {
308: cblock = getBlock(i);
309: if (
310: (
311: ((AROS_BE2LONG(bootBlock(cblock)->id) & 0xFFFFFF00)==0x444F5300) &&
312: ((AROS_BE2LONG(bootBlock(cblock)->id) & 0xFF)>0)
313: ) ||
314: (AROS_BE2LONG(cblock->blockbuffer[0]) == IDNAME_RIGIDDISK)
315: )
316: break;
317: }
318: if (i == RDB_LOCATION_LIMIT)
319: return 0;
320: if (AROS_BE2LONG(cblock->blockbuffer[0]) == IDNAME_RIGIDDISK)
321: {
322: /* we have an RDB partition table within a MBR-Partition */
323: rdbb = i;
324: }
325: else if (i<2)
326: {
327: /* partition type is 0x30 = AROS and AFFS formatted */
328: rdbb = RDB_LOCATION_LIMIT;
329: rootb = (part_length-1+2)/2;
330: cblock = getBlock(rootb);
331: if (
332: (AROS_BE2LONG(rootBlock(cblock)->p_type) != T_SHORT) ||
333: (AROS_BE2LONG(rootBlock(cblock)->s_type) != ST_ROOT) ||
334: calcChkSum(128, cblock->blockbuffer)
335: )
336: return 0;
337: }
338: else
339: return 0;
340: return 1;
341: }
342:
343: static int seek(unsigned long offset)
344: {
345: struct CacheBlock *cblock;
346: unsigned long block;
347: unsigned long togo;
348:
349: block = fsysb->file.header_block;
350:
351: togo = offset / 512;
352: fsysb->file.current.filekey = 71-(togo % 72);
353: togo /= 72;
354: fsysb->file.current.byte = offset % 512;
355: fsysb->file.current.offset = offset;
356: while ((togo) && (block))
357: {
358: disk_read_func = disk_read_hook;
359: cblock = getBlock(block);
360: disk_read_func = NULL;
361: block = AROS_BE2LONG(extensionBlock(cblock)->extension);
362: togo--;
363: }
364: if (togo)
365: return 1;
366: fsysb->file.current.block = block;
367: return 0;
368: }
369:
370: int affs_read(char *buf, int len) {
371: struct CacheBlock *cblock;
372: unsigned short size;
373: unsigned int readbytes = 0;
374:
375: if (fsysb->file.current.offset != filepos)
376: {
377: if (seek(filepos))
378: return ERR_FILELENGTH;
379: }
380: if (fsysb->file.current.block == 0)
381: return 0;
382: if (len>(fsysb->file.filesize-fsysb->file.current.offset))
383: len=fsysb->file.filesize-fsysb->file.current.offset;
384: disk_read_func = disk_read_hook;
385: cblock = getBlock(fsysb->file.current.block);
386: disk_read_func = NULL;
387: while (len)
388: {
389: disk_read_func = disk_read_hook;
390: if (fsysb->file.current.filekey<0)
391: {
392: fsysb->file.current.filekey = 71;
393: fsysb->file.current.block = AROS_BE2LONG(extensionBlock(cblock)->extension);
394: if (fsysb->file.current.block)
395: {
396: cblock = getBlock(fsysb->file.current.block);
397: }
398: //#warning "else shouldn't occour"
399: }
400: size = 512;
401: size -= fsysb->file.current.byte;
402: if (size>len)
403: {
404: size = len;
405: devread
406: (
407: AROS_BE2LONG
408: (
409: extensionBlock(cblock)->filekey_table
410: [fsysb->file.current.filekey]
411: )+blockoffset,
412: fsysb->file.current.byte, size, (char *)((long)buf+readbytes)
413: );
414: fsysb->file.current.byte += size;
415: }
416: else
417: {
418: devread
419: (
420: AROS_BE2LONG
421: (
422: extensionBlock(cblock)->filekey_table
423: [fsysb->file.current.filekey]
424: )+blockoffset,
425: fsysb->file.current.byte, size, (char *)((long)buf+readbytes)
426: );
427: fsysb->file.current.byte = 0;
428: fsysb->file.current.filekey--;
429: }
430: disk_read_func = NULL;
431: len -= size;
432: readbytes += size;
433: }
434: fsysb->file.current.offset += readbytes;
435: filepos = fsysb->file.current.offset;
436: return readbytes;
437: }
438:
439: static unsigned char capitalch(unsigned char ch, unsigned char flags)
440: {
441:
442: if ((flags==0) || (flags==1))
443: return (unsigned char)((ch>='a') && (ch<='z') ? ch-('a'-'A') : ch);
444: else // DOS\(>=2)
445: return (unsigned char)(((ch>=224) && (ch<=254) && (ch!=247)) ||
446: ((ch>='a') && (ch<='z')) ? ch-('a'-'A') : ch);
447: }
448:
449: // str2 is a BCPL string
450: static int noCaseStrCmp(char *str1, char *str2, unsigned char flags)
451: {
452: unsigned char length;
453:
454: length=str2++[0];
455: do {
456: if ((*str1==0) && (length==0))
457: return 0;
458: length--;
459: // if ((*str1==0) && (*str2==0)) return 1;
460: } while (capitalch(*str1++,flags)==capitalch(*str2++,flags));
461: str1--;
462: return (*str1) ? 1 : -1;
463: }
464:
465: static unsigned int getHashKey(char *name,unsigned int tablesize, unsigned char flags)
466: {
467: unsigned int length;
468:
469: length=0;
470: while (name[length] != 0)
471: length++;
472: while (*name!=0)
473: length=(length * 13 +capitalch(*name++,flags)) & 0x7FF;
474: return length%tablesize;
475: }
476:
477: static grub_error_t getHeaderBlock(char *name, struct CacheBlock **dirh)
478: {
479: int key;
480:
481: key = getHashKey(name, 72, 1);
482: if (!dirHeader(*dirh)->hashtable[key])
483: return ERR_FILE_NOT_FOUND;
484: *dirh = getBlock(AROS_BE2LONG(dirHeader(*dirh)->hashtable[key]));
485: if (calcChkSum(128, (*dirh)->blockbuffer))
486: {
487: #ifdef DEBUG_AFFS
488: printf("ghb: %d\n", (*dirh)->blocknum);
489: #endif
490: return ERR_FSYS_CORRUPT;
491: }
492: if (AROS_BE2LONG(dirHeader(*dirh)->p_type) != T_SHORT)
493: return ERR_BAD_FILETYPE;
494: while (noCaseStrCmp(name,dirHeader(*dirh)->name,1) != 0)
495: {
496: if (!dirHeader(*dirh)->hashchain)
497: return ERR_FILE_NOT_FOUND;
498: *dirh = getBlock(AROS_BE2LONG(dirHeader(*dirh)->hashchain));
499: if (calcChkSum(128, (*dirh)->blockbuffer))
500: {
501: #ifdef DEBUG_AFFS
502: printf("ghb2: %d\n", (*dirh)->blocknum);
503: #endif
504: return ERR_FSYS_CORRUPT;
505: }
506: if (AROS_BE2LONG(dirHeader(*dirh)->p_type) != T_SHORT)
507: return ERR_BAD_FILETYPE;
508: }
509: return 0;
510: }
511:
512: static char *copyPart(char *src, char *dst)
513: {
514: while ((*src != '/') && (*src))
515: *dst++ = *src++;
516: if (*src == '/')
517: src++;
518: *dst-- = 0;
519: /* cut off spaces at the end */
520: while (*dst == ' ')
521: *dst-- = 0;
522: return src;
523: }
524:
525: static grub_error_t findBlock(char *name, struct CacheBlock **dirh)
526: {
527: char dname[32];
528: int block;
529:
530: name++; /* skip "/" */
531: /* partition table part */
532: if (rdbb < RDB_LOCATION_LIMIT)
533: {
534: int bpc;
535:
536: blockoffset = 0;
537: *dirh = getBlock(rdbb);
538: if (*name==0)
539: return 0;
540: name = copyPart(name, dname);
541: bpc = AROS_BE2LONG(rdsk(*dirh)->rdb_Sectors)*AROS_BE2LONG(rdsk(*dirh)->rdb_Heads);
542: block = AROS_BE2LONG(rdsk(*dirh)->rdb_PartitionList);
543: while (block != -1)
544: {
545: *dirh = getBlock(block);
546: if (noCaseStrCmp(dname, part(*dirh)->pb_DriveName, 1) == 0)
547: break;
548: block = AROS_BE2LONG(part(*dirh)->pb_Next);
549: }
550: if (block == -1)
551: return ERR_FILE_NOT_FOUND;
552: if (
553: ((AROS_BE2LONG(part(*dirh)->pb_Environment[DE_DOSTYPE]) & 0xFFFFFF00)!=0x444F5300) ||
554: ((AROS_BE2LONG(part(*dirh)->pb_Environment[DE_DOSTYPE]) & 0xFF)==0)
555: )
556: return ERR_BAD_FILETYPE;
557: blockoffset = AROS_BE2LONG(part(*dirh)->pb_Environment[DE_LOWCYL]);
558: rootb = AROS_BE2LONG(part(*dirh)->pb_Environment[DE_HIGHCYL]);
559: rootb = rootb-blockoffset+1; /* highcyl-lowcyl+1 */
560: rootb *= bpc;
561: rootb = rootb-1+AROS_BE2LONG(part(*dirh)->pb_Environment[DE_RESERVEDBLKS]);
562: rootb /= 2;
563: blockoffset *= bpc;
564: }
565:
566: /* filesystem part */
567: *dirh = getBlock(rootb);
568: while (*name)
569: {
570: if (
571: (AROS_BE2LONG(dirHeader(*dirh)->s_type) != ST_ROOT) &&
572: (AROS_BE2LONG(dirHeader(*dirh)->s_type) != ST_USERDIR)
573: )
574: return ERR_BAD_FILETYPE;
575: name = copyPart(name, dname);
576: errnum = getHeaderBlock(dname, dirh);
577: if (errnum)
578: return errnum;
579: }
580: return 0;
581: }
582:
583: #ifndef STAGE1_5
584: static void checkPossibility(char *filename, char *bstr)
585: {
586: char cstr[32];
587:
588: if (noCaseStrCmp(filename, bstr, 1)<=0)
589: {
590: if (print_possibilities>0)
591: print_possibilities = -print_possibilities;
592: memcpy(cstr, bstr+1, bstr[0]);
593: cstr[bstr[0]]=0;
594: print_a_completion(cstr);
595: }
596: }
597: #else
598: #define checkPossibility(a, b) do { } while(0)
599: #endif
600:
601: int affs_dir(char *dirname)
602: {
603: struct CacheBlock *buffer1;
604: struct CacheBlock *buffer2;
605: char *current = dirname;
606: char filename[128];
607: char *fname = filename;
608: int i,block;
609:
610: if (print_possibilities)
611: {
612: while (*current)
613: current++;
614: while (*current != '/')
615: current--;
616: current++;
617: while (*current)
618: {
619: *fname++ = *current;
620: *current++ = 0;
621: }
622: *fname=0;
623: errnum = findBlock(dirname, &buffer1);
624: if (errnum)
625: return 0;
626: if (AROS_BE2LONG(dirHeader(buffer1)->p_type) == IDNAME_RIGIDDISK)
627: {
628: block = AROS_BE2LONG(rdsk(buffer1)->rdb_PartitionList);
629: while (block != -1)
630: {
631: buffer1 = getBlock(block);
632: checkPossibility(filename, part(buffer1)->pb_DriveName);
633: block = AROS_BE2LONG(part(buffer1)->pb_Next);
634: }
635: #ifndef STAGE1_5
636: if (*filename == 0)
637: if (print_possibilities>0)
638: print_possibilities = -print_possibilities;
639: #endif
640: }
641: else if (AROS_BE2LONG(dirHeader(buffer1)->p_type) == T_SHORT)
642: {
643: LockBuffer(buffer1);
644: for (i=0;i<72;i++)
645: {
646: block = dirHeader(buffer1)->hashtable[i];
647: while (block)
648: {
649: buffer2 = getBlock(AROS_BE2LONG(block));
650: if (calcChkSum(128, buffer2->blockbuffer))
651: {
652: errnum = ERR_FSYS_CORRUPT;
653: return 0;
654: }
655: if (AROS_BE2LONG(dirHeader(buffer2)->p_type) != T_SHORT)
656: {
657: errnum = ERR_BAD_FILETYPE;
658: return 0;
659: }
660: checkPossibility(filename, dirHeader(buffer2)->name);
661: block = dirHeader(buffer2)->hashchain;
662: }
663: }
664: UnLockBuffer(buffer1);
665: #ifndef STAGE1_5
666: if (*filename == 0)
667: if (print_possibilities>0)
668: print_possibilities = -print_possibilities;
669: #endif
670: }
671: else
672: {
673: errnum = ERR_BAD_FILETYPE;
674: return 0;
675: }
676: while (*current != '/')
677: current--;
678: current++;
679: fname = filename;
680: while (*fname)
681: *current++ = *fname++;
682: //#warning "TODO: add some more chars until possibilities differ"
683: if (print_possibilities>0)
684: errnum = ERR_FILE_NOT_FOUND;
685: return (print_possibilities<0);
686: }
687: else
688: {
689: while (*current && !isspace(*current))
690: *fname++ = *current++;
691: *fname = 0;
692:
693: errnum = findBlock(filename, &buffer2);
694: if (errnum)
695: return 0;
696: if (AROS_BE2LONG(fileHeader(buffer2)->s_type)!=ST_FILE)
697: {
698: errnum = ERR_BAD_FILETYPE;
699: return 0;
700: }
701: fsysb->file.header_block = AROS_BE2LONG(fileHeader(buffer2)->own_key);
702: fsysb->file.current.block = AROS_BE2LONG(fileHeader(buffer2)->own_key);
703: fsysb->file.current.filekey = 71;
704: fsysb->file.current.byte = 0;
705: fsysb->file.current.offset = 0;
706: fsysb->file.filesize = AROS_BE2LONG(fileHeader(buffer2)->bytesize);
707: filepos = 0;
708: filemax = fsysb->file.filesize;
709: return 1;
710: }
711: }
712: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.