![[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 [CSRG BSD Unix] / 43BSDTahoe / sys / stand|
Return to sys.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / stand |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)sys.c 7.7 (Berkeley) 7/1/88
7: */
8:
9: #include "param.h"
10: #include "inode.h"
11: #include "fs.h"
12: #include "dir.h"
13: #include "reboot.h"
14: #include "saio.h"
15:
16: #define isdigit(c) ((u_int)((c) - '0') <= 9)
17: #define isspace(c) ((c) == ' ' || (c) == '\t')
18: #define isupper(c) ((u_int)((c) - 'A') <= 'Z' - 'A')
19: #define tolower(c) ((c) - 'A' + 'a')
20:
21: ino_t dlook();
22:
23: struct dirstuff {
24: int loc;
25: struct iob *io;
26: };
27:
28: struct iob iob[NFILES];
29:
30: static
31: openi(n, io)
32: register struct iob *io;
33: {
34: register struct dinode *dp;
35: int cc;
36:
37: io->i_offset = 0;
38: io->i_bn = fsbtodb(&io->i_fs, itod(&io->i_fs, n)) + io->i_boff;
39: io->i_cc = io->i_fs.fs_bsize;
40: io->i_ma = io->i_buf;
41: cc = devread(io);
42: dp = (struct dinode *)io->i_buf;
43: io->i_ino.i_ic = dp[itoo(&io->i_fs, n)].di_ic;
44: return (cc);
45: }
46:
47: static
48: find(path, file)
49: register char *path;
50: struct iob *file;
51: {
52: register char *q;
53: char *dir, c;
54: int n;
55:
56: if (path == NULL || *path == '\0') {
57: printf("null path\n");
58: return (0);
59: }
60:
61: if (openi((ino_t) ROOTINO, file) < 0) {
62: printf("can't read root inode\n");
63: return (0);
64: }
65: dir = path;
66: while (*path) {
67: while (*path == '/')
68: path++;
69: q = path;
70: while(*q != '/' && *q != '\0')
71: q++;
72: c = *q;
73: *q = '\0';
74: if (q == path) path = "." ; /* "/" means "/." */
75:
76: if ((n = dlook(path, file, dir)) != 0) {
77: if (c == '\0')
78: break;
79: if (openi(n, file) < 0)
80: return (0);
81: *q = c;
82: path = q;
83: continue;
84: } else {
85: printf("%s: not found\n", path);
86: return (0);
87: }
88: }
89: return (n);
90: }
91:
92: #define NBUFS 4
93: static char b[NBUFS][MAXBSIZE];
94: static daddr_t blknos[NBUFS];
95:
96: static daddr_t
97: sbmap(io, bn)
98: register struct iob *io;
99: daddr_t bn;
100: {
101: register struct inode *ip;
102: int i, j, sh;
103: daddr_t nb, *bap;
104:
105: ip = &io->i_ino;
106: if (bn < 0) {
107: printf("bn negative\n");
108: return ((daddr_t)0);
109: }
110:
111: /*
112: * blocks 0..NDADDR are direct blocks
113: */
114: if(bn < NDADDR) {
115: nb = ip->i_db[bn];
116: return (nb);
117: }
118:
119: /*
120: * addresses NIADDR have single and double indirect blocks.
121: * the first step is to determine how many levels of indirection.
122: */
123: sh = 1;
124: bn -= NDADDR;
125: for (j = NIADDR; j > 0; j--) {
126: sh *= NINDIR(&io->i_fs);
127: if (bn < sh)
128: break;
129: bn -= sh;
130: }
131: if (j == 0) {
132: printf("bn ovf %D\n", bn);
133: return ((daddr_t)0);
134: }
135:
136: /*
137: * fetch the first indirect block address from the inode
138: */
139: nb = ip->i_ib[NIADDR - j];
140: if (nb == 0) {
141: printf("bn void %D\n",bn);
142: return ((daddr_t)0);
143: }
144:
145: /*
146: * fetch through the indirect blocks
147: */
148: for (; j <= NIADDR; j++) {
149: if (blknos[j] != nb) {
150: io->i_bn = fsbtodb(&io->i_fs, nb) + io->i_boff;
151: io->i_ma = b[j];
152: io->i_cc = io->i_fs.fs_bsize;
153: if (devread(io) != io->i_fs.fs_bsize) {
154: if (io->i_error)
155: errno = io->i_error;
156: printf("bn %D: read error\n", io->i_bn);
157: return ((daddr_t)0);
158: }
159: blknos[j] = nb;
160: }
161: bap = (daddr_t *)b[j];
162: sh /= NINDIR(&io->i_fs);
163: i = (bn / sh) % NINDIR(&io->i_fs);
164: nb = bap[i];
165: if(nb == 0) {
166: printf("bn void %D\n",bn);
167: return ((daddr_t)0);
168: }
169: }
170: return (nb);
171: }
172:
173: static ino_t
174: dlook(s, io, dir)
175: char *s;
176: register struct iob *io;
177: char *dir;
178: {
179: register struct direct *dp;
180: register struct inode *ip;
181: struct dirstuff dirp;
182: int len;
183:
184: if (s == NULL || *s == '\0')
185: return (0);
186: ip = &io->i_ino;
187: if ((ip->i_mode&IFMT) != IFDIR) {
188: printf("%s: not a directory\n", dir);
189: return (0);
190: }
191: if (ip->i_size == 0) {
192: printf("%s: zero length directory\n", dir);
193: return (0);
194: }
195: len = strlen(s);
196: dirp.loc = 0;
197: dirp.io = io;
198: for (dp = readdir(&dirp); dp != NULL; dp = readdir(&dirp)) {
199: if(dp->d_ino == 0)
200: continue;
201: if (dp->d_namlen == len && !strcmp(s, dp->d_name))
202: return (dp->d_ino);
203: }
204: return (0);
205: }
206:
207: /*
208: * get next entry in a directory.
209: */
210: struct direct *
211: readdir(dirp)
212: register struct dirstuff *dirp;
213: {
214: register struct direct *dp;
215: register struct iob *io;
216: daddr_t lbn, d;
217: int off;
218:
219: io = dirp->io;
220: for(;;) {
221: if (dirp->loc >= io->i_ino.i_size)
222: return (NULL);
223: off = blkoff(&io->i_fs, dirp->loc);
224: if (off == 0) {
225: lbn = lblkno(&io->i_fs, dirp->loc);
226: d = sbmap(io, lbn);
227: if(d == 0)
228: return (NULL);
229: io->i_bn = fsbtodb(&io->i_fs, d) + io->i_boff;
230: io->i_ma = io->i_buf;
231: io->i_cc = blksize(&io->i_fs, &io->i_ino, lbn);
232: if (devread(io) < 0) {
233: errno = io->i_error;
234: printf("bn %D: directory read error\n",
235: io->i_bn);
236: return (NULL);
237: }
238: }
239: dp = (struct direct *)(io->i_buf + off);
240: dirp->loc += dp->d_reclen;
241: if (dp->d_ino == 0)
242: continue;
243: return (dp);
244: }
245: }
246:
247: lseek(fdesc, addr, ptr)
248: int fdesc, ptr;
249: off_t addr;
250: {
251: register struct iob *io;
252:
253: #ifndef SMALL
254: if (ptr != L_SET) {
255: printf("Seek not from beginning of file\n");
256: errno = EOFFSET;
257: return (-1);
258: }
259: #endif
260: fdesc -= 3;
261: if (fdesc < 0 || fdesc >= NFILES ||
262: ((io = &iob[fdesc])->i_flgs & F_ALLOC) == 0) {
263: errno = EBADF;
264: return (-1);
265: }
266: io->i_offset = addr;
267: io->i_bn = addr / DEV_BSIZE;
268: io->i_cc = 0;
269: return (0);
270: }
271:
272: getc(fdesc)
273: int fdesc;
274: {
275: register struct iob *io;
276: register struct fs *fs;
277: register char *p;
278: int c, lbn, off, size, diff;
279:
280:
281: if (fdesc >= 0 && fdesc <= 2)
282: return (getchar());
283: fdesc -= 3;
284: if (fdesc < 0 || fdesc >= NFILES ||
285: ((io = &iob[fdesc])->i_flgs&F_ALLOC) == 0) {
286: errno = EBADF;
287: return (-1);
288: }
289: p = io->i_ma;
290: if (io->i_cc <= 0) {
291: if ((io->i_flgs & F_FILE) != 0) {
292: diff = io->i_ino.i_size - io->i_offset;
293: if (diff <= 0)
294: return (-1);
295: fs = &io->i_fs;
296: lbn = lblkno(fs, io->i_offset);
297: io->i_bn = fsbtodb(fs, sbmap(io, lbn)) + io->i_boff;
298: off = blkoff(fs, io->i_offset);
299: size = blksize(fs, &io->i_ino, lbn);
300: } else {
301: io->i_bn = io->i_offset / DEV_BSIZE;
302: off = 0;
303: size = DEV_BSIZE;
304: }
305: io->i_ma = io->i_buf;
306: io->i_cc = size;
307: if (devread(io) < 0) {
308: errno = io->i_error;
309: return (-1);
310: }
311: if ((io->i_flgs & F_FILE) != 0) {
312: if (io->i_offset - off + size >= io->i_ino.i_size)
313: io->i_cc = diff + off;
314: io->i_cc -= off;
315: }
316: p = &io->i_buf[off];
317: }
318: io->i_cc--;
319: io->i_offset++;
320: c = (unsigned)*p++;
321: io->i_ma = p;
322: return (c);
323: }
324:
325: int errno;
326:
327: read(fdesc, buf, count)
328: int fdesc, count;
329: char *buf;
330: {
331: register i, size;
332: register struct iob *file;
333: register struct fs *fs;
334: int lbn, off;
335:
336: errno = 0;
337: if (fdesc >= 0 & fdesc <= 2) {
338: i = count;
339: do {
340: *buf = getchar();
341: } while (--i && *buf++ != '\n');
342: return (count - i);
343: }
344: fdesc -= 3;
345: if (fdesc < 0 || fdesc >= NFILES ||
346: ((file = &iob[fdesc])->i_flgs&F_ALLOC) == 0) {
347: errno = EBADF;
348: return (-1);
349: }
350: if ((file->i_flgs&F_READ) == 0) {
351: errno = EBADF;
352: return (-1);
353: }
354: #ifndef SMALL
355: if ((file->i_flgs & F_FILE) == 0) {
356: file->i_cc = count;
357: file->i_ma = buf;
358: file->i_bn = file->i_boff + (file->i_offset / DEV_BSIZE);
359: i = devread(file);
360: if (i < 0)
361: errno = file->i_error;
362: else
363: file->i_offset += i;
364: return (i);
365: }
366: #endif
367: if (file->i_offset+count > file->i_ino.i_size)
368: count = file->i_ino.i_size - file->i_offset;
369: if ((i = count) <= 0)
370: return (0);
371: /*
372: * While reading full blocks, do I/O into user buffer.
373: * Anything else uses getc().
374: */
375: fs = &file->i_fs;
376: while (i) {
377: off = blkoff(fs, file->i_offset);
378: lbn = lblkno(fs, file->i_offset);
379: size = blksize(fs, &file->i_ino, lbn);
380: if (off == 0 && size <= i) {
381: file->i_bn = fsbtodb(fs, sbmap(file, lbn)) +
382: file->i_boff;
383: file->i_cc = size;
384: file->i_ma = buf;
385: if (devread(file) < 0) {
386: errno = file->i_error;
387: return (-1);
388: }
389: file->i_offset += size;
390: file->i_cc = 0;
391: buf += size;
392: i -= size;
393: } else {
394: size -= off;
395: if (size > i)
396: size = i;
397: i -= size;
398: do {
399: *buf++ = getc(fdesc+3);
400: } while (--size);
401: }
402: }
403: return (count);
404: }
405:
406: #ifndef SMALL
407: write(fdesc, buf, count)
408: int fdesc, count;
409: char *buf;
410: {
411: register i;
412: register struct iob *file;
413:
414: errno = 0;
415: if (fdesc >= 0 && fdesc <= 2) {
416: i = count;
417: while (i--)
418: putchar(*buf++);
419: return (count);
420: }
421: fdesc -= 3;
422: if (fdesc < 0 || fdesc >= NFILES ||
423: ((file = &iob[fdesc])->i_flgs&F_ALLOC) == 0) {
424: errno = EBADF;
425: return (-1);
426: }
427: if ((file->i_flgs&F_WRITE) == 0) {
428: errno = EBADF;
429: return (-1);
430: }
431: file->i_cc = count;
432: file->i_ma = buf;
433: file->i_bn = file->i_boff + (file->i_offset / DEV_BSIZE);
434: i = devwrite(file);
435: file->i_offset += count;
436: if (i < 0)
437: errno = file->i_error;
438: return (i);
439: }
440: #endif
441:
442: int openfirst = 1;
443: u_int opendev; /* last device opened */
444: extern u_int bootdev;
445:
446: open(str, how)
447: char *str;
448: int how;
449: {
450: register char *t;
451: register int cnt;
452: register struct iob *file;
453: int fdesc, args[8], *argp;
454:
455: if (openfirst) {
456: for (cnt = 0; cnt < NFILES; cnt++)
457: iob[cnt].i_flgs = 0;
458: openfirst = 0;
459: }
460:
461: for (fdesc = 0;; fdesc++) {
462: if (fdesc == NFILES)
463: _stop("No more file slots");
464: if (iob[fdesc].i_flgs == 0) {
465: file = &iob[fdesc];
466: file->i_flgs |= F_ALLOC;
467: file->i_adapt = file->i_ctlr = file->i_unit =
468: file->i_part = 0;
469: break;
470: }
471: }
472:
473: for (cnt = 0; cnt < sizeof(args)/sizeof(args[0]); args[cnt++] = 0);
474: #ifndef SMALL
475: for (t = str; *t && *t != '/' && *t != ':' && *t != '('; ++t)
476: if (isupper(*t))
477: *t = tolower(*t);
478: switch(*t) {
479: case '(': /* type(adapt, ctlr, drive, partition)file */
480: if ((file->i_ino.i_dev = getdev(str, t - str)) == -1)
481: goto bad;
482: for (argp = args + 4, cnt = 0; *t != ')'; ++cnt) {
483: for (++t; isspace(*t); ++t);
484: if (*t == ')')
485: break;
486: if (!isdigit(*t))
487: goto badspec;
488: *argp++ = atoi(t);
489: for (++t; isdigit(*t); ++t);
490: if (*t != ',' && *t != ')' || cnt == 4)
491: goto badspec;
492: }
493: for (++t; isspace(*t); ++t);
494: argp -= 4;
495: file->i_adapt = *argp++;
496: file->i_ctlr = *argp++;
497: file->i_unit = *argp++;
498: file->i_part = *argp;
499: break;
500: case ':': /* [A-Za-z]*[0-9]*[A-Za-z]:file */
501: for (t = str; *t != ':' && !isdigit(*t); ++t);
502: if ((file->i_ino.i_dev = getdev(str, t - str)) == -1)
503: goto bad;
504: if ((file->i_unit = getunit(t)) == -1)
505: goto bad;
506: for (; isdigit(*t); ++t);
507: if (*t >= 'a' && *t <= 'h')
508: file->i_part = *t++ - 'a';
509: if (*t != ':') {
510: errno = EOFFSET;
511: goto badspec;
512: }
513: for (++t; isspace(*t); ++t);
514: break;
515: case '/':
516: default: /* default bootstrap unit and device */
517: #else
518: {
519: #endif /* SMALL */
520: file->i_ino.i_dev = B_TYPE(bootdev);
521: file->i_adapt = B_ADAPTOR(bootdev);
522: file->i_ctlr = B_CONTROLLER(bootdev);
523: file->i_unit = B_UNIT(bootdev);
524: file->i_part = B_PARTITION(bootdev);
525: t = str;
526: }
527:
528: opendev = MAKEBOOTDEV(file->i_ino.i_dev, file->i_adapt, file->i_ctlr,
529: file->i_unit, file->i_part);
530:
531: if (errno = devopen(file))
532: goto bad;
533:
534: if (*t == '\0') {
535: file->i_flgs |= how + 1;
536: file->i_cc = 0;
537: file->i_offset = 0;
538: return (fdesc+3);
539: }
540: #ifndef SMALL
541: else if (how != 0) {
542: printf("Can't write files yet.. Sorry\n");
543: errno = EIO;
544: goto bad;
545: }
546: #endif
547: file->i_ma = (char *)(&file->i_fs);
548: file->i_cc = SBSIZE;
549: file->i_bn = SBOFF / DEV_BSIZE + file->i_boff;
550: file->i_offset = 0;
551: if (devread(file) < 0) {
552: errno = file->i_error;
553: printf("super block read error\n");
554: goto bad;
555: }
556: if ((cnt = find(t, file)) == 0) {
557: errno = ESRCH;
558: goto bad;
559: }
560: if (openi(cnt, file) < 0) {
561: errno = file->i_error;
562: goto bad;
563: }
564: file->i_offset = 0;
565: file->i_cc = 0;
566: file->i_flgs |= F_FILE | (how+1);
567: return (fdesc+3);
568:
569: #ifndef SMALL
570: badspec:
571: printf("malformed device specification\nusage: device(adaptor, controller, drive, partition)file\n");
572: #endif
573: bad:
574: file->i_flgs = 0;
575: return (-1);
576: }
577:
578: #ifndef SMALL
579: static
580: getdev(str, len)
581: register char *str;
582: int len;
583: {
584: register struct devsw *dp;
585: register int i;
586: char savedch = str[len];
587:
588: str[len] = '\0';
589: for (dp = devsw, i = 0; i < ndevs; dp++, i++)
590: if (dp->dv_name && strcmp(str, dp->dv_name) == 0) {
591: str[len] = savedch;
592: return (i);
593: }
594: printf("Unknown device\nKnown devices are:\n");
595: for (dp = devsw, i = 0; i < ndevs; dp++, i++)
596: if (dp->dv_name)
597: printf(" %s", dp->dv_name);
598: printf("\n");
599: errno = ENXIO;
600: return (-1);
601: }
602:
603: static
604: getunit(cp)
605: register char *cp;
606: {
607: int unit;
608:
609: unit = atoi(cp);
610: if ((u_int)unit > 255) {
611: printf("minor device number out of range (0-255)\n");
612: errno = EUNIT;
613: return (-1);
614: }
615: return (unit);
616: }
617: #endif /* SMALL */
618:
619: close(fdesc)
620: int fdesc;
621: {
622: struct iob *file;
623:
624: fdesc -= 3;
625: if (fdesc < 0 || fdesc >= NFILES ||
626: ((file = &iob[fdesc])->i_flgs&F_ALLOC) == 0) {
627: errno = EBADF;
628: return (-1);
629: }
630: if ((file->i_flgs&F_FILE) == 0)
631: devclose(file);
632: file->i_flgs = 0;
633: return (0);
634: }
635:
636: #ifndef SMALL
637: ioctl(fdesc, cmd, arg)
638: int fdesc, cmd;
639: char *arg;
640: {
641: register struct iob *file;
642: int error = 0;
643:
644: fdesc -= 3;
645: if (fdesc < 0 || fdesc >= NFILES ||
646: ((file = &iob[fdesc])->i_flgs&F_ALLOC) == 0) {
647: errno = EBADF;
648: return (-1);
649: }
650: switch (cmd) {
651:
652: case SAIOHDR:
653: file->i_flgs |= F_HDR;
654: break;
655:
656: case SAIOCHECK:
657: file->i_flgs |= F_CHECK;
658: break;
659:
660: case SAIOHCHECK:
661: file->i_flgs |= F_HCHECK;
662: break;
663:
664: case SAIONOBAD:
665: file->i_flgs |= F_NBSF;
666: break;
667:
668: case SAIODOBAD:
669: file->i_flgs &= ~F_NBSF;
670: break;
671:
672: default:
673: error = devioctl(file, cmd, arg);
674: break;
675: }
676: if (error < 0)
677: errno = file->i_error;
678: return (error);
679: }
680: #endif /* SMALL */
681:
682: exit()
683: {
684: _stop("Exit called");
685: }
686:
687: _stop(s)
688: char *s;
689: {
690: int i;
691:
692: for (i = 0; i < NFILES; i++)
693: if (iob[i].i_flgs != 0)
694: close(i);
695: printf("%s\n", s);
696: _rtt();
697: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.