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