![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dutil.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [XINU] / xinu / sys / LSI|
Return to dutil.c CVS log | Up to [XINU] / xinu / sys / LSI |
1.1 root 1: /* dutil.c - dutil */
2:
3: #include <conf.h>
4: #include <kernel.h>
5: #include <proc.h>
6: #include <disk.h>
7: #include <lfile.h>
8: #include <dir.h>
9: #include <tty.h>
10:
11: #define TERMEOF '\004' /* interpreted as EOF at console*/
12: #define DISKID 33 /* an arbitrary disk id number */
13: #ifndef DISK0
14: #define DISK0 4
15: #endif
16:
17: struct dir *dirptr; /* pointer to the in-core dir */
18: int diskdev; /* disk device operated on */
19: int dsize; /* disk size in blocks */
20: int niblks; /* number of i-blocks this disk */
21: char buf[200]; /* buffer for input line */
22: char dbuff[DBUFSIZ]; /* one disk buffer */
23: char msg[] =
24: "Choose from: dir, read, write, create, or type help\n";
25: #define PROMPT "\ncmd: "
26: char arg1[150];
27: char arg2[150];
28: Bool verbose;
29:
30: struct cmdname { /* list of valid commands */
31: char *cname;
32: int cargs;
33: char *cexpl;
34: } cmds[] = { "append", 2, "append file1 onto file2",
35: "create", 1, "create a new (empty) file",
36: "dir", 0, "list directory",
37: "exec", 1, "execute a program from disk",
38: "freeze", 1, "freeze this program & save",
39: "help", 0, "print this page of info",
40: "iblock", 1, "print an iblock",
41: "init", 1, "initialize disk device number",
42: "mkfs", 0, "make a file system",
43: "name", 2, "rename file1 to file2",
44: "quit", 0, "quit running this program",
45: "read", 1, "read a file and display it",
46: "size", 0, "report the size of the disk",
47: "trace", 1, "trace a file's iblock list",
48: "verbose", 1, "set verbose output y or n",
49: "write", 1, "write a file from terminal",
50: "zap", 1, "remove a file from the disk",
51: "?", 0, "synonym for 'help'"};
52: #define NCMDS sizeof(cmds)/sizeof(struct cmdname)
53: int ncmds;
54:
55:
56: /*------------------------------------------------------------------------
57: * dutil -- general disk utility program.
58: *------------------------------------------------------------------------
59: */
60: dutil()
61: {
62: int ret;
63:
64: kprintf("\n\n*** Disk Utility Program ***\n\n");
65: diskdev = DISK0;
66: verbose = FALSE;
67: ncmds = NCMDS;
68: kprintf("Starting with disk DISK0 (device id = %d)",diskdev);
69: kprintf(" type '?' for help\n");
70: dirptr = dsdirec(diskdev);
71: sizeup(diskdev);
72: while (1) {
73: switch( getcmd() ) {
74:
75: case 0: ret = duapp(diskdev, arg1, arg2);
76: break;
77:
78: case 1: ret = ducreat(diskdev, arg1);
79: break;
80:
81: case 2: ret = dudir(diskdev);
82: break;
83:
84: case 3: ret = duexec(diskdev, arg1);
85: break;
86:
87: case 4: ret = dufreeze(diskdev, arg1);
88: break;
89:
90: case 5: ret = duhelp();
91: break;
92:
93: case 6: ret = duiblk(diskdev, arg1);
94: break;
95:
96: case 7: ret = duinit(arg1);
97: if (ret != SYSERR)
98: diskdev = ret;
99: break;
100:
101: case 8: ret = dupmkfs(diskdev);
102: break;
103:
104: case 9: ret = duname(diskdev, arg1, arg2);
105: break;
106:
107: case 10: ret = duquit();
108: break;
109:
110: case 11: ret = duread(diskdev, arg1);
111: break;
112:
113: case 12: ret = dusize(diskdev);
114: break;
115:
116: case 13: ret = dutrace(diskdev, arg1);
117: break;
118:
119: case 14: ret = duverbose(arg1);
120: break;
121:
122: case 15: ret = duwrite(diskdev, arg1);
123: break;
124:
125: case 16: ret = duzap(diskdev, arg1);
126: break;
127:
128: case 17: ret = duhelp();
129: break;
130:
131: default: ret = SYSERR;
132:
133: }
134: if (verbose)
135: kprintf("Command completed with code %d\n",ret);
136: }
137: }
138:
139:
140: /*------------------------------------------------------------------------
141: * duapp -- append one file to the end of another
142: *------------------------------------------------------------------------
143: */
144: duapp(diskdev, from, to)
145: int diskdev;
146: char *from, *to;
147: {
148: int f1, f2;
149: int ich;
150:
151: if (verbose)
152: kprintf("Appending files...\n");
153: if ( (f2=open(diskdev,to,"rwo")) == SYSERR) {
154: kprintf("Can't open file %s\n",to);
155: return(SYSERR);
156: }
157: if (verbose)
158: kprintf("device id for file '%s' is %d\n",to,f2);
159: if (strcmp(from,"-") == 0)
160: f1 = CONSOLE;
161: else
162: if ( (f1=open(diskdev,from,"ro")) == SYSERR) {
163: kprintf("Can't open input file %s\n",from);
164: close(f2);
165: return(SYSERR);
166: }
167: if (verbose)
168: kprintf("device id for file '%s' is %d\n",from,f1);
169: while ( (ich=getc(f2)) != EOF)
170: if (ich == SYSERR)
171: kprintf("Error positioning file %s\n",to);
172: while ( (ich=inchar(f1)) != EOF) {
173: if (ich == SYSERR) {
174: kprintf("Error reading file %s\n", from);
175: close(f1);
176: close(f2);
177: return(SYSERR);
178: }
179: putc(f2, ich);
180: }
181: close(f1);
182: close(f2);
183: return(OK);
184: }
185:
186:
187: /*------------------------------------------------------------------------
188: * ducreat -- create an empty disk file given its name
189: *------------------------------------------------------------------------
190: */
191: ducreat(diskdev, name)
192: int diskdev;
193: char *name;
194: {
195: int f1;
196:
197: if (verbose)
198: kprintf("Creating file %s\n", name);
199: if ( (f1=open(diskdev,name,"nr")) == SYSERR) {
200: kprintf("Can't create new file %s\n", name);
201: return(SYSERR);
202: }
203: close(f1);
204: return(OK);
205: }
206:
207:
208: /*------------------------------------------------------------------------
209: * duexec -- unfreeze a program and execute from disk
210: *------------------------------------------------------------------------
211: */
212: duexec(diskdir, name)
213: int diskdir;
214: char *name;
215: {
216: int f1;
217:
218: if ( (f1=open(diskdev, name, "ro")) == SYSERR) {
219: kprintf("Can't frind program %s\n", name);
220: return(SYSERR);
221: }
222: kprintf("Command not implemented\n");
223: close(f1);
224: return(SYSERR);
225: }
226:
227:
228: /*------------------------------------------------------------------------
229: * dufreeze -- freeze this program and save it on disk
230: *------------------------------------------------------------------------
231: */
232: dufreeze(diskdev, name)
233: int diskdev;
234: char *name;
235: {
236: int f1;
237:
238: if ( (f1 = open(diskdev,name,"wn")) == SYSERR) {
239: kprintf("Can't create file %s\n", name);
240: return(SYSERR);
241: }
242: kprintf("Command not implemented\n");
243: close(f1);
244: return(SYSERR);
245: }
246:
247:
248: /*------------------------------------------------------------------------
249: * duhelp -- print help message
250: *------------------------------------------------------------------------
251: */
252: duhelp()
253: {
254: int i, len;
255:
256: kprintf("\nCommands available are:\n\n");
257: kprintf(" Command #args Description\n");
258: for (i=0 ; i<ncmds ; i++) {
259: kprintf(" %s",cmds[i].cname);
260: for (len=strlen(cmds[i].cname) ; len<16 ; len++)
261: kprintf(" ");
262: kprintf("%d %s\n",cmds[i].cargs, cmds[i].cexpl);
263: }
264: kprintf("\n");
265: return(OK);
266: }
267:
268:
269: /*------------------------------------------------------------------------
270: * duiblk -- print an iblock given its index
271: *------------------------------------------------------------------------
272: */
273: duiblk(diskdev, arg)
274: int diskdev;
275: char *arg;
276: {
277: struct iblk iblock;
278: int k, j;
279: char ch;
280: IBADDR ibnum;
281:
282: for (ibnum=0 ; (ch = *arg)!='\000' ; arg++) {
283: if (ch<'0' || ch>'9')
284: return(SYSERR);
285: ibnum = 10*ibnum + (ch - '0');
286: }
287: if (ibnum < 0)
288: return(SYSERR);
289: ibget(diskdev, ibnum, &iblock);
290: kprintf("iblock %d: offset=%U next=%d\n\n ",
291: ibnum, iblock.ib_byte, iblock.ib_next);
292: for (j=IBLEN-1 ; j>=0&&iblock.ib_dba[j]==DBNULL ; j--)
293: ;
294: if (j < 0)
295: kprintf("empty\n");
296: else {
297: for (k=0 ; k<=j ; k++)
298: kprintf("%u ", iblock.ib_dba[k]);
299: kprintf("\n");
300: }
301: return(OK);
302: }
303:
304:
305: /*------------------------------------------------------------------------
306: * duinit -- initialize disk drive number and size
307: *------------------------------------------------------------------------
308: */
309: duinit(drive)
310: char *drive;
311: {
312: int i,n;
313: char ch;
314:
315: n = 0;
316: for (i=0 ; i<20 ; i++) {
317: if ( (ch = *drive++) == '\000' || ch=='\n') {
318: sizeup(n);
319: return(n);
320: } else {
321: if (ch<'0' || ch>'9') {
322: kprintf("Digit expected; got '%c'\n",ch);
323: return(SYSERR);
324: }
325: n = 10*n + (ch - '0');
326: }
327: }
328: kprintf("Argument too long.\n");
329: return(SYSERR);
330: }
331:
332:
333: /*------------------------------------------------------------------------
334: * dupmkfs -- make a file system from scratch
335: *------------------------------------------------------------------------
336: */
337: dupmkfs(diskdev)
338: int diskdev;
339: {
340: int ret;
341:
342: if (verbose)
343: kprintf("Making a file system...\n");
344: ret = dumkfs(diskdev, niblks, dsize, DISKID, verbose);
345: return(ret);
346: }
347:
348: /*------------------------------------------------------------------------
349: * duname -- rename one file into another
350: *------------------------------------------------------------------------
351: */
352: duname(diskdev, fname, tname)
353: int diskdev;
354: char *fname;
355: char *tname;
356: {
357: struct fdes *fdptr, *fdptr2;
358: struct dir *dirptr;
359: int i, pos;
360: int sem;
361:
362: if (verbose)
363: kprintf("Renaming file '%s' to '%s'\n", fname, tname);
364: dirptr = dsdirec(diskdev);
365: sem = ( (struct dsblk *)devtab[diskdev].dvioblk)->ddirsem;
366: wait(sem);
367: for (pos= -1,i=0 ; i<dirptr->d_nfiles ; i++) {
368: fdptr = &dirptr->d_files[i];
369: if (strcmp(fname, fdptr->fdname) == 0) {
370: pos = i;
371: } else if (strcmp(tname, fdptr->fdname) == 0) {
372: kprintf("File '%s' already exists\n",tname);
373: signal(sem);
374: return(SYSERR);
375: }
376: }
377: if (pos >= 0) {
378: strcpy(dirptr->d_files[pos].fdname, tname);
379: write(diskdev, dskbcpy(dirptr), DIRBLK);
380: signal(sem);
381: return(OK);
382: }
383: kprintf("File '%s' not found in directory\n", fname);
384: signal(sem);
385: return(SYSERR);
386: }
387:
388:
389: /*------------------------------------------------------------------------
390: * duquit -- stop executing
391: *------------------------------------------------------------------------
392: */
393: duquit()
394: {
395: int i;
396:
397: if (verbose)
398: kprintf("Exiting utility program...\n");
399: for (i=1 ; i<NPROC ; i++)
400: if (i != currpid)
401: kill(i);
402: kill(currpid);
403: }
404:
405:
406: /*------------------------------------------------------------------------
407: * duread -- read a file and display on the terminal
408: *------------------------------------------------------------------------
409: */
410: duread(diskdev, fname)
411: int diskdev;
412: char *fname;
413: {
414: int f, ich;
415:
416: if (verbose)
417: kprintf("Read file %s\n", fname);
418: if ( (f=open(diskdev, fname, "ro")) == SYSERR) {
419: kprintf("Can't open file %s\n", fname);
420: return(SYSERR);
421: }
422: while( (ich=getc(f)) != EOF )
423: if (ich == SYSERR) {
424: kprintf("***ERROR ON READ***\n");
425: return(SYSERR);
426: } else
427: kprintf("%c", ich);
428: close(f);
429: return(OK);
430: }
431:
432:
433: /*------------------------------------------------------------------------
434: * dusize -- size the disk and print out the number of blocks
435: *------------------------------------------------------------------------
436: */
437: dusize()
438: {
439: kprintf("Disk has %u blocks on it\n", dsize);
440: }
441:
442:
443: /*------------------------------------------------------------------------
444: * dutrace -- trace the iblock list for a given file
445: *------------------------------------------------------------------------
446: */
447: dutrace(diskdev, fname)
448: int diskdev;
449: char *fname;
450: {
451: int f;
452: int inum, i, j,k;
453: struct iblk iblock;
454: struct flblk *flptr;
455:
456: if (verbose)
457: kprintf("Tracing iblocks for file %s\n", fname);
458: if ( (f=open(diskdev, fname, "ro")) == SYSERR) {
459: kprintf("Can't open file %s\n", fname);
460: return(SYSERR);
461: }
462: flptr = (struct flblk *)devtab[f].dvioblk;
463: inum = flptr->fl_iba;
464: for (i=0 ; inum!=IBNULL && i<10 ; i++) {
465: kprintf("iblock %d: ",inum);
466: ibget(diskdev, inum, &iblock);
467: for (j=IBLEN-1 ; j>=0&&iblock.ib_dba[j]==DBNULL ; j--)
468: ;
469: if (j < 0)
470: kprintf("empty\n");
471: else {
472: for (k=0 ; k<=j ; k++)
473: kprintf("%u ", iblock.ib_dba[k]);
474: kprintf("\n");
475: }
476: inum = iblock.ib_next;
477: }
478: close(f);
479: return(OK);
480: }
481:
482: /*------------------------------------------------------------------------
483: * duverbose -- turn on/off verbose output switch
484: *------------------------------------------------------------------------
485: */
486: duverbose(arg)
487: char *arg;
488: {
489: int len;
490:
491: if (verbose)
492: kprintf("Setting verbose option.\n");
493: len = strlen(arg);
494: if (len<=3 && strncmp(arg,"yes",len) == 0) {
495: verbose = TRUE;
496: return(OK);
497: } else if (len<=2 && strncmp(arg,"no",len) == 0) {
498: verbose = FALSE;
499: return(OK);
500: }
501: kprintf("Argument must be 'yes' or 'no', not '%s'\n", arg);
502: return(SYSERR);
503: }
504:
505:
506: /*------------------------------------------------------------------------
507: * duwrite -- overwrite a file taking input from terminal
508: *------------------------------------------------------------------------
509: */
510: duwrite(diskdev, fname)
511: {
512: int f, ich;
513:
514: if (verbose)
515: kprintf("Writing file %s\n", fname);
516: if ( (f=open(diskdev,fname,"wo")) == SYSERR) {
517: kprintf("Error opening file %s -- will attempt to create\n",
518: fname);
519: if ( (f=open(diskdev,fname,"wn")) == SYSERR) {
520: kprintf("Can't create file %s\n", fname);
521: return(SYSERR);
522: }
523: }
524: kprintf("Enter text; terminate with CNTL-d\n\n");
525: while( (ich=inchar(CONSOLE)) != EOF )
526: putc(f, ich);
527: close(f);
528: return(OK);
529: }
530:
531:
532: /*------------------------------------------------------------------------
533: * dupzap -- zap a file from the directory
534: *------------------------------------------------------------------------
535: */
536: duzap(diskdev, fname)
537: int diskdev;
538: char *fname;
539: {
540: struct fdes *fdptr, *fdptr2;
541: struct dir *dirptr;
542: int i, j, sem;
543: IBADDR ilist;
544:
545: if (verbose)
546: kprintf("Removing file %s from directory\n", fname);
547: dirptr = dsdirec(diskdev);
548: sem = ((struct dsblk *)devtab[diskdev].dvioblk)->ddirsem;
549: wait(sem);
550: for (i=0 ; i<dirptr->d_nfiles ; i++) {
551: fdptr = &dirptr->d_files[i];
552: if (strcmp(fname, fdptr->fdname) == 0) {
553: ilist = fdptr->fdiba;
554: dirptr->d_nfiles--;
555: fdptr2 = &dirptr->d_files[i+1];
556: for (j=i ; j<dirptr->d_nfiles ; j++)
557: *fdptr++ = *fdptr2++;
558: write(diskdev, dskbcpy(dirptr), DIRBLK);
559: signal(sem);
560: iblfree(diskdev, ilist);
561: return(OK);
562: }
563: }
564: kprintf("File %s not found in directory\n", fname);
565: signal(sem);
566: return(SYSERR);
567: }
568:
569:
570: /*------------------------------------------------------------------------
571: * sizeup -- size up the disk and place number of blocks in dsize
572: *------------------------------------------------------------------------
573: */
574: LOCAL sizeup(diskdev)
575: int diskdev;
576: {
577: DBADDR low, high, mid;
578:
579: low = 0;
580: high = 31000;
581: while (low < high-1) {
582: mid = (DBADDR)(low + high)/(DBADDR)2;
583: if (read(diskdev,dbuff,mid) == SYSERR)
584: high = mid;
585: else
586: low = mid;
587: }
588: dsize = low+1;
589: niblks = dsize/20;
590: }
591:
592:
593: /*------------------------------------------------------------------------
594: * inchar -- get next input character
595: *------------------------------------------------------------------------
596: */
597: LOCAL inchar(dev)
598: {
599: int ich;
600:
601: if (dev!=CONSOLE)
602: return(getc(dev));
603: if ( (ich=getc(CONSOLE)) == TERMEOF) {
604: while( getc(CONSOLE) != NEWLINE)
605: ;
606: return(EOF);
607: } else
608: return(ich);
609: }
610:
611:
612: /*------------------------------------------------------------------------
613: * getcmd -- get next command and appropriate number of args.
614: *------------------------------------------------------------------------
615: */
616: getcmd()
617: {
618: int i;
619:
620: while (1) {
621: kprintf("%s", PROMPT);
622: i = duparse();
623: sleep10(1);
624: if (i != SYSERR)
625: return(i);
626: else
627: kprintf("%s\n", msg);
628: }
629: }
630:
631:
632: /*------------------------------------------------------------------------
633: * duparse -- parse one command line and return command index
634: *------------------------------------------------------------------------
635: */
636: LOCAL duparse()
637: {
638: int len, i, nargs, cindex;
639: char ch;
640:
641: while( (ch=getc(CONSOLE)) == ' ')
642: ;
643: for (len=0 ; ch!='\n' && ch!=' ' ; ch=getc(CONSOLE))
644: buf[len++] = ch;
645: if (len == 0)
646: return(SYSERR);
647: buf[len] = '\000';
648: if ( (cindex=lookup(len)) == SYSERR) {
649: read(CONSOLE, buf, 0);
650: return(SYSERR);
651: }
652: if ( (nargs=cmds[cindex].cargs) == 0) {
653: while (ch != '\n')
654: ch = getc(CONSOLE);
655: return(cindex);
656: }
657: while (ch == ' ')
658: ch=getc(CONSOLE);
659: if (ch == '\n') {
660: kprintf("\nToo few arguments for '%s'\n",
661: cmds[cindex].cname);
662: return(SYSERR);
663: }
664: for (len=0 ; ch!='\n' && ch!=' ' ; ch=getc(CONSOLE))
665: arg1[len++] = ch;
666: arg1[len] = '\000';
667: if ( (nargs=cmds[cindex].cargs) <= 1) {
668: while (ch != '\n')
669: ch = getc(CONSOLE);
670: return(cindex);
671: }
672: while (ch == ' ')
673: ch=getc(CONSOLE);
674: if (ch == '\n') {
675: kprintf("\nToo few arguments for '%s'\n",
676: cmds[cindex].cname);
677: return(SYSERR);
678: }
679: for (len=0 ; ch!='\n' && ch!=' ' ; ch=getc(CONSOLE))
680: arg2[len++] = ch;
681: arg2[len] = '\000';
682: while (ch != '\n')
683: ch = getc(CONSOLE);
684: return(cindex);
685: }
686:
687:
688: /*------------------------------------------------------------------------
689: * lookup -- lookup a command name in the table, returning its index
690: *------------------------------------------------------------------------
691: */
692: LOCAL lookup(len)
693: int len;
694: {
695: int i;
696:
697: for (i=0 ; i<ncmds ; i++)
698: if (len <= strlen(cmds[i].cname) &&
699: strncmp(cmds[i].cname, buf, len) == 0)
700: return(i);
701: return(SYSERR);
702: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.