![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / boot / stand|
Return to sys.c CVS log | Up to [Research Unix] / researchv9 / sys / boot / stand |
1.1 root 1: /*
2: * @(#)sys.c 1.1 86/02/03 Copyright (c) 1985 by Sun Microsystems, Inc.
3: */
4:
5: /*
6: * Basic file system reading code for standalone I/O system.
7: * Simulates a primitive UNIX I/O system (read(), write(), open(), etc).
8: * Does not attempt writes to file systems, tho writing to whole devices
9: * is supported, when the driver supports it.
10: */
11:
12: #include "param.h"
13: #include "saio.h"
14: #include "../h/dir.h"
15: #include "../h/time.h"
16: #include "../h/vnode.h"
17: #include "../ufs/fs.h"
18: #include "../ufs/inode.h"
19: /*
20: * This struct keeps track of an open file in the standalone I/O system.
21: *
22: * It includes an IOB for device addess, an inode, a buffer for reading
23: * indirect blocks and inodes, and a buffer for the superblock of the
24: * file system (if any).
25: */
26: struct iob {
27: struct saioreq i_si; /* I/O request block for this file */
28: struct inode i_ino; /* Inode for this file */
29: char i_buf[MAXBSIZE];/* Buffer for reading inodes & dirs */
30: union {
31: struct fs ui_fs; /* Superblock for file system */
32: char dummy[SBSIZE];
33: } i_un;
34: };
35: #define i_flgs i_si.si_flgs
36: #define i_boottab i_si.si_boottab
37: #define i_devdata i_si.si_devdata
38: #define i_ctlr i_si.si_ctlr
39: #define i_unit i_si.si_unit
40: #define i_boff i_si.si_boff
41: #define i_cyloff i_si.si_cyloff
42: #define i_offset i_si.si_offset
43: #define i_bn i_si.si_bn
44: #define i_ma i_si.si_ma
45: #define i_cc i_si.si_cc
46: #define i_fs i_un.ui_fs
47:
48: /* These are the pools of buffers, iob's, etc. */
49: #define NBUFS (NIADDR+1) /* NOT! a variable */
50: char b[NBUFS][MAXBSIZE];
51: daddr_t blknos[NBUFS];
52: struct iob iob[NFILES];
53:
54: ino_t dlook();
55:
56: struct dirstuff {
57: int loc;
58: struct iob *io;
59: };
60:
61: static
62: openi(n,io)
63: ino_t n;
64: register struct iob *io;
65: {
66: register struct dinode *dp;
67:
68: io->i_offset = 0;
69: io->i_bn = fsbtodb(&io->i_fs, itod(&io->i_fs, n));
70: io->i_cc = io->i_fs.fs_bsize;
71: io->i_ma = io->i_buf;
72: /* FIXME: this call to devread() does not check for errors! */
73: devread(&io->i_si);
74: dp = (struct dinode *)io->i_buf;
75: io->i_ino.i_ic = dp[itoo(&io->i_fs, n)].di_ic;
76: }
77:
78: static ino_t
79: find(path, file)
80: register char *path;
81: struct iob *file;
82: {
83: register char *q;
84: char c;
85: ino_t n;
86:
87: if (path==NULL || *path=='\0') {
88: printf("null path\n");
89: return(0);
90: }
91:
92: openi((ino_t) ROOTINO, file);
93: while (*path) {
94: while (*path == '/')
95: path++;
96: q = path;
97: while(*q != '/' && *q != '\0')
98: q++;
99: c = *q;
100: *q = '\0';
101:
102: if ((n=dlook(path, file))!=0) {
103: if (c=='\0')
104: break;
105: openi(n, file);
106: *q = c;
107: path = q;
108: continue;
109: } else {
110: printf("%s not found\n",path);
111: return(0);
112: }
113: }
114: return(n);
115: }
116:
117: static daddr_t
118: sbmap(io, bn)
119: register struct iob *io;
120: daddr_t bn;
121: {
122: register struct inode *ip;
123: register int i, j, sh;
124: register daddr_t nb, *bap;
125:
126: ip = &io->i_ino;
127:
128: /*
129: * blocks 0..NDADDR are direct blocks
130: */
131: if(bn < NDADDR) {
132: nb = ip->i_db[bn];
133: return(nb);
134: }
135:
136: #ifndef BOOTBLOCK
137: /*
138: * addresses NIADDR have single and double indirect blocks.
139: * the first step is to determine how many levels of indirection.
140: */
141: sh = 1;
142: bn -= NDADDR;
143: for (j = NIADDR; j > 0; j--) {
144: sh *= NINDIR(&io->i_fs);
145: if (bn < sh)
146: break;
147: bn -= sh;
148: }
149: if (j == 0) {
150: printf("bn ovf %D\n", bn);
151: return ((daddr_t)0);
152: }
153:
154: /*
155: * fetch the first indirect block address from the inode
156: */
157: nb = ip->i_ib[NIADDR - j];
158: if (nb == 0) {
159: printf("bn void %D\n",bn);
160: return((daddr_t)0);
161: }
162:
163: /*
164: * fetch through the indirect blocks
165: */
166: for (; j <= NIADDR; j++) {
167: if (blknos[j] != nb) {
168: io->i_bn = fsbtodb(&io->i_fs, nb);
169: io->i_ma = b[j];
170: io->i_cc = io->i_fs.fs_bsize;
171: if (devread(&io->i_si) != io->i_cc)
172: return((daddr_t)0);
173: blknos[j] = nb;
174: }
175: bap = (daddr_t *)b[j];
176: sh /= NINDIR(&io->i_fs);
177: i = (bn / sh) % NINDIR(&io->i_fs);
178: nb = bap[i];
179: if(nb == 0) {
180: printf("bn void %D\n",bn);
181: return((daddr_t)0);
182: }
183: }
184: return(nb);
185: #else BOOTBLOCK
186: return((daddr_t)0);
187: #endif BOOTBLOCK
188: }
189:
190: static ino_t
191: dlook(s, io)
192: char *s;
193: register struct iob *io;
194: {
195: register struct direct *dp;
196: register struct inode *ip;
197: struct dirstuff dirp;
198: register int len;
199:
200: ip = &io->i_ino;
201: #ifndef BOOTBLOCK
202: if (s == NULL || *s == '\0')
203: return(0);
204: if ((ip->i_mode&IFMT) != IFDIR) {
205: printf("not a directory\n");
206: return(0);
207: }
208: if (ip->i_size == 0) {
209: printf("zero length directory\n");
210: return(0);
211: }
212: #endif
213: len = strlen(s);
214: dirp.loc = 0;
215: dirp.io = io;
216: for (dp = readdir(&dirp); dp != NULL; dp = readdir(&dirp)) {
217: if(dp->d_ino == 0)
218: continue;
219: if (dp->d_namlen == len && !strcmp(s, dp->d_name))
220: return(dp->d_ino);
221: #ifndef BOOTBLOCK
222: /* Allow "*" to print all names at that level, w/out match */
223: if (!strcmp(s, "*"))
224: printf("%s\n", dp->d_name);
225: #endif
226: }
227: return(0);
228: }
229:
230: /*
231: * get next entry in a directory.
232: */
233: struct direct *
234: readdir(dirp)
235: register struct dirstuff *dirp;
236: {
237: register struct direct *dp;
238: register struct iob *io;
239: register daddr_t lbn, d;
240: register int off;
241:
242: io = dirp->io;
243: for(;;) {
244: if (dirp->loc >= io->i_ino.i_size)
245: return NULL;
246: off = blkoff(&io->i_fs, dirp->loc);
247: if (off == 0) {
248: lbn = lblkno(&io->i_fs, dirp->loc);
249: d = sbmap(io, lbn);
250: if(d == 0)
251: return NULL;
252: io->i_bn = fsbtodb(&io->i_fs, d);
253: io->i_ma = io->i_buf;
254: io->i_cc = blksize(&io->i_fs, &io->i_ino, lbn);
255: if (devread(&io->i_si) != io->i_cc)
256: return NULL;
257: }
258: dp = (struct direct *)(io->i_buf + off);
259: dirp->loc += dp->d_reclen;
260: if (dp->d_ino == 0)
261: continue;
262: return (dp);
263: }
264: }
265:
266: lseek(fdesc, addr, ptr)
267: int fdesc;
268: register off_t addr;
269: int ptr;
270: {
271: register struct iob *io;
272:
273: #ifndef BOOTBLOCK
274: fdesc -= 3;
275: if (fdesc < 0 || fdesc >= NFILES ||
276: ((io = &iob[fdesc])->i_flgs & F_ALLOC) == 0)
277: return(-1);
278: #else
279: io = &iob[fdesc - 3];
280: #endif
281: io->i_si.si_flgs &= ~F_EOF;
282: io->i_offset = addr;
283: io->i_bn = addr / DEV_BSIZE;
284: io->i_cc = 0;
285: return(0);
286: }
287:
288: /* FIXME: possibly make this static and pass iob, eliminating assorted tests? */
289: getc(fdesc)
290: int fdesc;
291: {
292: register struct iob *io;
293: register struct fs *fs;
294: register char *p;
295: register int c, off, size, diff;
296: register daddr_t lbn;
297:
298:
299: #ifndef BOOTBLOCK
300: if (fdesc >= 0 && fdesc <= 2)
301: return(getchar());
302: fdesc -= 3;
303: if (fdesc < 0 || fdesc >= NFILES ||
304: ((io = &iob[fdesc])->i_flgs&F_ALLOC) == 0)
305: return(-1);
306: #else
307: io = &iob[fdesc -= 3];
308: #endif
309: p = io->i_ma;
310: if (io->i_cc <= 0) {
311: if ((io->i_flgs & F_FILE) != 0) {
312: diff = io->i_ino.i_size - io->i_offset;
313: if (diff <= 0)
314: return (-1);
315: fs = &io->i_fs;
316: lbn = lblkno(fs, io->i_offset);
317: io->i_bn = fsbtodb(fs, sbmap(io, lbn));
318: off = blkoff(fs, io->i_offset);
319: size = blksize(fs, &io->i_ino, lbn);
320: } else {
321: io->i_bn = io->i_offset / DEV_BSIZE;
322: off = 0;
323: size = DEV_BSIZE;
324: }
325: io->i_ma = io->i_buf;
326: io->i_cc = size;
327: if (devread(&io->i_si) != io->i_cc) /* Trap errors */
328: return(-1);
329: if ((io->i_flgs & F_FILE) != 0) {
330: if (io->i_offset - off + size >= io->i_ino.i_size)
331: io->i_cc = diff + off;
332: io->i_cc -= off;
333: }
334: p = &io->i_buf[off];
335: }
336: io->i_cc--;
337: io->i_offset++;
338: c = (unsigned)*p++;
339: io->i_ma = p;
340: return(c);
341: }
342:
343:
344: read(fdesc, buf, count)
345: int fdesc;
346: register char *buf;
347: int count;
348: {
349: register i,j;
350: register struct iob *file;
351:
352: #ifndef BOOTBLOCK
353: if (fdesc >= 0 && fdesc <= 2) {
354: i = count;
355: do {
356: *buf = getchar();
357: } while (--i && *buf++ != '\n');
358: return(count - i);
359: }
360: fdesc -= 3;
361: if (fdesc < 0 || fdesc >= NFILES ||
362: ((file = &iob[fdesc])->i_flgs&F_ALLOC) == 0)
363: return(-1);
364: if ((file->i_flgs&F_READ) == 0)
365: return(-1);
366: fdesc += 3;
367: #else BOOTBLOCK
368: file = &iob[fdesc - 3];
369: #endif BOOTBLOCK
370: if ((file->i_flgs & F_FILE) == 0) {
371: file->i_cc = count;
372: file->i_ma = buf;
373: file->i_bn = (file->i_offset / DEV_BSIZE);
374: i = devread(&file->i_si);
375: file->i_offset += count;
376: return(i);
377: } else {
378: if (file->i_offset+count > file->i_ino.i_size)
379: count = file->i_ino.i_size - file->i_offset;
380: if ((i = count) <= 0)
381: return(0);
382: #ifdef BOOTBLOCK
383: do {
384: *buf++ = getc(fdesc);
385: } while (--i);
386: #else BOOTBLOCK
387: while (i > 0) {
388: if ((j = file->i_cc) <= 0) {
389: *buf++ = getc(fdesc);
390: i--;
391: } else {
392: if (i < j)
393: j = i;
394: bcopy(file->i_ma, buf, (unsigned)j);
395: buf += j;
396: file->i_ma += j;
397: file->i_offset += j;
398: file->i_cc -= j;
399: i -= j;
400: }
401: }
402: #endif BOOTBLOCK
403: return(count);
404: }
405: }
406:
407: #ifndef BOOTBLOCK
408: write(fdesc, buf, count)
409: int fdesc;
410: char *buf;
411: int count;
412: {
413: register i;
414: register struct iob *file;
415:
416: if (fdesc >= 0 && fdesc <= 2) {
417: i = count;
418: while (i--)
419: putchar(*buf++);
420: return(count);
421: }
422: fdesc -= 3;
423: if (fdesc < 0 || fdesc >= NFILES ||
424: ((file = &iob[fdesc])->i_flgs&F_ALLOC) == 0)
425: return(-1);
426: if ((file->i_flgs&F_WRITE) == 0)
427: return(-1);
428: if (count % DEV_BSIZE)
429: printf("count=%d?\n", count);
430: file->i_cc = count;
431: file->i_ma = buf;
432: file->i_bn = (file->i_offset / DEV_BSIZE);
433: i = devwrite(&file->i_si);
434: file->i_offset += count;
435: return(i);
436: }
437: #endif BOOTBLOCK
438:
439: /*
440: * Open a file on a physical device, or open the device itself.
441: *
442: * The device is identified by a struct bootparam which gives pointers
443: * to the struct boottab, containing the device open, strategy and close
444: * routines; and the device parameters such as controller #, unit #, etc.
445: *
446: * If *str == 0, the device is opened, else the named file in the file
447: * system on the device is opened.
448: */
449: int
450: physopen(bp, str, how)
451: register struct bootparam *bp;
452: char *str;
453: int how;
454: {
455: int fdesc;
456: register struct iob *file;
457:
458: #ifdef BOOTBLOCK
459: fdesc = 0;
460: file = &iob[0];
461: file->i_flgs |= F_ALLOC;
462: #else BOOTBLOCK
463: fdesc = getiob(); /* Allocate an IOB */
464: file = &iob[fdesc];
465: #endif BOOTBLOCK
466:
467: file->i_boottab = bp->bp_boottab; /* Record pointer to boot table */
468: file->i_ctlr = bp->bp_ctlr;
469: file->i_unit = bp->bp_unit;
470: file->i_boff = bp->bp_part;
471: file->i_ino.i_dev = 0; /* Call it device 0 for chuckles */
472:
473: return(openfile(fdesc, file, str, how));
474: }
475:
476: #ifndef BOOTBLOCK
477:
478: int openfirst = 1;
479:
480: /*
481: * Allocate an IOB for a newly opened file.
482: */
483: int
484: getiob()
485: {
486: register int fdesc;
487:
488: if (openfirst) {
489: openfirst = 0;
490: for (fdesc = 0; fdesc < NFILES; fdesc++)
491: iob[fdesc].i_flgs = 0;
492: }
493:
494: for (fdesc = 0; fdesc < NFILES; fdesc++)
495: if (iob[fdesc].i_flgs == 0)
496: goto gotfile;
497: _stop("No more file slots");
498: gotfile:
499: (&iob[fdesc])->i_flgs |= F_ALLOC;
500: return fdesc;
501: }
502:
503: /* Hex string scanner for open() */
504: static char *
505: openhex(p, ip)
506: register char *p;
507: int *ip;
508: {
509: register int ac = 0;
510:
511: while (*p) {
512: if (*p >= '0' && *p <= '9')
513: ac = (ac<<4) + (*p - '0');
514: else if (*p >= 'a' && *p <= 'f')
515: ac = (ac<<4) + (*p - 'a' + 10);
516: else if (*p >= 'A' && *p <= 'F')
517: ac = (ac<<4) + (*p - 'A' + 10);
518: else
519: break;
520: p++;
521: }
522: if (*p == ',')
523: p++;
524: *ip = ac;
525: return (p);
526: }
527:
528: /*
529: * Open a device or file-in-file-system-on-device.
530: */
531: int
532: open(str, how)
533: char *str;
534: int how;
535: {
536: register char *cp;
537: register struct iob *file;
538: register struct boottab *dp;
539: register struct boottab **tablep;
540: int fdesc;
541: long atol();
542:
543: extern struct boottab *(devsw[]);
544:
545: fdesc = getiob(); /* Allocate an IOB */
546: file = &iob[fdesc];
547:
548: for (cp = str; *cp && *cp != '('; cp++)
549: ;
550: if (*cp++ != '(') {
551: file->i_flgs = 0;
552: goto badsyntax;
553: }
554: for (tablep = devsw; 0 != (dp = *tablep); tablep++) {
555: if (str[0] == dp->b_dev[0] && str[1] == dp->b_dev[1])
556: goto gotdev;
557: }
558: printf("Unknown device: %c%c; known devices:\n", str[0], str[1]);
559: for (tablep = devsw; 0 != (dp = *tablep); tablep++)
560: printf(" %s\n", dp->b_desc);
561: file->i_flgs = 0;
562: return(-1);
563: gotdev:
564: file->i_boottab = dp; /* Record pointer to boot table */
565: file->i_ino.i_dev = tablep-devsw;
566: #ifdef sun
567: cp = openhex(cp, &file->i_ctlr);
568: #endif
569: cp = openhex(cp, &file->i_unit);
570: cp = openhex(cp, (int *)&file->i_boff);
571: if (*cp == '\0') goto doit;
572: if (*cp != ')') {
573: badsyntax:
574: printf("%s: bad syntax, try dev(ctlr,unit,part)name\n", str);
575: return -1;
576: }
577: do
578: cp++;
579: while (*cp == ' ');
580:
581: doit:
582: return(openfile(fdesc, file, cp, how));
583: }
584: #endif NOOPEN
585:
586:
587: /*
588: * File processing for open call
589: */
590: openfile(fdesc, file, cp, how)
591: int fdesc;
592: struct iob *file;
593: char *cp;
594: int how;
595: {
596: ino_t ino;
597:
598: if (devopen(&file->i_si)) {
599: file->i_flgs = 0;
600: return(-1); /* if devopen fails, open fails */
601: }
602:
603: if (*cp == '\0') { /* Opening a device */
604: file->i_flgs |= how+1;
605: file->i_cc = 0;
606: file->i_offset = 0;
607: return(fdesc+3);
608: }
609: /* Opening a file system; read the superblock. */
610: file->i_ma = (char *)(&file->i_fs);
611: file->i_cc = SBSIZE;
612: file->i_bn = SBLOCK;
613: file->i_offset = 0;
614: if (devread(&file->i_si) != SBSIZE) {
615: file->i_flgs = 0;
616: return(-1);
617: }
618: #ifndef BOOTBLOCK
619: if (file->i_fs.fs_magic != FS_MAGIC) {
620: printf("Not a file system\n");
621: return(-1);
622: }
623: #endif
624: if ((ino = find(cp, file)) == 0) {
625: file->i_flgs = 0;
626: return(-1);
627: }
628: #ifndef BOOTBLOCK
629: if (how != 0) {
630: printf("Can't write files yet.. Sorry\n");
631: file->i_flgs = 0;
632: return(-1);
633: }
634: #endif
635: openi(ino, file);
636: file->i_offset = 0;
637: file->i_cc = 0;
638: file->i_flgs |= F_FILE | (how+1);
639: return(fdesc+3);
640: }
641:
642:
643: close(fdesc)
644: int fdesc;
645: {
646: register struct iob *file;
647:
648: fdesc -= 3;
649: if (fdesc < 0 || fdesc >= NFILES ||
650: ((file = &iob[fdesc])->i_flgs&F_ALLOC) == 0)
651: return(-1);
652: devclose(&file->i_si); /* For a file-in-filesys or for raw dev */
653: file->i_flgs = 0;
654: return(0);
655: }
656:
657: exit()
658: {
659: _stop((char *)0);
660: }
661:
662: _stop(s)
663: char *s;
664: {
665: register int i;
666:
667: for (i = 0; i < NFILES; i++)
668: if (iob[i].i_flgs != 0)
669: close(i);
670: if (s) printf("%s\n", s);
671: _exit();
672: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.