![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fsdb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / etc|
Return to fsdb.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / etc |
1.1 ! root 1: /* ! 2: * Copyright (c) 1988 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * This code is derived from software contributed to Berkeley by ! 6: * Computer Consoles Inc. ! 7: * ! 8: * Redistribution and use in source and binary forms are permitted ! 9: * provided that the above copyright notice and this paragraph are ! 10: * duplicated in all such forms and that any documentation, ! 11: * advertising materials, and other materials related to such ! 12: * distribution and use acknowledge that the software was developed ! 13: * by the University of California, Berkeley. The name of the ! 14: * University may not be used to endorse or promote products derived ! 15: * from this software without specific prior written permission. ! 16: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 17: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 18: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 19: */ ! 20: ! 21: #ifndef lint ! 22: char copyright[] = ! 23: "@(#) Copyright (c) 1988 Regents of the University of California.\n\ ! 24: All rights reserved.\n"; ! 25: #endif /* not lint */ ! 26: ! 27: #ifndef lint ! 28: static char sccsid[] = "@(#)fsdb.c 5.3 (Berkeley) 6/18/88"; ! 29: #endif /* not lint */ ! 30: ! 31: /* ! 32: * fsdb - file system debugger ! 33: * ! 34: * usage: fsdb [options] special ! 35: * options: ! 36: * -? display usage ! 37: * -o override some error conditions ! 38: * -p"string" set prompt to string ! 39: * -w open for write ! 40: */ ! 41: ! 42: #include <sys/param.h> ! 43: #include <signal.h> ! 44: #include <sys/fs.h> ! 45: #include <sys/inode.h> ! 46: #include <sys/dir.h> ! 47: #include <sys/file.h> ! 48: #include <stdio.h> ! 49: #include <setjmp.h> ! 50: ! 51: /* ! 52: * Never changing defines. ! 53: */ ! 54: #define OCTAL 8 /* octal base */ ! 55: #define DECIMAL 10 /* decimal base */ ! 56: #define HEX 16 /* hexadecimal base */ ! 57: ! 58: /* ! 59: * Adjustable defines. ! 60: */ ! 61: #define NBUF 10 /* number of cache buffers */ ! 62: #define PROMPTSIZE 80 /* size of user definable prompt */ ! 63: #define MAXFILES 40000 /* max number of files ls can handle */ ! 64: #define FIRST_DEPTH 10 /* default depth for find and ls */ ! 65: #define SECOND_DEPTH 100 /* second try at depth (maximum) */ ! 66: #define INPUTBUFFER 1040 /* size of input buffer */ ! 67: #define BYTESPERLINE 16 /* bytes per line of /dxo output */ ! 68: #define NREG 36 /* number of save registers */ ! 69: ! 70: /* ! 71: * Values dependent on sizes of structs and such. ! 72: */ ! 73: #define NUMB 3 /* these three are arbitrary, */ ! 74: #define BLOCK 5 /* but must be different from */ ! 75: #define FRAGMENT 7 /* the rest (hence odd). */ ! 76: #define BITSPERCHAR 8 /* couldn't find it anywhere */ ! 77: #define CHAR (sizeof (char)) ! 78: #define SHORT (sizeof (short)) ! 79: #define LONG (sizeof (long)) ! 80: #define INODE (sizeof (struct dinode)) ! 81: #define DIRECTORY (sizeof (struct direct)) ! 82: #define CGRP (sizeof (struct cg)) ! 83: #define SB (sizeof (struct fs)) ! 84: #define BLKSIZE (fs->fs_bsize) /* for clarity */ ! 85: #define FRGSIZE (fs->fs_fsize) ! 86: #define BLKSHIFT (fs->fs_bshift) ! 87: #define FRGSHIFT (fs->fs_fshift) ! 88: ! 89: /* ! 90: * Messy macros that would otherwise clutter up such glamorous code. ! 91: */ ! 92: #define itob(i) ((itod(fs, (i)) << FRGSHIFT) + itoo(fs, (i)) * INODE) ! 93: #define min(x, y) ((x) < (y) ? (x) : (y)) ! 94: #define STRINGSIZE(d) ((long)d->d_reclen - \ ! 95: ((long)&d->d_name[0] - (long)&d->d_ino)) ! 96: #define letter(c) ((((c) >= 'a')&&((c) <= 'z')) ||\ ! 97: (((c) >= 'A')&&((c) <= 'Z'))) ! 98: #define digit(c) (((c) >= '0') && ((c) <= '9')) ! 99: #define HEXLETTER(c) (((c) >= 'A') && ((c) <= 'F')) ! 100: #define hexletter(c) (((c) >= 'a') && ((c) <= 'f')) ! 101: #define octaldigit(c) (((c) >= '0') && ((c) <= '7')) ! 102: #define uppertolower(c) ((c) - 'A' + 'a') ! 103: #define hextodigit(c) ((c) - 'a' + 10) ! 104: #define numtodigit(c) ((c) - '0') ! 105: #define loword(X) (((ushort *)&X)[1]) ! 106: #define lobyte(X) (((unsigned char *)&X)[1]) ! 107: ! 108: /* ! 109: * buffer cache structure. ! 110: */ ! 111: struct buf { ! 112: struct buf *fwd; ! 113: struct buf *back; ! 114: char *blkaddr; ! 115: short valid; ! 116: long blkno; ! 117: } buf[NBUF], bhdr; ! 118: ! 119: /* ! 120: * used to hold save registers (see '<' and '>'). ! 121: */ ! 122: struct save_registers { ! 123: long sv_addr; ! 124: long sv_value; ! 125: long sv_objsz; ! 126: } regs[NREG]; ! 127: ! 128: /* ! 129: * cd, find, and ls use this to hold filenames. Each filename is broken ! 130: * up by a slash. In other words, /usr/src/adm would have a len field ! 131: * of 2 (starting from 0), and filenames->fname[0-2] would hold usr, ! 132: * src, and adm components of the pathname. ! 133: */ ! 134: struct filenames { ! 135: long ino; /* inode */ ! 136: long len; /* number of components */ ! 137: char flag; /* flag if using SECOND_DEPTH allocator */ ! 138: char find; /* flag if found by find */ ! 139: char **fname; /* hold components of pathname */ ! 140: } *filenames, *top; ! 141: ! 142: struct fs filesystem, *fs; /* super block */ ! 143: ! 144: /* ! 145: * Global data. ! 146: */ ! 147: char *input_path[MAXPATHLEN]; ! 148: char *stack_path[MAXPATHLEN]; ! 149: char *current_path[MAXPATHLEN]; ! 150: char input_buffer[INPUTBUFFER]; ! 151: char *prompt; ! 152: char *buffers; ! 153: char scratch[64]; ! 154: char BASE[] = "o u x"; ! 155: char PROMPT[PROMPTSIZE] = "> "; ! 156: char laststyle = '/'; ! 157: char lastpo = 'x'; ! 158: short input_pointer; ! 159: short current_pathp; ! 160: short stack_pathp; ! 161: short input_pathp; ! 162: short cmp_level; ! 163: short nfiles; ! 164: short type = NUMB; ! 165: short dirslot; ! 166: short fd; ! 167: short c_count; ! 168: short error; ! 169: short paren; ! 170: short trapped; ! 171: short doing_cd; ! 172: short doing_find; ! 173: short find_by_name; ! 174: short find_by_inode; ! 175: short long_list; ! 176: short recursive; ! 177: short objsz = SHORT; ! 178: short override = 0; ! 179: short wrtflag; ! 180: short base = HEX; ! 181: short acting_on_inode; ! 182: short acting_on_directory; ! 183: short should_print = 1; ! 184: short clear; ! 185: short star; ! 186: long addr; ! 187: long bod_addr; ! 188: long value; ! 189: long erraddr; ! 190: long errcur_bytes; ! 191: long errino; ! 192: long errinum; ! 193: long cur_cgrp; ! 194: long cur_ino; ! 195: long cur_inum; ! 196: long cur_dir; ! 197: long cur_block; ! 198: long cur_bytes; ! 199: long find_ino; ! 200: long filesize; ! 201: long blocksize; ! 202: long stringsize; ! 203: long count = 1; ! 204: long commands; ! 205: long read_requests; ! 206: long actual_disk_reads; ! 207: jmp_buf env; ! 208: ! 209: extern char *malloc(), *calloc(); ! 210: char getachar(); ! 211: char *getblk(), *fmtentry(); ! 212: int err(); ! 213: long get(), bmap(), expr(), term(), getnumb(); ! 214: unsigned long *print_check(); ! 215: ! 216: /* ! 217: * main - lines are read up to the unprotected ('\') newline and ! 218: * held in an input buffer. Characters may be read from the ! 219: * input buffer using getachar() and unread using ungetachar(). ! 220: * Reading the whole line ahead allows the use of debuggers ! 221: * which would otherwise be impossible since the debugger ! 222: * and fsdb could not share stdin. ! 223: */ ! 224: ! 225: main(argc,argv) ! 226: short argc; ! 227: char **argv; ! 228: { ! 229: ! 230: register char c, *cptr; ! 231: register short i, j, *iptr; ! 232: register struct direct *dirp; ! 233: register struct buf *bp; ! 234: struct filenames *fn; ! 235: char *progname; ! 236: short colon, mode; ! 237: long temp; ! 238: unsigned block; ! 239: int ffcmp(); ! 240: ! 241: setbuf(stdin, NULL); ! 242: ! 243: progname = argv[0]; ! 244: prompt = &PROMPT[0]; ! 245: /* ! 246: * Parse options. ! 247: */ ! 248: while (argc>1 && argv[1][0] == '-') { ! 249: if (strcmp("-?", argv[1]) == 0) ! 250: goto usage; ! 251: if (strcmp("-o", argv[1]) == 0) { ! 252: printf("error checking off\n"); ! 253: override = 1; ! 254: argc--; argv++; ! 255: continue; ! 256: } ! 257: if (strncmp("-p", argv[1],2) == 0) { ! 258: prompt = &argv[1][2]; ! 259: argc--; argv++; ! 260: continue; ! 261: } ! 262: if (strcmp("-w", argv[1]) == 0) { ! 263: wrtflag = 2; /* suitable for open */ ! 264: argc--; argv++; ! 265: continue; ! 266: } ! 267: } ! 268: if (argc!=2) { ! 269: usage: ! 270: printf("usage: %s [options] special\n", progname); ! 271: printf("options:\n"); ! 272: printf("\t-? display usage\n"); ! 273: printf("\t-o override some error conditions\n"); ! 274: printf("\t-p\"string\" set prompt to string\n"); ! 275: printf("\t-w open for write\n"); ! 276: exit(1); ! 277: } ! 278: /* ! 279: * Attempt to open the special file. ! 280: */ ! 281: if ((fd = open(argv[1],wrtflag)) < 0) { ! 282: perror(argv[1]); ! 283: exit(1); ! 284: } ! 285: /* ! 286: * Read in the super block and validate (not too picky). ! 287: */ ! 288: if (lseek(fd, SBLOCK * DEV_BSIZE, 0) == -1) { ! 289: perror(argv[1]); ! 290: exit(1); ! 291: } ! 292: if (read(fd, &filesystem, sizeof filesystem) != sizeof filesystem) { ! 293: printf("%s: cannot read superblock\n", argv[1]); ! 294: exit(1); ! 295: } ! 296: fs = &filesystem; ! 297: if (fs->fs_magic != FS_MAGIC) { ! 298: printf("%s: Bad magic number in file system\n", argv[1]); ! 299: exit(1); ! 300: } ! 301: if (fs->fs_postblformat == FS_42POSTBLFMT) ! 302: fs->fs_nrpos = 8; ! 303: printf("fsdb of %s %s -- last mounted on %s\n", ! 304: argv[1], wrtflag ? "(Opened for write)" : "(Read only)", ! 305: &fs->fs_fsmnt[0]); ! 306: /* ! 307: * Malloc buffers and set up cache. ! 308: */ ! 309: buffers = malloc(NBUF * BLKSIZE); ! 310: bhdr.fwd = bhdr.back = &bhdr; ! 311: for (i=0; i<NBUF; i++) { ! 312: bp = &buf[i]; ! 313: bp->blkaddr = buffers + (i * BLKSIZE); ! 314: bp->valid = 0; ! 315: insert(bp); ! 316: } ! 317: /* ! 318: * Malloc filenames structure. The space for the actual filenames ! 319: * is allocated as it needs it. ! 320: */ ! 321: filenames = (struct filenames *)calloc(MAXFILES, ! 322: sizeof (struct filenames)); ! 323: if (filenames == NULL) { ! 324: printf("out of memory\n"); ! 325: exit(1); ! 326: } ! 327: ! 328: fn = filenames; ! 329: ! 330: restore_inode(2); ! 331: /* ! 332: * Malloc a few filenames (needed by pwd for example). ! 333: */ ! 334: for (i = 0; i < MAXPATHLEN; i++) { ! 335: input_path[i] = calloc(1, MAXNAMLEN); ! 336: stack_path[i] = calloc(1, MAXNAMLEN); ! 337: current_path[i] = calloc(1, MAXNAMLEN); ! 338: if (current_path[i] == NULL) { ! 339: printf("out of memory\n"); ! 340: exit(1); ! 341: } ! 342: } ! 343: current_pathp = -1; ! 344: ! 345: signal(2,err); ! 346: setjmp(env); ! 347: ! 348: getnextinput(); ! 349: /* ! 350: * Main loop and case statement. If an error condition occurs ! 351: * initialization and recovery is attempted. ! 352: */ ! 353: for (;;) { ! 354: if (error) { ! 355: freemem(filenames, nfiles); ! 356: nfiles = 0; ! 357: c_count = 0; ! 358: count = 1; ! 359: star = 0; ! 360: error = 0; ! 361: paren = 0; ! 362: acting_on_inode = 0; ! 363: acting_on_directory = 0; ! 364: should_print = 1; ! 365: addr = erraddr; ! 366: cur_ino = errino; ! 367: cur_inum = errinum; ! 368: cur_bytes = errcur_bytes; ! 369: printf("?\n"); ! 370: getnextinput(); ! 371: if (error) ! 372: continue; ! 373: } ! 374: c_count++; ! 375: ! 376: switch (c = getachar()) { ! 377: ! 378: case '\n': /* command end */ ! 379: freemem(filenames, nfiles); ! 380: nfiles = 0; ! 381: if (should_print && laststyle == '=') { ! 382: ungetachar(c); ! 383: goto calc; ! 384: } ! 385: if (c_count == 1) { ! 386: clear = 0; ! 387: should_print = 1; ! 388: erraddr = addr; ! 389: errino = cur_ino; ! 390: errinum = cur_inum; ! 391: errcur_bytes = cur_bytes; ! 392: switch (objsz) { ! 393: case DIRECTORY: ! 394: if ((addr = ! 395: getdirslot(dirslot+1)) == 0) ! 396: should_print = 0; ! 397: if (error) { ! 398: ungetachar(c); ! 399: continue; ! 400: } ! 401: break; ! 402: case INODE: ! 403: cur_inum++; ! 404: addr = itob(cur_inum); ! 405: if (!icheck(addr)) { ! 406: cur_inum--; ! 407: should_print = 0; ! 408: } ! 409: break; ! 410: case CGRP: ! 411: case SB: ! 412: cur_cgrp++; ! 413: if ((addr=cgrp_check(cur_cgrp)) == 0) { ! 414: cur_cgrp--; ! 415: continue; ! 416: } ! 417: break; ! 418: default: ! 419: addr += objsz; ! 420: cur_bytes += objsz; ! 421: if (valid_addr() == 0) ! 422: continue; ! 423: } ! 424: } ! 425: if (type == NUMB) ! 426: trapped = 0; ! 427: if (should_print) ! 428: switch (objsz) { ! 429: case DIRECTORY: ! 430: fprnt('?', 'd'); ! 431: break; ! 432: case INODE: ! 433: fprnt('?', 'i'); ! 434: if (!error) ! 435: cur_ino = addr; ! 436: break; ! 437: case CGRP: ! 438: fprnt('?', 'c'); ! 439: break; ! 440: case SB: ! 441: fprnt('?', 's'); ! 442: break; ! 443: case CHAR: ! 444: case SHORT: ! 445: case LONG: ! 446: fprnt(laststyle, lastpo); ! 447: } ! 448: if (error) { ! 449: ungetachar(c); ! 450: continue; ! 451: } ! 452: c_count = colon = acting_on_inode = 0; ! 453: acting_on_directory = 0; ! 454: should_print = 1; ! 455: getnextinput(); ! 456: if (error) ! 457: continue; ! 458: erraddr = addr; ! 459: errino = cur_ino; ! 460: errinum = cur_inum; ! 461: errcur_bytes = cur_bytes; ! 462: continue; ! 463: ! 464: case '(': /* numeric expression or unknown command */ ! 465: default: ! 466: colon = 0; ! 467: if (digit(c) || c == '(') { ! 468: ungetachar(c); ! 469: addr = expr(); ! 470: type = NUMB; ! 471: value = addr; ! 472: continue; ! 473: } ! 474: printf("unknown command or bad syntax\n"); ! 475: error++; ! 476: continue; ! 477: ! 478: case '?': /* general print facilities */ ! 479: case '/': ! 480: fprnt(c, getachar()); ! 481: continue; ! 482: ! 483: case ';': /* command separator and . */ ! 484: case '\t': ! 485: case ' ': ! 486: case '.': ! 487: continue; ! 488: ! 489: case ':': /* command indicator */ ! 490: colon++; ! 491: commands++; ! 492: should_print = 0; ! 493: stringsize = 0; ! 494: trapped = 0; ! 495: continue; ! 496: ! 497: case ',': /* count indicator */ ! 498: colon = star = 0; ! 499: if ((c = getachar()) == '*') { ! 500: star = 1; ! 501: count = BLKSIZE; ! 502: } else { ! 503: ungetachar(c); ! 504: count = expr(); ! 505: if (error) ! 506: continue; ! 507: if (!count) ! 508: count = 1; ! 509: } ! 510: clear = 0; ! 511: continue; ! 512: ! 513: case '+': /* address addition */ ! 514: colon = 0; ! 515: c = getachar(); ! 516: ungetachar(c); ! 517: if (c == '\n') ! 518: temp = 1; ! 519: else { ! 520: temp = expr(); ! 521: if (error) ! 522: continue; ! 523: } ! 524: erraddr = addr; ! 525: errcur_bytes = cur_bytes; ! 526: switch (objsz) { ! 527: case DIRECTORY: ! 528: addr = getdirslot(dirslot + temp); ! 529: if (error) ! 530: continue; ! 531: break; ! 532: case INODE: ! 533: cur_inum += temp; ! 534: addr = itob(cur_inum); ! 535: if (!icheck(addr)) { ! 536: cur_inum -= temp; ! 537: continue; ! 538: } ! 539: break; ! 540: case CGRP: ! 541: case SB: ! 542: cur_cgrp += temp; ! 543: if ((addr = cgrp_check(cur_cgrp)) == 0) { ! 544: cur_cgrp -= temp; ! 545: continue; ! 546: } ! 547: break; ! 548: default: ! 549: laststyle = '/'; ! 550: addr += temp * objsz; ! 551: cur_bytes += temp * objsz; ! 552: if (valid_addr() == 0) ! 553: continue; ! 554: } ! 555: value = get(objsz); ! 556: continue; ! 557: ! 558: case '-': /* address subtraction */ ! 559: colon = 0; ! 560: c = getachar(); ! 561: ungetachar(c); ! 562: if (c == '\n') ! 563: temp = 1; ! 564: else { ! 565: temp = expr(); ! 566: if (error) ! 567: continue; ! 568: } ! 569: erraddr = addr; ! 570: errcur_bytes = cur_bytes; ! 571: switch (objsz) { ! 572: case DIRECTORY: ! 573: addr = getdirslot(dirslot - temp); ! 574: if (error) ! 575: continue; ! 576: break; ! 577: case INODE: ! 578: cur_inum -= temp; ! 579: addr = itob(cur_inum); ! 580: if (!icheck(addr)) { ! 581: cur_inum += temp; ! 582: continue; ! 583: } ! 584: break; ! 585: case CGRP: ! 586: case SB: ! 587: cur_cgrp -= temp; ! 588: if ((addr = cgrp_check(cur_cgrp)) == 0) { ! 589: cur_cgrp += temp; ! 590: continue; ! 591: } ! 592: break; ! 593: default: ! 594: laststyle = '/'; ! 595: addr -= temp * objsz; ! 596: cur_bytes -= temp * objsz; ! 597: if (valid_addr() == 0) ! 598: continue; ! 599: } ! 600: value = get(objsz); ! 601: continue; ! 602: ! 603: case '*': /* address multiplication */ ! 604: colon = 0; ! 605: temp = expr(); ! 606: if (error) ! 607: continue; ! 608: if (objsz != INODE && objsz != DIRECTORY) ! 609: laststyle = '/'; ! 610: addr *= temp; ! 611: value = get(objsz); ! 612: continue; ! 613: ! 614: case '%': /* address division */ ! 615: colon = 0; ! 616: temp = expr(); ! 617: if (error) ! 618: continue; ! 619: if (!temp) { ! 620: printf("divide by zero\n"); ! 621: error++; ! 622: continue; ! 623: } ! 624: if (objsz != INODE && objsz != DIRECTORY) ! 625: laststyle = '/'; ! 626: addr /= temp; ! 627: value = get(objsz); ! 628: continue; ! 629: ! 630: case '=': { /* assignment operation */ ! 631: short tbase = base; ! 632: ! 633: calc: ! 634: c = getachar(); ! 635: if (c == '\n') { ! 636: ungetachar(c); ! 637: c = lastpo; ! 638: if (acting_on_inode == 1) { ! 639: if (c != 'o' && c != 'd' && c != 'x' && ! 640: c != 'O' && c != 'D' && c != 'X') { ! 641: switch (objsz) { ! 642: case LONG: ! 643: c = lastpo = 'X'; ! 644: break; ! 645: case SHORT: ! 646: c = lastpo = 'x'; ! 647: break; ! 648: case CHAR: ! 649: c = lastpo = 'c'; ! 650: } ! 651: } ! 652: } else { ! 653: if (acting_on_inode == 2) ! 654: c = lastpo = 't'; ! 655: } ! 656: } else if (acting_on_inode) ! 657: lastpo = c; ! 658: should_print = star = 0; ! 659: count = 1; ! 660: erraddr = addr; ! 661: errcur_bytes = cur_bytes; ! 662: switch (c) { ! 663: case '"': /* character string */ ! 664: if (type == NUMB) { ! 665: blocksize = BLKSIZE; ! 666: filesize = BLKSIZE * 2; ! 667: cur_bytes = blkoff(fs, addr); ! 668: if (objsz==DIRECTORY || objsz==INODE) ! 669: lastpo = 'X'; ! 670: } ! 671: puta(); ! 672: continue; ! 673: case '+': /* =+ operator */ ! 674: temp = expr(); ! 675: value = get(objsz); ! 676: if (!error) ! 677: put(value+temp,objsz); ! 678: continue; ! 679: case '-': /* =- operator */ ! 680: temp = expr(); ! 681: value = get(objsz); ! 682: if (!error) ! 683: put(value-temp,objsz); ! 684: continue; ! 685: case 'b': ! 686: case 'c': ! 687: if (objsz == CGRP) ! 688: fprnt('?', c); ! 689: else ! 690: fprnt('/', c); ! 691: continue; ! 692: case 'i': ! 693: addr = cur_ino; ! 694: fprnt('?', 'i'); ! 695: continue; ! 696: case 's': ! 697: fprnt('?', 's'); ! 698: continue; ! 699: case 't': ! 700: case 'T': ! 701: laststyle = '='; ! 702: printf("\t\t"); ! 703: printf("%s", ctime(&value)); ! 704: continue; ! 705: case 'o': ! 706: base = OCTAL; ! 707: goto otx; ! 708: case 'd': ! 709: if (objsz == DIRECTORY) { ! 710: addr = cur_dir; ! 711: fprnt('?', 'd'); ! 712: continue; ! 713: } ! 714: base = DECIMAL; ! 715: goto otx; ! 716: case 'x': ! 717: base = HEX; ! 718: otx: ! 719: laststyle = '='; ! 720: printf("\t\t"); ! 721: if (acting_on_inode) ! 722: print(value & 0177777L, 12, -8, 0); ! 723: else ! 724: print(addr & 0177777L, 12, -8, 0); ! 725: printf("\n"); ! 726: base = tbase; ! 727: continue; ! 728: case 'O': ! 729: base = OCTAL; ! 730: goto OTX; ! 731: case 'D': ! 732: base = DECIMAL; ! 733: goto OTX; ! 734: case 'X': ! 735: base = HEX; ! 736: OTX: ! 737: laststyle = '='; ! 738: printf("\t\t"); ! 739: if (acting_on_inode) ! 740: print(value, 12, -8, 0); ! 741: else ! 742: print(addr, 12, -8, 0); ! 743: printf("\n"); ! 744: base = tbase; ! 745: continue; ! 746: default: /* regular assignment */ ! 747: ungetachar(c); ! 748: value = expr(); ! 749: if (error) ! 750: printf("syntax error\n"); ! 751: else ! 752: put(value,objsz); ! 753: continue; ! 754: } ! 755: } ! 756: ! 757: case '>': /* save current address */ ! 758: colon = 0; ! 759: should_print = 0; ! 760: c = getachar(); ! 761: if (!letter(c) && !digit(c)) { ! 762: printf("invalid register specification, "); ! 763: printf("must be letter or digit\n"); ! 764: error++; ! 765: continue; ! 766: } ! 767: if (letter(c)) { ! 768: if (c < 'a') ! 769: c = uppertolower(c); ! 770: c = hextodigit(c); ! 771: } else ! 772: c = numtodigit(c); ! 773: regs[c].sv_addr = addr; ! 774: regs[c].sv_value = value; ! 775: regs[c].sv_objsz = objsz; ! 776: continue; ! 777: ! 778: case '<': /* restore saved address */ ! 779: colon = 0; ! 780: should_print = 0; ! 781: c = getachar(); ! 782: if (!letter(c) && !digit(c)) { ! 783: printf("invalid register specification, "); ! 784: printf("must be letter or digit\n"); ! 785: error++; ! 786: continue; ! 787: } ! 788: if (letter(c)) { ! 789: if (c < 'a') ! 790: c = uppertolower(c); ! 791: c = hextodigit(c); ! 792: } else ! 793: c = numtodigit(c); ! 794: addr = regs[c].sv_addr; ! 795: value = regs[c].sv_value; ! 796: objsz = regs[c].sv_objsz; ! 797: continue; ! 798: ! 799: case 'a': ! 800: if (colon) ! 801: colon = 0; ! 802: else ! 803: goto no_colon; ! 804: if (match("at", 2)) { /* access time */ ! 805: acting_on_inode = 2; ! 806: should_print = 1; ! 807: addr = (long) ! 808: &((struct dinode *)cur_ino)->di_atime; ! 809: value = get(LONG); ! 810: type = NULL; ! 811: continue; ! 812: } ! 813: goto bad_syntax; ! 814: ! 815: case 'b': ! 816: if (colon) ! 817: colon = 0; ! 818: else ! 819: goto no_colon; ! 820: if (match("block", 2)) { /* block conversion */ ! 821: if (type == NUMB) { ! 822: value = addr; ! 823: cur_bytes = 0; ! 824: blocksize = BLKSIZE; ! 825: filesize = BLKSIZE * 2; ! 826: } ! 827: addr = value << FRGSHIFT; ! 828: bod_addr = addr; ! 829: value = get(LONG); ! 830: type = BLOCK; ! 831: dirslot = 0; ! 832: trapped++; ! 833: continue; ! 834: } ! 835: if (match("bs", 2)) { /* block size */ ! 836: acting_on_inode = 1; ! 837: should_print = 1; ! 838: if (icheck(cur_ino) == 0) ! 839: continue; ! 840: addr = (long) ! 841: &((struct dinode *)cur_ino)->di_blocks; ! 842: value = get(LONG); ! 843: type = NULL; ! 844: continue; ! 845: } ! 846: if (match("base", 2)) { /* change/show base */ ! 847: showbase: ! 848: if ((c = getachar()) == '\n') { ! 849: ungetachar(c); ! 850: printf("base =\t\t"); ! 851: switch (base) { ! 852: case OCTAL: ! 853: printf("OCTAL\n"); ! 854: continue; ! 855: case DECIMAL: ! 856: printf("DECIMAL\n"); ! 857: continue; ! 858: case HEX: ! 859: printf("HEX\n"); ! 860: continue; ! 861: } ! 862: } ! 863: if (c != '=') { ! 864: printf("missing '='\n"); ! 865: error++; ! 866: continue; ! 867: } ! 868: value = expr(); ! 869: switch (value) { ! 870: default: ! 871: printf("invalid base\n"); ! 872: error++; ! 873: break; ! 874: case OCTAL: ! 875: case DECIMAL: ! 876: case HEX: ! 877: base = value; ! 878: } ! 879: goto showbase; ! 880: } ! 881: goto bad_syntax; ! 882: ! 883: case 'c': ! 884: if (colon) ! 885: colon = 0; ! 886: else ! 887: goto no_colon; ! 888: if (match("cd", 2)) { /* change directory */ ! 889: top = filenames - 1; ! 890: eat_spaces(); ! 891: if ((c = getachar()) == '\n') { ! 892: ungetachar(c); ! 893: current_pathp = -1; ! 894: restore_inode(2); ! 895: continue; ! 896: } ! 897: ungetachar(c); ! 898: temp = cur_inum; ! 899: doing_cd = 1; ! 900: parse(); ! 901: doing_cd = 0; ! 902: if (nfiles != 1) { ! 903: restore_inode(temp); ! 904: if (!error) { ! 905: print_path(input_path, ! 906: input_pathp); ! 907: if (nfiles == 0) ! 908: printf(" not found\n"); ! 909: else ! 910: printf(" ambiguous\n"); ! 911: error++; ! 912: } ! 913: continue; ! 914: } ! 915: restore_inode(filenames->ino); ! 916: if ((mode = icheck(addr)) == 0) ! 917: continue; ! 918: if ((mode & IFMT) != IFDIR) { ! 919: restore_inode(temp); ! 920: print_path(input_path, input_pathp); ! 921: printf(" not a directory\n"); ! 922: error++; ! 923: continue; ! 924: } ! 925: for (i = 0; i <= top->len; i++) ! 926: strcpy(current_path[i], ! 927: top->fname[i]); ! 928: current_pathp = top->len; ! 929: continue; ! 930: } ! 931: if (match("cg", 2)) { /* cylinder group */ ! 932: if (type == NUMB) ! 933: value = addr; ! 934: if (value > fs->fs_ncg - 1) { ! 935: printf("maximum cylinder group is "); ! 936: print(fs->fs_ncg - 1, 8, -8, 0); ! 937: printf("\n"); ! 938: error++; ! 939: continue; ! 940: } ! 941: type = objsz = CGRP; ! 942: cur_cgrp = value; ! 943: addr = cgtod(fs, cur_cgrp) << FRGSHIFT; ! 944: continue; ! 945: } ! 946: if (match("ct", 2)) { /* creation time */ ! 947: acting_on_inode = 2; ! 948: should_print = 1; ! 949: addr = (long) ! 950: &((struct dinode *)cur_ino)->di_ctime; ! 951: value = get(LONG); ! 952: type = NULL; ! 953: continue; ! 954: } ! 955: goto bad_syntax; ! 956: ! 957: case 'd': ! 958: if (colon) ! 959: colon = 0; ! 960: else ! 961: goto no_colon; ! 962: if (match("directory", 2)) { /* directory offsets */ ! 963: if (type == NUMB) ! 964: value = addr; ! 965: objsz = DIRECTORY; ! 966: type = DIRECTORY; ! 967: addr = getdirslot(value); ! 968: continue; ! 969: } ! 970: if (match("db", 2)) { /* direct block */ ! 971: acting_on_inode = 1; ! 972: should_print = 1; ! 973: if (type == NUMB) ! 974: value = addr; ! 975: if (value >= NDADDR) { ! 976: printf("direct blocks are 0 to "); ! 977: print(NDADDR - 1, 0, 0, 0); ! 978: printf("\n"); ! 979: error++; ! 980: continue; ! 981: } ! 982: addr = cur_ino; ! 983: if (!icheck(addr)) ! 984: continue; ! 985: addr = (long) ! 986: &((struct dinode *)cur_ino)->di_db[value]; ! 987: bod_addr = addr; ! 988: cur_bytes = (value) * BLKSIZE; ! 989: cur_block = value; ! 990: type = BLOCK; ! 991: dirslot = 0; ! 992: value = get(LONG); ! 993: if (!value && !override) { ! 994: printf("non existent block\n"); ! 995: error++; ! 996: } ! 997: continue; ! 998: } ! 999: goto bad_syntax; ! 1000: ! 1001: case 'f': ! 1002: if (colon) ! 1003: colon = 0; ! 1004: else ! 1005: goto no_colon; ! 1006: if (match("find", 3)) { /* find command */ ! 1007: find(); ! 1008: continue; ! 1009: } ! 1010: if (match("fragment", 2)) { /* fragment conv. */ ! 1011: if (type == NUMB) { ! 1012: value = addr; ! 1013: cur_bytes = 0; ! 1014: blocksize = FRGSIZE; ! 1015: filesize = FRGSIZE * 2; ! 1016: } ! 1017: if (min(blocksize, filesize) - cur_bytes > ! 1018: FRGSIZE) { ! 1019: blocksize = cur_bytes + FRGSIZE; ! 1020: filesize = blocksize * 2; ! 1021: } ! 1022: addr = value << FRGSHIFT; ! 1023: bod_addr = addr; ! 1024: value = get(LONG); ! 1025: type = FRAGMENT; ! 1026: dirslot = 0; ! 1027: trapped++; ! 1028: continue; ! 1029: } ! 1030: if (match("file", 4)) { /* access as file */ ! 1031: acting_on_inode = 1; ! 1032: should_print = 1; ! 1033: if (type == NUMB) ! 1034: value = addr; ! 1035: addr = cur_ino; ! 1036: if ((mode = icheck(addr)) == 0) ! 1037: continue; ! 1038: if ((mode & IFCHR) && !override) { ! 1039: printf("special device\n"); ! 1040: error++; ! 1041: continue; ! 1042: } ! 1043: if ((addr = (bmap(value) << FRGSHIFT)) == 0) ! 1044: continue; ! 1045: cur_block = value; ! 1046: bod_addr = addr; ! 1047: type = BLOCK; ! 1048: dirslot = 0; ! 1049: continue; ! 1050: } ! 1051: if (match("fill", 4)) { /* fill */ ! 1052: if (getachar() != '=') { ! 1053: printf("missing '='\n"); ! 1054: error++; ! 1055: continue; ! 1056: } ! 1057: if (objsz == INODE || objsz == DIRECTORY) { ! 1058: printf("can't fill inode or directory\n"); ! 1059: error++; ! 1060: continue; ! 1061: } ! 1062: fill(); ! 1063: continue; ! 1064: } ! 1065: goto bad_syntax; ! 1066: ! 1067: case 'g': ! 1068: if (colon) ! 1069: colon = 0; ! 1070: else ! 1071: goto no_colon; ! 1072: if (match("gid", 1)) { /* group id */ ! 1073: acting_on_inode = 1; ! 1074: should_print = 1; ! 1075: addr = (long) ! 1076: &((struct dinode *)cur_ino)->di_gid; ! 1077: value = get(SHORT); ! 1078: type = NULL; ! 1079: continue; ! 1080: } ! 1081: goto bad_syntax; ! 1082: ! 1083: case 'i': ! 1084: if (colon) ! 1085: colon = 0; ! 1086: else ! 1087: goto no_colon; ! 1088: if (match("inode", 2)) { /* i# to inode conversion */ ! 1089: if (c_count == 2) { ! 1090: addr = cur_ino; ! 1091: value = get(INODE); ! 1092: type = NULL; ! 1093: laststyle = '='; ! 1094: lastpo = 'i'; ! 1095: should_print = 1; ! 1096: continue; ! 1097: } ! 1098: if (type == NUMB) ! 1099: value = addr; ! 1100: addr = itob(value); ! 1101: if (!icheck(addr)) ! 1102: continue; ! 1103: cur_ino = addr; ! 1104: cur_inum = value; ! 1105: value = get(INODE); ! 1106: type = NULL; ! 1107: continue; ! 1108: } ! 1109: if (match("ib", 2)) { /* indirect block */ ! 1110: acting_on_inode = 1; ! 1111: should_print = 1; ! 1112: if (type == NUMB) ! 1113: value = addr; ! 1114: if (value >= NIADDR) { ! 1115: printf("indirect blocks are 0 to "); ! 1116: print(NIADDR - 1, 0, 0, 0); ! 1117: printf("\n"); ! 1118: error++; ! 1119: continue; ! 1120: } ! 1121: addr = (long) ! 1122: &((struct dinode *)cur_ino)->di_ib[value]; ! 1123: cur_bytes = (NDADDR - 1) * BLKSIZE; ! 1124: temp = 1; ! 1125: for (i = 0; i < value; i++) { ! 1126: temp *= NINDIR(fs) * BLKSIZE; ! 1127: cur_bytes += temp; ! 1128: } ! 1129: type = BLOCK; ! 1130: dirslot = 0; ! 1131: value = get(LONG); ! 1132: if (!value && !override) { ! 1133: printf("non existent block\n"); ! 1134: error++; ! 1135: } ! 1136: continue; ! 1137: } ! 1138: goto bad_syntax; ! 1139: ! 1140: case 'l': ! 1141: if (colon) ! 1142: colon = 0; ! 1143: else ! 1144: goto no_colon; ! 1145: if (match("ls", 2)) { /* ls command */ ! 1146: temp = cur_inum; ! 1147: recursive = long_list = 0; ! 1148: top = filenames - 1; ! 1149: for (;;) { ! 1150: eat_spaces(); ! 1151: if ((c = getachar()) == '-') { ! 1152: if ((c = getachar()) == 'R') { ! 1153: recursive = 1; ! 1154: continue; ! 1155: } else if (c == 'l') { ! 1156: long_list = 1; ! 1157: } else { ! 1158: printf("unknown option "); ! 1159: printf("'%c'\n", c); ! 1160: error++; ! 1161: break; ! 1162: } ! 1163: } else ! 1164: ungetachar(c); ! 1165: if ((c = getachar()) == '\n') { ! 1166: if (c_count != 2) { ! 1167: ungetachar(c); ! 1168: break; ! 1169: } ! 1170: } ! 1171: c_count++; ! 1172: ungetachar(c); ! 1173: parse(); ! 1174: restore_inode(temp); ! 1175: if (error) ! 1176: break; ! 1177: } ! 1178: recursive = 0; ! 1179: if (error || nfiles == 0) { ! 1180: if (!error) { ! 1181: print_path(input_path, ! 1182: input_pathp); ! 1183: printf(" not found\n"); ! 1184: } ! 1185: continue; ! 1186: } ! 1187: if (nfiles) { ! 1188: cmp_level = 0; ! 1189: qsort((char *)filenames, nfiles, ! 1190: sizeof (struct filenames), ffcmp); ! 1191: ls(filenames, filenames + (nfiles - 1), 0); ! 1192: } else { ! 1193: printf("no match\n"); ! 1194: error++; ! 1195: } ! 1196: restore_inode(temp); ! 1197: continue; ! 1198: } ! 1199: if (match("ln", 2)) { /* link count */ ! 1200: acting_on_inode = 1; ! 1201: should_print = 1; ! 1202: addr = (long) ! 1203: &((struct dinode *)cur_ino)->di_nlink; ! 1204: value = get(SHORT); ! 1205: type = NULL; ! 1206: continue; ! 1207: } ! 1208: goto bad_syntax; ! 1209: ! 1210: case 'm': ! 1211: if (colon) ! 1212: colon = 0; ! 1213: else ! 1214: goto no_colon; ! 1215: addr = cur_ino; ! 1216: if ((mode = icheck(addr)) == 0) ! 1217: continue; ! 1218: if (match("mt", 2)) { /* modification time */ ! 1219: acting_on_inode = 2; ! 1220: should_print = 1; ! 1221: addr = (long) ! 1222: &((struct dinode *)cur_ino)->di_mtime; ! 1223: value = get(LONG); ! 1224: type = NULL; ! 1225: continue; ! 1226: } ! 1227: if (match("md", 2)) { /* mode */ ! 1228: acting_on_inode = 1; ! 1229: should_print = 1; ! 1230: addr = (long) ! 1231: &((struct dinode *)cur_ino)->di_mode; ! 1232: value = get(SHORT); ! 1233: type = NULL; ! 1234: continue; ! 1235: } ! 1236: if (match("maj", 2)) { /* major device number */ ! 1237: acting_on_inode = 1; ! 1238: should_print = 1; ! 1239: if (devcheck(mode)) ! 1240: continue; ! 1241: addr = (long) ! 1242: &((struct dinode *)cur_ino)->di_db[1]; ! 1243: value = get(LONG); ! 1244: type = NULL; ! 1245: continue; ! 1246: } ! 1247: if (match("min", 2)) { /* minor device number */ ! 1248: acting_on_inode = 1; ! 1249: should_print = 1; ! 1250: if (devcheck(mode)) ! 1251: continue; ! 1252: addr = (long) ! 1253: &((struct dinode *)cur_ino)->di_db[0]; ! 1254: value = get(LONG); ! 1255: type = NULL; ! 1256: continue; ! 1257: } ! 1258: goto bad_syntax; ! 1259: ! 1260: case 'n': ! 1261: if (colon) ! 1262: colon = 0; ! 1263: else ! 1264: goto no_colon; ! 1265: if (match("nm", 1)) { /* directory name */ ! 1266: objsz = DIRECTORY; ! 1267: acting_on_directory = 1; ! 1268: cur_dir = addr; ! 1269: if ((cptr = getblk(addr)) == 0) ! 1270: continue; ! 1271: dirp = (struct direct *)(cptr+blkoff(fs, addr)); ! 1272: stringsize = (long)dirp->d_reclen - ! 1273: ((long)&dirp->d_name[0] - (long)&dirp->d_ino); ! 1274: addr = (long) ! 1275: &((struct direct *)addr)->d_name[0]; ! 1276: type = NULL; ! 1277: continue; ! 1278: } ! 1279: goto bad_syntax; ! 1280: ! 1281: case 'o': ! 1282: if (colon) ! 1283: colon = 0; ! 1284: else ! 1285: goto no_colon; ! 1286: if (match("override", 1)) { /* override flip flop */ ! 1287: if (override = !override) ! 1288: printf("error checking off\n"); ! 1289: else ! 1290: printf("error checking on\n"); ! 1291: continue; ! 1292: } ! 1293: goto bad_syntax; ! 1294: ! 1295: case 'p': ! 1296: if (colon) ! 1297: colon = 0; ! 1298: else ! 1299: goto no_colon; ! 1300: if (match("pwd", 2)) { /* print working dir */ ! 1301: print_path(current_path, current_pathp); ! 1302: printf("\n"); ! 1303: continue; ! 1304: } ! 1305: if (match("prompt", 2)) { /* change prompt */ ! 1306: if ((c = getachar()) != '=') { ! 1307: printf("missing '='\n"); ! 1308: error++; ! 1309: continue; ! 1310: } ! 1311: if ((c = getachar()) != '"') { ! 1312: printf("missing '\"'\n"); ! 1313: error++; ! 1314: continue; ! 1315: } ! 1316: i = 0; ! 1317: prompt = &prompt[0]; ! 1318: while ((c = getachar()) != '"' && ! 1319: c != '\n') { ! 1320: prompt[i++] = c; ! 1321: if (i >= PROMPTSIZE) { ! 1322: printf("string too long\n"); ! 1323: error++; ! 1324: break; ! 1325: } ! 1326: } ! 1327: prompt[i] = '\0'; ! 1328: continue; ! 1329: } ! 1330: goto bad_syntax; ! 1331: ! 1332: case 'q': ! 1333: if (!colon) ! 1334: goto no_colon; ! 1335: if (match("quit", 1)) { /* quit */ ! 1336: if ((c = getachar()) != '\n') { ! 1337: error++; ! 1338: continue; ! 1339: } ! 1340: exit(0); ! 1341: } ! 1342: goto bad_syntax; ! 1343: ! 1344: case 's': ! 1345: if (colon) ! 1346: colon = 0; ! 1347: else ! 1348: goto no_colon; ! 1349: if (match("sb", 2)) { /* super block */ ! 1350: if (c_count == 2) { ! 1351: cur_cgrp = -1; ! 1352: type = objsz = SB; ! 1353: laststyle = '='; ! 1354: lastpo = 's'; ! 1355: should_print = 1; ! 1356: continue; ! 1357: } ! 1358: if (type == NUMB) ! 1359: value = addr; ! 1360: if (value > fs->fs_ncg - 1) { ! 1361: printf("maximum super block is "); ! 1362: print(fs->fs_ncg - 1, 8, -8, 0); ! 1363: printf("\n"); ! 1364: error++; ! 1365: continue; ! 1366: } ! 1367: type = objsz = SB; ! 1368: cur_cgrp = value; ! 1369: addr = cgsblock(fs, cur_cgrp) << FRGSHIFT; ! 1370: continue; ! 1371: } ! 1372: if (match("sz", 2)) { /* file size */ ! 1373: acting_on_inode = 1; ! 1374: should_print = 1; ! 1375: addr = (long) ! 1376: &((struct dinode *)cur_ino)->di_size; ! 1377: value = get(LONG); ! 1378: type = NULL; ! 1379: continue; ! 1380: } ! 1381: goto bad_syntax; ! 1382: ! 1383: case 'u': ! 1384: if (colon) ! 1385: colon = 0; ! 1386: else ! 1387: goto no_colon; ! 1388: if (match("uid", 1)) { /* user id */ ! 1389: acting_on_inode = 1; ! 1390: should_print = 1; ! 1391: addr = (long) ! 1392: &((struct dinode *)cur_ino)->di_uid; ! 1393: value = get(SHORT); ! 1394: type = NULL; ! 1395: continue; ! 1396: } ! 1397: goto bad_syntax; ! 1398: ! 1399: case 'F': /* buffer status (internal use only) */ ! 1400: if (colon) ! 1401: colon = 0; ! 1402: else ! 1403: goto no_colon; ! 1404: for (bp = bhdr.fwd; bp != &bhdr; bp = bp->fwd) ! 1405: printf("%8x %d\n",bp->blkno,bp->valid); ! 1406: printf("\n"); ! 1407: printf("# commands\t\t%d\n", commands); ! 1408: printf("# read requests\t\t%d\n", read_requests); ! 1409: printf("# actual disk reads\t%d\n", actual_disk_reads); ! 1410: continue; ! 1411: no_colon: ! 1412: printf("a colon should precede a command\n"); ! 1413: error++; ! 1414: continue; ! 1415: bad_syntax: ! 1416: printf("more letters needed to distinguish command\n"); ! 1417: error++; ! 1418: continue; ! 1419: } ! 1420: } ! 1421: } ! 1422: ! 1423: /* ! 1424: * getachar - get next character from input buffer. ! 1425: */ ! 1426: char ! 1427: getachar() ! 1428: { ! 1429: return(input_buffer[input_pointer++]); ! 1430: } ! 1431: ! 1432: /* ! 1433: * ungetachar - return character to input buffer. ! 1434: */ ! 1435: ungetachar(c) ! 1436: register char c; ! 1437: { ! 1438: if (input_pointer == 0) { ! 1439: printf("internal problem maintaining input buffer\n"); ! 1440: error++; ! 1441: return; ! 1442: } ! 1443: input_buffer[--input_pointer] = c; ! 1444: } ! 1445: ! 1446: /* ! 1447: * getnextinput - display the prompt and read an input line. ! 1448: * An input line is up to 128 characters terminated by the newline ! 1449: * character. Handle overflow, shell escape, and eof. ! 1450: */ ! 1451: getnextinput() ! 1452: { ! 1453: register int i; ! 1454: register char c; ! 1455: register short pid, rpid; ! 1456: int retcode; ! 1457: ! 1458: newline: ! 1459: i = 0; ! 1460: printf("%s", prompt); ! 1461: ignore_eol: ! 1462: while ((c = getc(stdin)) != '\n' && !(c == '!' && i == 0) && ! 1463: !feof(stdin) && i <= INPUTBUFFER - 2) ! 1464: input_buffer[i++] = c; ! 1465: if (input_buffer[i - 1] == '\\') { ! 1466: input_buffer[i++] = c; ! 1467: goto ignore_eol; ! 1468: } ! 1469: if (feof(stdin)) { ! 1470: printf("\n"); ! 1471: exit(0); ! 1472: } ! 1473: if (c == '!') { ! 1474: if ((pid = fork()) == 0) { ! 1475: execl("/bin/sh", "sh", "-t", 0); ! 1476: error++; ! 1477: return; ! 1478: } ! 1479: while ((rpid = wait(&retcode)) != pid && rpid != -1) ! 1480: ; ! 1481: printf("!\n"); ! 1482: goto newline; ! 1483: } ! 1484: if (c != '\n') ! 1485: printf("input truncated to 128 characters\n"); ! 1486: input_buffer[i] = '\n'; ! 1487: input_pointer = 0; ! 1488: } ! 1489: ! 1490: /* ! 1491: * eat_spaces - read extraneous spaces. ! 1492: */ ! 1493: eat_spaces() ! 1494: { ! 1495: register char c; ! 1496: ! 1497: while ((c = getachar()) == ' ') ! 1498: ; ! 1499: ungetachar(c); ! 1500: } ! 1501: ! 1502: /* ! 1503: * restore_inode - set up all inode indicators so inum is now ! 1504: * the current inode. ! 1505: */ ! 1506: restore_inode(inum) ! 1507: long inum; ! 1508: { ! 1509: errinum = cur_inum = inum; ! 1510: addr = errino = cur_ino = itob(inum); ! 1511: } ! 1512: ! 1513: /* ! 1514: * match - return false if the input does not match string up to ! 1515: * upto letters. Then proceed to chew up extraneous letters. ! 1516: */ ! 1517: match(string, upto) ! 1518: register char *string; ! 1519: register int upto; ! 1520: { ! 1521: register int i, length = strlen(string) - 1; ! 1522: register char c; ! 1523: int save_upto = upto; ! 1524: ! 1525: while (--upto) { ! 1526: string++; ! 1527: if ((c = getachar()) != *string) { ! 1528: for (i = save_upto - upto; i; i--) { ! 1529: ungetachar(c); ! 1530: c = *--string; ! 1531: } ! 1532: return(0); ! 1533: } ! 1534: length--; ! 1535: } ! 1536: while (length--) { ! 1537: string++; ! 1538: if ((c = getachar()) != *string) { ! 1539: ungetachar(c); ! 1540: return(1); ! 1541: } ! 1542: } ! 1543: return(1); ! 1544: } ! 1545: ! 1546: /* ! 1547: * expr - expression evaluator. Will evaluate expressions from ! 1548: * left to right with no operator precedence. Parentheses may ! 1549: * be used. ! 1550: */ ! 1551: long ! 1552: expr() ! 1553: { ! 1554: register long numb = 0, temp; ! 1555: register char c; ! 1556: ! 1557: numb = term(); ! 1558: for (;;) { ! 1559: if (error) ! 1560: return; ! 1561: c = getachar(); ! 1562: switch (c) { ! 1563: ! 1564: case '+': ! 1565: numb += term(); ! 1566: continue; ! 1567: ! 1568: case '-': ! 1569: numb -= term(); ! 1570: continue; ! 1571: ! 1572: case '*': ! 1573: numb *= term(); ! 1574: continue; ! 1575: ! 1576: case '%': ! 1577: temp = term(); ! 1578: if (!temp) { ! 1579: printf("divide by zero\n"); ! 1580: error++; ! 1581: return; ! 1582: } ! 1583: numb /= temp; ! 1584: continue; ! 1585: ! 1586: case ')': ! 1587: paren--; ! 1588: return(numb); ! 1589: ! 1590: default: ! 1591: ungetachar(c); ! 1592: if (paren && !error) { ! 1593: printf("missing ')'\n"); ! 1594: error++; ! 1595: } ! 1596: return(numb); ! 1597: } ! 1598: } ! 1599: } ! 1600: ! 1601: /* ! 1602: * term - used by expression evaluator to get an operand. ! 1603: */ ! 1604: long ! 1605: term() ! 1606: { ! 1607: register char c; ! 1608: ! 1609: switch (c = getachar()) { ! 1610: ! 1611: default: ! 1612: ungetachar(c); ! 1613: ! 1614: case '+': ! 1615: return(getnumb()); ! 1616: ! 1617: case '-': ! 1618: return(-getnumb()); ! 1619: ! 1620: case '(': ! 1621: paren++; ! 1622: return(expr()); ! 1623: } ! 1624: } ! 1625: ! 1626: /* ! 1627: * getnumb - read a number from the input stream. A leading ! 1628: * zero signifies octal interpretation, a leading '0x' ! 1629: * signifies hexadecimal, and a leading '0t' signifies ! 1630: * decimal. If the first character is a character, ! 1631: * return an error. ! 1632: */ ! 1633: long ! 1634: getnumb() ! 1635: { ! 1636: ! 1637: register char c, savec; ! 1638: long number = 0, tbase, num; ! 1639: extern short error; ! 1640: ! 1641: c = getachar(); ! 1642: if (!digit(c)) { ! 1643: error++; ! 1644: ungetachar(c); ! 1645: return(-1); ! 1646: } ! 1647: if (c == '0') { ! 1648: tbase = OCTAL; ! 1649: if ((c = getachar()) == 'x') ! 1650: tbase = HEX; ! 1651: else if (c == 't') ! 1652: tbase = DECIMAL; ! 1653: else ungetachar(c); ! 1654: } else { ! 1655: tbase = base; ! 1656: ungetachar(c); ! 1657: } ! 1658: for (;;) { ! 1659: num = tbase; ! 1660: c = savec = getachar(); ! 1661: if (HEXLETTER(c)) ! 1662: c = uppertolower(c); ! 1663: switch (tbase) { ! 1664: case HEX: ! 1665: if (hexletter(c)) { ! 1666: num = hextodigit(c); ! 1667: break; ! 1668: } ! 1669: case DECIMAL: ! 1670: if (digit(c)) ! 1671: num = numtodigit(c); ! 1672: break; ! 1673: case OCTAL: ! 1674: if (octaldigit(c)) ! 1675: num = numtodigit(c); ! 1676: } ! 1677: if (num == tbase) ! 1678: break; ! 1679: number = number * tbase + num; ! 1680: } ! 1681: ungetachar(savec); ! 1682: return(number); ! 1683: } ! 1684: ! 1685: /* ! 1686: * find - the syntax is almost identical to the unix command. ! 1687: * find dir [-name pattern] [-inum number] ! 1688: * Note: only one of -name or -inum may be used at a time. ! 1689: * Also, the -print is not needed (implied). ! 1690: */ ! 1691: find() ! 1692: { ! 1693: register struct filenames *fn; ! 1694: register char c; ! 1695: long temp; ! 1696: short mode; ! 1697: ! 1698: eat_spaces(); ! 1699: temp = cur_inum; ! 1700: top = filenames - 1; ! 1701: doing_cd = 1; ! 1702: parse(); ! 1703: doing_cd = 0; ! 1704: if (nfiles != 1) { ! 1705: restore_inode(temp); ! 1706: if (!error) { ! 1707: print_path(input_path, input_pathp); ! 1708: if (nfiles == 0) ! 1709: printf(" not found\n"); ! 1710: else ! 1711: printf(" ambiguous\n"); ! 1712: error++; ! 1713: return; ! 1714: } ! 1715: } ! 1716: restore_inode(filenames->ino); ! 1717: freemem(filenames, nfiles); ! 1718: nfiles = 0; ! 1719: top = filenames - 1; ! 1720: if ((mode = icheck(addr)) == 0) ! 1721: return; ! 1722: if ((mode & IFMT) != IFDIR) { ! 1723: print_path(input_path, input_pathp); ! 1724: printf(" not a directory\n"); ! 1725: error++; ! 1726: return; ! 1727: } ! 1728: eat_spaces(); ! 1729: if ((c = getachar()) != '-') { ! 1730: printf("missing '-'\n"); ! 1731: error++; ! 1732: return; ! 1733: } ! 1734: find_by_name = find_by_inode = 0; ! 1735: c = getachar(); ! 1736: if (match("name", 4)) { ! 1737: eat_spaces(); ! 1738: find_by_name = 1; ! 1739: } else if (match("inum", 4)) { ! 1740: eat_spaces(); ! 1741: find_ino = expr(); ! 1742: if (error) ! 1743: return; ! 1744: while ((c = getachar()) != '\n') ! 1745: ; ! 1746: ungetachar(c); ! 1747: find_by_inode = 1; ! 1748: } else { ! 1749: printf("use -name or -inum with find\n"); ! 1750: error++; ! 1751: return; ! 1752: } ! 1753: doing_find = 1; ! 1754: parse(); ! 1755: doing_find = 0; ! 1756: if (error) { ! 1757: restore_inode(temp); ! 1758: return; ! 1759: } ! 1760: for (fn = filenames; fn <= top; fn++) { ! 1761: if (fn->find == 0) ! 1762: continue; ! 1763: printf("i#: "); ! 1764: print(fn->ino, 12, -8, 0); ! 1765: print_path(fn->fname, fn->len); ! 1766: printf("\n"); ! 1767: } ! 1768: restore_inode(temp); ! 1769: } ! 1770: ! 1771: /* ! 1772: * ls - do an ls. Should behave exactly as ls(1). ! 1773: * Only -R and -l is supported and -l gives different results. ! 1774: */ ! 1775: ls(fn0, fnlast, level) ! 1776: struct filenames *fn0, *fnlast; ! 1777: short level; ! 1778: { ! 1779: register struct filenames *fn, *fnn; ! 1780: register int i; ! 1781: int fcmp(); ! 1782: ! 1783: fn = fn0; ! 1784: for (;;) { ! 1785: fn0 = fn; ! 1786: if (fn0->len) { ! 1787: cmp_level = level; ! 1788: qsort((char *)fn0, fnlast - fn0 + 1, ! 1789: sizeof (struct filenames), fcmp); ! 1790: } ! 1791: for (fnn = fn, fn++; fn <= fnlast; fnn = fn, fn++) { ! 1792: if (fnn->len != fn->len && level == fnn->len - 1) ! 1793: break; ! 1794: if (fnn->len == 0) ! 1795: continue; ! 1796: if (strcmp(fn->fname[level], fnn->fname[level])) ! 1797: break; ! 1798: } ! 1799: if (fn0->len && level != fn0->len - 1) ! 1800: ls(fn0, fnn, level + 1); ! 1801: else { ! 1802: if (fn0 != filenames) ! 1803: printf("\n"); ! 1804: print_path(fn0->fname, fn0->len - 1); ! 1805: printf(":\n"); ! 1806: if (fn0->len == 0) ! 1807: cmp_level = level; ! 1808: else ! 1809: cmp_level = level + 1; ! 1810: qsort((char *)fn0, fnn - fn0 + 1, ! 1811: sizeof (struct filenames), fcmp); ! 1812: formatf(fn0, fnn); ! 1813: nfiles -= fnn - fn0 + 1; ! 1814: } ! 1815: if (fn > fnlast) ! 1816: return; ! 1817: } ! 1818: } ! 1819: ! 1820: /* ! 1821: * formatf - code lifted from ls. ! 1822: */ ! 1823: formatf(fn0, fnlast) ! 1824: register struct filenames *fn0, *fnlast; ! 1825: { ! 1826: register struct filenames *fn; ! 1827: int width = 0, w, nentry = fnlast - fn0 + 1; ! 1828: int i, j, columns, lines; ! 1829: char *cp; ! 1830: ! 1831: if (long_list) { ! 1832: columns = 1; ! 1833: } else { ! 1834: for (fn = fn0; fn <= fnlast; fn++) { ! 1835: int len = strlen(fn->fname[cmp_level]) + 2; ! 1836: ! 1837: if (len > width) ! 1838: width = len; ! 1839: } ! 1840: width = (width + 8) &~ 7; ! 1841: columns = 80 / width; ! 1842: if (columns == 0) ! 1843: columns = 1; ! 1844: } ! 1845: lines = (nentry + columns - 1) / columns; ! 1846: for (i = 0; i < lines; i++) { ! 1847: for (j = 0; j < columns; j++) { ! 1848: fn = fn0 + j * lines + i; ! 1849: if (long_list) { ! 1850: printf("i#: "); ! 1851: print(fn->ino, 12, -8, 0); ! 1852: } ! 1853: cp = fmtentry(fn); ! 1854: printf("%s", cp); ! 1855: if (fn + lines > fnlast) { ! 1856: printf("\n"); ! 1857: break; ! 1858: } ! 1859: w = strlen(cp); ! 1860: while (w < width) { ! 1861: w = (w + 8) &~ 7; ! 1862: putchar('\t'); ! 1863: } ! 1864: } ! 1865: } ! 1866: } ! 1867: ! 1868: /* ! 1869: * fmtentry - code lifted from ls. ! 1870: */ ! 1871: char * ! 1872: fmtentry(fn) ! 1873: register struct filenames *fn; ! 1874: { ! 1875: static char fmtres[BUFSIZ]; ! 1876: register struct dinode *ip; ! 1877: register char *cptr, *cp, *dp; ! 1878: ! 1879: dp = &fmtres[0]; ! 1880: for (cp = fn->fname[cmp_level]; *cp; cp++) { ! 1881: if (*cp < ' ' || *cp >= 0177) ! 1882: *dp++ = '?'; ! 1883: else ! 1884: *dp++ = *cp; ! 1885: } ! 1886: addr = itob(fn->ino); ! 1887: if ((cptr = getblk(addr)) == 0) ! 1888: return(NULL); ! 1889: cptr += blkoff(fs, addr); ! 1890: ip = (struct dinode *)cptr; ! 1891: switch (ip->di_mode & IFMT) { ! 1892: case IFDIR: ! 1893: *dp++ = '/'; ! 1894: break; ! 1895: case IFLNK: ! 1896: *dp++ = '@'; ! 1897: break; ! 1898: case IFSOCK: ! 1899: *dp++ = '='; ! 1900: break; ! 1901: /* case IFIFO: ! 1902: *dp++ = 'f'; ! 1903: break; SYSTEM V only */ ! 1904: case IFCHR: ! 1905: case IFBLK: ! 1906: case IFREG: ! 1907: if (ip->di_mode & 0111) ! 1908: *dp++ = '*'; ! 1909: else ! 1910: *dp++ = ' '; ! 1911: break; ! 1912: default: ! 1913: *dp++ = '?'; ! 1914: ! 1915: } ! 1916: *dp++ = 0; ! 1917: return (fmtres); ! 1918: } ! 1919: ! 1920: /* ! 1921: * fcmp - routine used by qsort. Will sort first by name, then ! 1922: * then by pathname length if names are equal. Uses global ! 1923: * cmp_level to tell what component of the path name we are comparing. ! 1924: */ ! 1925: fcmp(f1, f2) ! 1926: register struct filenames *f1, *f2; ! 1927: { ! 1928: int value; ! 1929: ! 1930: if ((value = strcmp(f1->fname[cmp_level], f2->fname[cmp_level]))) ! 1931: return(value); ! 1932: return (f1->len - f2->len); ! 1933: } ! 1934: ! 1935: /* ! 1936: * ffcmp - routine used by qsort. Sort only by pathname length. ! 1937: */ ! 1938: ffcmp(f1, f2) ! 1939: register struct filenames *f1, *f2; ! 1940: { ! 1941: return (f1->len - f2->len); ! 1942: } ! 1943: ! 1944: /* ! 1945: * parse - set up the call to follow_path. ! 1946: */ ! 1947: parse() ! 1948: { ! 1949: register int i, j; ! 1950: char c; ! 1951: ! 1952: stack_pathp = input_pathp = -1; ! 1953: if ((c = getachar()) == '/') { ! 1954: while ((c = getachar()) == '/') ! 1955: ; ! 1956: ungetachar(c); ! 1957: cur_inum = 2; ! 1958: if ((c = getachar()) == '\n') { ! 1959: ungetachar('\n'); ! 1960: if (doing_cd) { ! 1961: top++; ! 1962: top->ino = 2; ! 1963: top->len = -1; ! 1964: nfiles = 1; ! 1965: return; ! 1966: } ! 1967: } else ! 1968: ungetachar(c); ! 1969: } else { ! 1970: ungetachar(c); ! 1971: stack_pathp = current_pathp; ! 1972: if (!doing_find) ! 1973: input_pathp = current_pathp; ! 1974: for (i = 0; i <= current_pathp; i++) { ! 1975: if (!doing_find) ! 1976: strcpy(input_path[i], current_path[i]); ! 1977: strcpy(stack_path[i], current_path[i]); ! 1978: } ! 1979: } ! 1980: getname(); ! 1981: follow_path(stack_pathp + 1, cur_inum); ! 1982: } ! 1983: ! 1984: /* ! 1985: * follow_path - called by cd, find, and ls. ! 1986: * input_path holds the name typed by the user. ! 1987: * stack_path holds the name at the current depth. ! 1988: */ ! 1989: follow_path(level, inum) ! 1990: long level, inum; ! 1991: { ! 1992: register struct direct *dirp; ! 1993: register char **ccptr, *cptr, c; ! 1994: register int i; ! 1995: struct filenames *tos, *bos, *fn, *fnn, *fnnn; ! 1996: long block; ! 1997: short mode; ! 1998: ! 1999: tos = top + 1; ! 2000: restore_inode(inum); ! 2001: if ((mode = icheck(addr)) == 0) ! 2002: return; ! 2003: if ((mode & IFMT) != IFDIR) ! 2004: return; ! 2005: block = cur_bytes = 0; ! 2006: while (cur_bytes < filesize) { ! 2007: if (block == 0 || bcomp(addr)) { ! 2008: error = 0; ! 2009: if ((addr = (bmap(block++) << FRGSHIFT)) == 0) ! 2010: break; ! 2011: if ((cptr = getblk(addr)) == 0) ! 2012: break; ! 2013: cptr += blkoff(fs, addr); ! 2014: } ! 2015: dirp = (struct direct *)cptr; ! 2016: if (dirp->d_ino) { ! 2017: if (level > input_pathp || doing_find || ! 2018: compare(input_path[level], &dirp->d_name[0], 1)) { ! 2019: if (++top - filenames >= MAXFILES) { ! 2020: printf("too many files\n"); ! 2021: error++; ! 2022: return; ! 2023: } ! 2024: top->fname = (char **)calloc(FIRST_DEPTH, sizeof (char **)); ! 2025: top->flag = 0; ! 2026: if (top->fname == 0) { ! 2027: printf("out of memory\n"); ! 2028: error++; ! 2029: return; ! 2030: } ! 2031: nfiles++; ! 2032: top->ino = dirp->d_ino; ! 2033: top->len = stack_pathp; ! 2034: top->find = 0; ! 2035: if (doing_find) { ! 2036: if (find_by_name) { ! 2037: if (compare(input_path[0], &dirp->d_name[0], 1)) ! 2038: top->find = 1; ! 2039: } else if (find_by_inode) ! 2040: if (find_ino == dirp->d_ino) ! 2041: top->find = 1; ! 2042: } ! 2043: if (top->len + 1 >= FIRST_DEPTH && top->flag == 0) { ! 2044: ccptr = (char **)calloc(SECOND_DEPTH, sizeof (char **)); ! 2045: if (ccptr == 0) { ! 2046: printf("out of memory\n"); ! 2047: error++; ! 2048: return; ! 2049: } ! 2050: for (i = 0; i < FIRST_DEPTH; i++) ! 2051: ccptr[i] = top->fname[i]; ! 2052: free((char *)top->fname); ! 2053: top->fname = ccptr; ! 2054: top->flag = 1; ! 2055: } ! 2056: if (top->len >= SECOND_DEPTH) { ! 2057: printf("maximum depth exceeded, try to cd lower\n"); ! 2058: error++; ! 2059: return; ! 2060: } ! 2061: /* ! 2062: * Copy current depth. ! 2063: */ ! 2064: for (i = 0; i <= stack_pathp; i++) { ! 2065: top->fname[i]=calloc(1, strlen(stack_path[i])+1); ! 2066: if (top->fname[i] == 0) { ! 2067: printf("out of memory\n"); ! 2068: error++; ! 2069: return; ! 2070: } ! 2071: strcpy(top->fname[i], stack_path[i]); ! 2072: } ! 2073: /* ! 2074: * Check for '.' or '..' typed. ! 2075: */ ! 2076: if ((level <= input_pathp) && ! 2077: (strcmp(input_path[level], ".") == 0 || ! 2078: strcmp(input_path[level], "..") == 0)) { ! 2079: if (strcmp(input_path[level],"..") == 0 && ! 2080: top->len >= 0) { ! 2081: free(top->fname[top->len]); ! 2082: top->len -= 1; ! 2083: } ! 2084: } else { ! 2085: /* ! 2086: * Check for duplicates. ! 2087: */ ! 2088: if (!doing_cd && !doing_find) { ! 2089: for (fn = filenames; fn < top; fn++) { ! 2090: if (fn->ino == dirp->d_ino && ! 2091: fn->len == stack_pathp + 1) { ! 2092: for (i = 0; i < fn->len; i++) ! 2093: if (strcmp(fn->fname[i], stack_path[i])) ! 2094: break; ! 2095: if (i != fn->len || ! 2096: strcmp(fn->fname[i], dirp->d_name)) ! 2097: continue; ! 2098: freemem(top, 1); ! 2099: if (top == filenames) ! 2100: top = NULL; ! 2101: else ! 2102: top--; ! 2103: nfiles--; ! 2104: goto duplicate; ! 2105: } ! 2106: } ! 2107: } ! 2108: top->len += 1; ! 2109: top->fname[top->len] = calloc(1, ! 2110: strlen(&dirp->d_name[0])+1); ! 2111: if (top->fname[top->len] == 0) { ! 2112: printf("out of memory\n"); ! 2113: error++; ! 2114: return; ! 2115: } ! 2116: strcpy(top->fname[top->len], &dirp->d_name[0]); ! 2117: } ! 2118: } ! 2119: } ! 2120: duplicate: ! 2121: addr += dirp->d_reclen; ! 2122: cptr += dirp->d_reclen; ! 2123: cur_bytes += dirp->d_reclen; ! 2124: } ! 2125: if (top < filenames) ! 2126: return; ! 2127: if ((doing_cd && level == input_pathp) || ! 2128: (!recursive && !doing_find && level > input_pathp)) ! 2129: return; ! 2130: bos = top; ! 2131: /* ! 2132: * Check newly added entries to determine if further expansion ! 2133: * is required. ! 2134: */ ! 2135: for (fn = tos; fn <= bos; fn++) { ! 2136: /* ! 2137: * Avoid '.' and '..' if beyond input. ! 2138: */ ! 2139: if ((recursive || doing_find) && (level > input_pathp) && ! 2140: (strcmp(fn->fname[fn->len], ".") == 0 || ! 2141: strcmp(fn->fname[fn->len], "..") == 0)) ! 2142: continue; ! 2143: restore_inode(fn->ino); ! 2144: if ((mode = icheck(cur_ino)) == 0) ! 2145: return; ! 2146: if ((mode & IFMT) == IFDIR || level < input_pathp) { ! 2147: /* ! 2148: * Set up current depth, remove current entry and ! 2149: * continue recursion. ! 2150: */ ! 2151: for (i = 0; i <= fn->len; i++) ! 2152: strcpy(stack_path[i], fn->fname[i]); ! 2153: stack_pathp = fn->len; ! 2154: if (!doing_find && ! 2155: (!recursive || (recursive && level <= input_pathp))) { ! 2156: /* ! 2157: * Remove current entry by moving others up. ! 2158: */ ! 2159: freemem(fn, 1); ! 2160: fnn = fn; ! 2161: for (fnnn = fnn, fnn++; fnn <= top; fnnn = fnn, fnn++) { ! 2162: fnnn->ino = fnn->ino; ! 2163: fnnn->len = fnn->len; ! 2164: if (fnnn->len + 1 < FIRST_DEPTH) { ! 2165: fnnn->fname = (char **)calloc(FIRST_DEPTH, ! 2166: sizeof (char **)); ! 2167: fnnn->flag = 0; ! 2168: } else if (fnnn->len < SECOND_DEPTH) { ! 2169: fnnn->fname = (char **)calloc(SECOND_DEPTH, ! 2170: sizeof (char **)); ! 2171: fnnn->flag = 1; ! 2172: } else { ! 2173: printf("maximum depth exceeded, "); ! 2174: printf("try to cd lower\n"); ! 2175: error++; ! 2176: return; ! 2177: } ! 2178: for (i = 0; i <= fnn->len; i++) ! 2179: fnnn->fname[i] = fnn->fname[i]; ! 2180: } ! 2181: if (fn == tos) ! 2182: fn--; ! 2183: top--; ! 2184: bos--; ! 2185: nfiles--; ! 2186: } ! 2187: follow_path(level + 1, cur_inum); ! 2188: if (error) ! 2189: return; ! 2190: } ! 2191: } ! 2192: } ! 2193: ! 2194: /* ! 2195: * getname - break up the pathname entered by the user into components. ! 2196: */ ! 2197: getname() ! 2198: { ! 2199: register int i; ! 2200: char c; ! 2201: ! 2202: if ((c = getachar()) == '\n') { ! 2203: ungetachar(c); ! 2204: return; ! 2205: } ! 2206: ungetachar(c); ! 2207: input_pathp++; ! 2208: clear: ! 2209: for (i = 0; i < MAXNAMLEN; i++) ! 2210: input_path[input_pathp][i] = '\0'; ! 2211: for (;;) { ! 2212: c = getachar(); ! 2213: if (c == '\\') { ! 2214: if (strlen(input_path[input_pathp]) + 1 >= MAXNAMLEN) { ! 2215: printf("maximum name length exceeded, "); ! 2216: printf("truncating\n"); ! 2217: return; ! 2218: } ! 2219: input_path[input_pathp][strlen(input_path[input_pathp])] = c; ! 2220: input_path[input_pathp][strlen(input_path[input_pathp])] = ! 2221: getachar(); ! 2222: continue; ! 2223: } ! 2224: if (c == ' ' || c == '\n') { ! 2225: ungetachar(c); ! 2226: return; ! 2227: } ! 2228: if (!doing_find && c == '/') { ! 2229: if (++input_pathp >= MAXPATHLEN) { ! 2230: printf("maximum path length exceeded, "); ! 2231: printf("truncating\n"); ! 2232: input_pathp--; ! 2233: return; ! 2234: } ! 2235: goto clear; ! 2236: } ! 2237: if (strlen(input_path[input_pathp]) >= MAXNAMLEN) { ! 2238: printf("maximum name length exceeded, truncating\n"); ! 2239: return; ! 2240: } ! 2241: input_path[input_pathp][strlen(input_path[input_pathp])] = c; ! 2242: } ! 2243: } ! 2244: ! 2245: /* ! 2246: * compare - check if a filename matches the pattern entered by the user. ! 2247: * Handles '*', '?', and '[]'. ! 2248: */ ! 2249: compare(s1, s2, at_start) ! 2250: char *s1, *s2; ! 2251: short at_start; ! 2252: { ! 2253: register char c, *s; ! 2254: ! 2255: s = s2; ! 2256: while (c = *s1) { ! 2257: if (c == '*') { ! 2258: if (at_start && s == s2 && !letter(*s2) && !digit(*s2)) ! 2259: return(0); ! 2260: if (*++s1 == 0) ! 2261: return(1); ! 2262: while (*s2) { ! 2263: if (compare(s1, s2, 0)) ! 2264: return(1); ! 2265: if (error) ! 2266: return(0); ! 2267: s2++; ! 2268: } ! 2269: } ! 2270: if (*s2 == 0) ! 2271: return(0); ! 2272: if (c == '\\') { ! 2273: s1++; ! 2274: goto compare_chars; ! 2275: } ! 2276: if (c == '?') { ! 2277: if (at_start && s == s2 && !letter(*s2) && !digit(*s2)) ! 2278: return(0); ! 2279: s1++; ! 2280: s2++; ! 2281: continue; ! 2282: } ! 2283: if (c == '[') { ! 2284: s1++; ! 2285: if (*s2 >= *s1++) { ! 2286: if (*s1++ != '-') { ! 2287: printf("missing '-'\n"); ! 2288: error++; ! 2289: return(0); ! 2290: } ! 2291: if (*s2 <= *s1++) { ! 2292: if (*s1++ != ']') { ! 2293: printf("missing ']'"); ! 2294: error++; ! 2295: return(0); ! 2296: } ! 2297: s2++; ! 2298: continue; ! 2299: } ! 2300: } ! 2301: } ! 2302: compare_chars: ! 2303: if (*s1++ == *s2++) ! 2304: continue; ! 2305: else ! 2306: return(0); ! 2307: } ! 2308: if (*s1 == *s2) ! 2309: return(1); ! 2310: return(0); ! 2311: } ! 2312: ! 2313: /* ! 2314: * freemem - free the memory allocated to the filenames structure. ! 2315: */ ! 2316: freemem(p, numb) ! 2317: struct filenames *p; ! 2318: int numb; ! 2319: { ! 2320: register int i, j; ! 2321: ! 2322: if (numb == 0) ! 2323: return; ! 2324: for (i = 0; i < numb; i++, p++) { ! 2325: for (j = 0; j <= p->len; j++) ! 2326: free(p->fname[j]); ! 2327: free((char *)p->fname); ! 2328: } ! 2329: } ! 2330: ! 2331: /* ! 2332: * print_path - print the pathname held in p. ! 2333: */ ! 2334: print_path(p, pntr) ! 2335: char *p[]; ! 2336: short pntr; ! 2337: { ! 2338: register int i; ! 2339: ! 2340: printf("/"); ! 2341: if (pntr >= 0) { ! 2342: for (i = 0; i < pntr; i++) ! 2343: printf("%s/", p[i]); ! 2344: printf("%s", p[pntr]); ! 2345: } ! 2346: } ! 2347: ! 2348: /* ! 2349: * fill - fill a section with a value or string. ! 2350: * addr,count:fill=[value, "string"]. ! 2351: */ ! 2352: fill() ! 2353: { ! 2354: register char *cptr; ! 2355: register int i; ! 2356: short eof_flag, end = 0, eof = 0; ! 2357: long temp, tcount, taddr; ! 2358: ! 2359: if (!wrtflag) { ! 2360: printf("not opened for write '-w'\n"); ! 2361: error++; ! 2362: return; ! 2363: } ! 2364: temp = expr(); ! 2365: if (error) ! 2366: return; ! 2367: if ((cptr = getblk(addr)) == 0) ! 2368: return; ! 2369: if (type == NUMB) ! 2370: eof_flag = 0; ! 2371: else ! 2372: eof_flag = 1; ! 2373: taddr = addr; ! 2374: switch (objsz) { ! 2375: case LONG: ! 2376: addr &= ~(LONG - 1); ! 2377: break; ! 2378: case SHORT: ! 2379: addr &= ~(SHORT - 1); ! 2380: temp &= 0177777L; ! 2381: break; ! 2382: case CHAR: ! 2383: temp &= 0377; ! 2384: } ! 2385: cur_bytes -= taddr - addr; ! 2386: cptr += blkoff(fs, addr); ! 2387: tcount = check_addr(eof_flag, &end, &eof, 0); ! 2388: for (i = 0; i < tcount; i++) { ! 2389: switch (objsz) { ! 2390: case LONG: ! 2391: *(long *)cptr = temp; ! 2392: break; ! 2393: case SHORT: ! 2394: *(short *)cptr = temp; ! 2395: break; ! 2396: case CHAR: ! 2397: *cptr = temp; ! 2398: } ! 2399: cptr += objsz; ! 2400: } ! 2401: addr += (tcount - 1) * objsz; ! 2402: cur_bytes += (tcount - 1) * objsz; ! 2403: put(temp, objsz); ! 2404: if (eof) { ! 2405: printf("end of file\n"); ! 2406: error++; ! 2407: } else if (end) { ! 2408: printf("end of block\n"); ! 2409: error++; ! 2410: } ! 2411: } ! 2412: ! 2413: /* ! 2414: * get - read a byte, short or long from the file system. ! 2415: * The entire block containing the desired item is read ! 2416: * and the appropriate data is extracted and returned. ! 2417: */ ! 2418: long ! 2419: get(lngth) ! 2420: short lngth; ! 2421: { ! 2422: ! 2423: register char *bptr; ! 2424: long temp = addr; ! 2425: ! 2426: objsz = lngth; ! 2427: if (objsz == INODE || objsz == SHORT) ! 2428: temp &= ~(SHORT - 1); ! 2429: else if (objsz == DIRECTORY || objsz == LONG) ! 2430: temp &= ~(LONG - 1); ! 2431: if ((bptr = getblk(temp)) == 0) ! 2432: return(-1); ! 2433: bptr += blkoff(fs, temp); ! 2434: switch (objsz) { ! 2435: case CHAR: ! 2436: return((long)*bptr); ! 2437: case SHORT: ! 2438: case INODE: ! 2439: return((long)(*(short *)bptr)); ! 2440: case LONG: ! 2441: case DIRECTORY: ! 2442: return(*(long *)bptr); ! 2443: } ! 2444: return(0); ! 2445: } ! 2446: ! 2447: /* ! 2448: * cgrp_check - make sure that we don't bump the cylinder group ! 2449: * beyond the total number of cylinder groups or before the start. ! 2450: */ ! 2451: cgrp_check(cgrp) ! 2452: long cgrp; ! 2453: { ! 2454: if (cgrp < 0) { ! 2455: if (objsz == CGRP) ! 2456: printf("beginning of cylinder groups\n"); ! 2457: else ! 2458: printf("beginning of super blocks\n"); ! 2459: error++; ! 2460: return(0); ! 2461: } ! 2462: if (cgrp >= fs->fs_ncg) { ! 2463: if (objsz == CGRP) ! 2464: printf("end of cylinder groups\n"); ! 2465: else ! 2466: printf("end of super blocks\n"); ! 2467: error++; ! 2468: return(0); ! 2469: } ! 2470: if (objsz == CGRP) ! 2471: return(cgtod(fs, cgrp) << FRGSHIFT); ! 2472: else ! 2473: return(cgsblock(fs, cgrp) << FRGSHIFT); ! 2474: } ! 2475: ! 2476: /* ! 2477: * icheck - make sure we can read the block containing the inode ! 2478: * and determine the filesize (0 if inode not allocated). Return ! 2479: * 0 if error otherwise return the mode. ! 2480: */ ! 2481: icheck(address) ! 2482: long address; ! 2483: { ! 2484: register char *cptr; ! 2485: register struct dinode *ip; ! 2486: ! 2487: if ((cptr = getblk(address)) == 0) ! 2488: return(0); ! 2489: cptr += blkoff(fs, address); ! 2490: ip = (struct dinode *)cptr; ! 2491: if ((ip->di_mode & IFMT) == 0) { ! 2492: if (!override) { ! 2493: printf("inode not allocated\n"); ! 2494: error++; ! 2495: return(0); ! 2496: } ! 2497: blocksize = filesize = 0; ! 2498: } else { ! 2499: trapped++; ! 2500: filesize = ip->di_size; ! 2501: blocksize = filesize * 2; ! 2502: } ! 2503: return(ip->di_mode); ! 2504: } ! 2505: ! 2506: /* ! 2507: * getdirslot - get the address of the directory slot desired. ! 2508: */ ! 2509: getdirslot(slot) ! 2510: short slot; ! 2511: { ! 2512: register char *cptr; ! 2513: register struct direct *dirp; ! 2514: register short i; ! 2515: char *string = &scratch[0]; ! 2516: short bod = 0, mode, temp; ! 2517: ! 2518: if (slot < 0) { ! 2519: slot = 0; ! 2520: bod++; ! 2521: } ! 2522: if (type != DIRECTORY) { ! 2523: if (type == BLOCK) ! 2524: string = "block"; ! 2525: else ! 2526: string = "fragment"; ! 2527: addr = bod_addr; ! 2528: if ((cptr = getblk(addr)) == 0) ! 2529: return(0); ! 2530: cptr += blkoff(fs, addr); ! 2531: cur_bytes = 0; ! 2532: dirp = (struct direct *)cptr; ! 2533: for (dirslot = 0; dirslot < slot; dirslot++) { ! 2534: dirp = (struct direct *)cptr; ! 2535: if (blocksize > filesize) { ! 2536: if (cur_bytes + dirp->d_reclen >= filesize) { ! 2537: printf("end of file\n"); ! 2538: erraddr = addr; ! 2539: errcur_bytes = cur_bytes; ! 2540: stringsize = STRINGSIZE(dirp); ! 2541: error++; ! 2542: return(addr); ! 2543: } ! 2544: } else { ! 2545: if (cur_bytes + dirp->d_reclen >= blocksize) { ! 2546: printf("end of %s\n", string); ! 2547: erraddr = addr; ! 2548: errcur_bytes = cur_bytes; ! 2549: stringsize = STRINGSIZE(dirp); ! 2550: error++; ! 2551: return(addr); ! 2552: } ! 2553: } ! 2554: cptr += dirp->d_reclen; ! 2555: addr += dirp->d_reclen; ! 2556: cur_bytes += dirp->d_reclen; ! 2557: } ! 2558: if (bod) { ! 2559: if (blocksize > filesize) ! 2560: printf("beginning of file\n"); ! 2561: else ! 2562: printf("beginning of %s\n", string); ! 2563: erraddr = addr; ! 2564: errcur_bytes = cur_bytes; ! 2565: error++; ! 2566: } ! 2567: stringsize = STRINGSIZE(dirp); ! 2568: return(addr); ! 2569: } else { ! 2570: addr = cur_ino; ! 2571: if ((mode = icheck(addr)) == 0) ! 2572: return(0); ! 2573: if (!override && (mode & IFDIR) == 0) { ! 2574: printf("inode is not a directory\n"); ! 2575: error++; ! 2576: return(0); ! 2577: } ! 2578: temp = slot; ! 2579: i = cur_bytes = 0; ! 2580: for (;;) { ! 2581: if (i == 0 || bcomp(addr)) { ! 2582: error = 0; ! 2583: if ((addr=(bmap(i++) << FRGSHIFT)) == 0) ! 2584: break; ! 2585: if ((cptr = getblk(addr)) == 0) ! 2586: break; ! 2587: cptr += blkoff(fs, addr); ! 2588: } ! 2589: dirp = (struct direct *)cptr; ! 2590: value = dirp->d_ino; ! 2591: if (!temp--) ! 2592: break; ! 2593: if (cur_bytes + dirp->d_reclen >= filesize) { ! 2594: printf("end of file\n"); ! 2595: dirslot = slot - temp - 1; ! 2596: objsz = DIRECTORY; ! 2597: erraddr = addr; ! 2598: errcur_bytes = cur_bytes; ! 2599: stringsize = STRINGSIZE(dirp); ! 2600: error++; ! 2601: return(addr); ! 2602: } ! 2603: addr += dirp->d_reclen; ! 2604: cptr += dirp->d_reclen; ! 2605: cur_bytes += dirp->d_reclen; ! 2606: } ! 2607: dirslot = slot; ! 2608: objsz = DIRECTORY; ! 2609: if (bod) { ! 2610: printf("beginning of file\n"); ! 2611: erraddr = addr; ! 2612: errcur_bytes = cur_bytes; ! 2613: error++; ! 2614: } ! 2615: stringsize = STRINGSIZE(dirp); ! 2616: return(addr); ! 2617: } ! 2618: } ! 2619: ! 2620: /* ! 2621: * putf - print a byte as an ascii character if possible. ! 2622: * The exceptions are tabs, newlines, backslashes ! 2623: * and nulls which are printed as the standard C ! 2624: * language escapes. Characters which are not ! 2625: * recognized are printed as \?. ! 2626: */ ! 2627: putf(c) ! 2628: register char c; ! 2629: { ! 2630: ! 2631: if (c<=037 || c>=0177 || c=='\\') { ! 2632: printf("\\"); ! 2633: switch (c) { ! 2634: case '\\': ! 2635: printf("\\"); ! 2636: break; ! 2637: case '\t': ! 2638: printf("t"); ! 2639: break; ! 2640: case '\n': ! 2641: printf("n"); ! 2642: break; ! 2643: case '\0': ! 2644: printf("0"); ! 2645: break; ! 2646: default: ! 2647: printf("?"); ! 2648: } ! 2649: } ! 2650: else { ! 2651: printf("%c", c); ! 2652: printf(" "); ! 2653: } ! 2654: } ! 2655: ! 2656: /* ! 2657: * put - write an item into the buffer for the current address ! 2658: * block. The value is checked to make sure that it will ! 2659: * fit in the size given without truncation. If successful, ! 2660: * the entire block is written back to the file system. ! 2661: */ ! 2662: put(item,lngth) ! 2663: long item; ! 2664: short lngth; ! 2665: { ! 2666: ! 2667: register char *bptr, *sbptr; ! 2668: register long *vptr; ! 2669: long s_err,nbytes; ! 2670: long olditem; ! 2671: ! 2672: if (!wrtflag) { ! 2673: printf("not opened for write '-w'\n"); ! 2674: error++; ! 2675: return; ! 2676: } ! 2677: objsz = lngth; ! 2678: if ((sbptr = getblk(addr)) == 0) ! 2679: return; ! 2680: bptr = sbptr + blkoff(fs, addr); ! 2681: switch (objsz) { ! 2682: case LONG: ! 2683: case DIRECTORY: ! 2684: olditem = *(long *)bptr; ! 2685: *(long *)bptr = item; ! 2686: break; ! 2687: case SHORT: ! 2688: case INODE: ! 2689: olditem = (long)*(short *)bptr; ! 2690: item &= 0177777L; ! 2691: *(short *)bptr = item; ! 2692: break; ! 2693: case CHAR: ! 2694: olditem = (long)*bptr; ! 2695: item &= 0377; ! 2696: *bptr = lobyte(loword(item)); ! 2697: break; ! 2698: default: ! 2699: error++; ! 2700: return; ! 2701: } ! 2702: if ((s_err = lseek(fd, addr & fs->fs_bmask, 0)) == -1) { ! 2703: error++; ! 2704: printf("seek error : %x\n",addr); ! 2705: return(0); ! 2706: } ! 2707: if ((nbytes = write(fd, sbptr, BLKSIZE)) != BLKSIZE) { ! 2708: error++; ! 2709: printf("write error : addr = %x\n",addr); ! 2710: printf(" : s_err = %x\n",s_err); ! 2711: printf(" : nbytes = %x\n",nbytes); ! 2712: return(0); ! 2713: } ! 2714: if (!acting_on_inode && objsz != INODE && objsz != DIRECTORY) { ! 2715: index(base); ! 2716: print(olditem, 8, -8, 0); ! 2717: printf("\t=\t"); ! 2718: print(item, 8, -8, 0); ! 2719: printf("\n"); ! 2720: } else { ! 2721: if (objsz == DIRECTORY) { ! 2722: addr = cur_dir; ! 2723: fprnt('?', 'd'); ! 2724: } else { ! 2725: addr = cur_ino; ! 2726: objsz = INODE; ! 2727: fprnt('?', 'i'); ! 2728: } ! 2729: } ! 2730: return; ! 2731: } ! 2732: ! 2733: /* ! 2734: * getblk - check if the desired block is in the file system. ! 2735: * Search the incore buffers to see if the block is already ! 2736: * available. If successful, unlink the buffer control block ! 2737: * from its position in the buffer list and re-insert it at ! 2738: * the head of the list. If failure, use the last buffer ! 2739: * in the list for the desired block. Again, this control ! 2740: * block is placed at the head of the list. This process ! 2741: * will leave commonly requested blocks in the in-core buffers. ! 2742: * Finally, a pointer to the buffer is returned. ! 2743: */ ! 2744: char * ! 2745: getblk(address) ! 2746: long address; ! 2747: { ! 2748: ! 2749: register struct buf *bp; ! 2750: long s_err, nbytes; ! 2751: unsigned long block; ! 2752: ! 2753: read_requests++; ! 2754: block = lblkno(fs, address); ! 2755: if (block >= fragstoblks(fs, fs->fs_size)) { ! 2756: printf("block exceeds maximum block in file system\n"); ! 2757: error++; ! 2758: return(0); ! 2759: } ! 2760: for (bp=bhdr.fwd; bp!= &bhdr; bp=bp->fwd) ! 2761: if (bp->valid && bp->blkno==block) ! 2762: goto xit; ! 2763: actual_disk_reads++; ! 2764: bp = bhdr.back; ! 2765: bp->blkno = block; ! 2766: bp->valid = 0; ! 2767: if ((s_err = lseek(fd, address & fs->fs_bmask, 0)) == -1) { ! 2768: error++; ! 2769: printf("seek error : %x\n",address); ! 2770: return(0); ! 2771: } ! 2772: if ((nbytes = read(fd, bp->blkaddr, BLKSIZE)) != BLKSIZE) { ! 2773: error++; ! 2774: printf("read error : addr = %x\n",address); ! 2775: printf(" : s_err = %x\n",s_err); ! 2776: printf(" : nbytes = %x\n",nbytes); ! 2777: return(0); ! 2778: } ! 2779: bp->valid++; ! 2780: xit: bp->back->fwd = bp->fwd; ! 2781: bp->fwd->back = bp->back; ! 2782: insert(bp); ! 2783: return(bp->blkaddr); ! 2784: } ! 2785: ! 2786: /* ! 2787: * insert - place the designated buffer control block ! 2788: * at the head of the linked list of buffers. ! 2789: */ ! 2790: insert(bp) ! 2791: register struct buf *bp; ! 2792: { ! 2793: ! 2794: bp->back = &bhdr; ! 2795: bp->fwd = bhdr.fwd; ! 2796: bhdr.fwd->back = bp; ! 2797: bhdr.fwd = bp; ! 2798: } ! 2799: ! 2800: /* ! 2801: * err - called on interrupts. Set the current address ! 2802: * back to the last address stored in erraddr. Reset all ! 2803: * appropriate flags. A reset call is made to return ! 2804: * to the main loop; ! 2805: */ ! 2806: err() ! 2807: { ! 2808: freemem(filenames, nfiles); ! 2809: nfiles = 0; ! 2810: signal(2,err); ! 2811: addr = erraddr; ! 2812: cur_ino = errino; ! 2813: cur_inum = errinum; ! 2814: cur_bytes = errcur_bytes; ! 2815: error = 0; ! 2816: c_count = 0; ! 2817: printf("\n?\n"); ! 2818: fseek(stdin, 0L, 2); ! 2819: longjmp(env,0); ! 2820: } ! 2821: ! 2822: /* ! 2823: * devcheck - check that the given mode represents a ! 2824: * special device. The IFCHR bit is on for both ! 2825: * character and block devices. ! 2826: */ ! 2827: devcheck(md) ! 2828: register short md; ! 2829: { ! 2830: if (override) ! 2831: return(0); ! 2832: if (md & IFCHR) ! 2833: return(0); ! 2834: printf("not character or block device\n"); ! 2835: error++; ! 2836: return(1); ! 2837: } ! 2838: ! 2839: /* ! 2840: * nullblk - return error if address is zero. This is done ! 2841: * to prevent block 0 from being used as an indirect block ! 2842: * for a large file or as a data block for a small file. ! 2843: */ ! 2844: nullblk(bn) ! 2845: long bn; ! 2846: { ! 2847: if (bn != 0) ! 2848: return(0); ! 2849: printf("non existent block\n"); ! 2850: error++; ! 2851: return(1); ! 2852: } ! 2853: ! 2854: /* ! 2855: * puta - put ascii characters into a buffer. The string ! 2856: * terminates with a quote or newline. The leading quote, ! 2857: * which is optional for directory names, was stripped off ! 2858: * by the assignment case in the main loop. ! 2859: */ ! 2860: puta() ! 2861: { ! 2862: register char *cptr, c; ! 2863: register int i; ! 2864: char *sbptr; ! 2865: short terror = 0; ! 2866: long maxchars, s_err, nbytes, temp; ! 2867: long taddr = addr, tcount = 0, item, olditem = 0; ! 2868: ! 2869: if (!wrtflag) { ! 2870: printf("not opened for write '-w'\n"); ! 2871: error++; ! 2872: return; ! 2873: } ! 2874: if ((sbptr = getblk(addr)) == 0) ! 2875: return; ! 2876: cptr = sbptr + blkoff(fs, addr); ! 2877: if (objsz == DIRECTORY) { ! 2878: if (acting_on_directory) ! 2879: maxchars = stringsize - 1; ! 2880: else ! 2881: maxchars = LONG; ! 2882: } else if (objsz == INODE) ! 2883: maxchars = objsz - (addr - cur_ino); ! 2884: else ! 2885: maxchars = min(blocksize - cur_bytes, filesize - cur_bytes); ! 2886: while ((c = getachar()) != '"') { ! 2887: if (tcount >= maxchars) { ! 2888: printf("string too long\n"); ! 2889: if (objsz == DIRECTORY) ! 2890: addr = cur_dir; ! 2891: else if (acting_on_inode || objsz == INODE) ! 2892: addr = cur_ino; ! 2893: else ! 2894: addr = taddr; ! 2895: erraddr = addr; ! 2896: errcur_bytes = cur_bytes; ! 2897: terror++; ! 2898: break; ! 2899: } ! 2900: tcount++; ! 2901: if (c == '\n') { ! 2902: ungetachar(c); ! 2903: break; ! 2904: } ! 2905: temp = (long)*cptr; ! 2906: olditem <<= BITSPERCHAR; ! 2907: olditem += temp & 0xff; ! 2908: if (c == '\\') { ! 2909: switch (c = getachar()) { ! 2910: case 't': ! 2911: *cptr++ = '\t'; ! 2912: break; ! 2913: case 'n': ! 2914: *cptr++ = '\n'; ! 2915: break; ! 2916: case '0': ! 2917: *cptr++ = '\0'; ! 2918: break; ! 2919: default: ! 2920: *cptr++ = c; ! 2921: break; ! 2922: } ! 2923: } ! 2924: else ! 2925: *cptr++ = c; ! 2926: } ! 2927: if (objsz == DIRECTORY && acting_on_directory) ! 2928: for (i = tcount; i <= maxchars; i++) ! 2929: *cptr++ = '\0'; ! 2930: if ((s_err = lseek(fd, addr & fs->fs_bmask, 0)) == -1) { ! 2931: error++; ! 2932: printf("seek error : %x\n",addr); ! 2933: return(0); ! 2934: } ! 2935: if ((nbytes = write(fd, sbptr, BLKSIZE)) != BLKSIZE) { ! 2936: error++; ! 2937: printf("write error : addr = %x\n",addr); ! 2938: printf(" : s_err = %x\n",s_err); ! 2939: printf(" : nbytes = %x\n",nbytes); ! 2940: return(0); ! 2941: } ! 2942: if (!acting_on_inode && objsz != INODE && objsz != DIRECTORY) { ! 2943: addr += tcount; ! 2944: cur_bytes += tcount; ! 2945: taddr = addr; ! 2946: if (objsz != CHAR) { ! 2947: addr &= ~(objsz - 1); ! 2948: cur_bytes -= taddr - addr; ! 2949: } ! 2950: if (addr == taddr) { ! 2951: addr -= objsz; ! 2952: taddr = addr; ! 2953: } ! 2954: tcount = LONG - (taddr - addr); ! 2955: index(base); ! 2956: if ((cptr = getblk(addr)) == 0) ! 2957: return; ! 2958: cptr += blkoff(fs, addr); ! 2959: switch (objsz) { ! 2960: case LONG: ! 2961: item = *(long *)cptr; ! 2962: if (tcount < LONG) { ! 2963: olditem <<= tcount * BITSPERCHAR; ! 2964: temp = 1; ! 2965: for (i = 0; i < (tcount*BITSPERCHAR); i++) ! 2966: temp <<= 1; ! 2967: olditem += item & (temp - 1); ! 2968: } ! 2969: break; ! 2970: case SHORT: ! 2971: item = (long)*(short *)cptr; ! 2972: if (tcount < SHORT) { ! 2973: olditem <<= tcount * BITSPERCHAR; ! 2974: temp = 1; ! 2975: for (i = 0; i < (tcount * BITSPERCHAR); i++) ! 2976: temp <<= 1; ! 2977: olditem += item & (temp - 1); ! 2978: } ! 2979: olditem &= 0177777L; ! 2980: break; ! 2981: case CHAR: ! 2982: item = (long)*cptr; ! 2983: olditem &= 0377; ! 2984: } ! 2985: print(olditem, 8, -8, 0); ! 2986: printf("\t=\t"); ! 2987: print(item, 8, -8, 0); ! 2988: printf("\n"); ! 2989: } else { ! 2990: if (objsz == DIRECTORY) { ! 2991: addr = cur_dir; ! 2992: fprnt('?', 'd'); ! 2993: } else { ! 2994: addr = cur_ino; ! 2995: objsz = INODE; ! 2996: fprnt('?', 'i'); ! 2997: } ! 2998: } ! 2999: if (terror) ! 3000: error++; ! 3001: } ! 3002: ! 3003: /* ! 3004: * fprnt - print data. 'count' elements are printed where '*' will ! 3005: * print an entire blocks worth or up to the eof, whichever ! 3006: * occurs first. An error will occur if crossing a block boundary ! 3007: * is attempted since consecutive blocks don't usually have ! 3008: * meaning. Current print types: ! 3009: * / b - print as bytes (base sensitive) ! 3010: * c - print as characters ! 3011: * o O - print as octal shorts (longs) ! 3012: * d D - print as decimal shorts (longs) ! 3013: * x X - print as hexadecimal shorts (longs) ! 3014: * ? c - print as cylinder groups ! 3015: * d - print as directories ! 3016: * i - print as inodes ! 3017: * s - print as super blocks ! 3018: */ ! 3019: fprnt(style, po) ! 3020: register char style, po; ! 3021: { ! 3022: register int i; ! 3023: register struct fs *sb; ! 3024: register struct cg *cg; ! 3025: register struct direct *dirp; ! 3026: register struct dinode *ip; ! 3027: int tbase; ! 3028: char c, *cptr, *p; ! 3029: long tinode, tcount, temp, taddr; ! 3030: short offset, mode, end = 0, eof = 0, eof_flag; ! 3031: unsigned short *sptr; ! 3032: unsigned long *lptr; ! 3033: ! 3034: laststyle = style; ! 3035: lastpo = po; ! 3036: should_print = 0; ! 3037: if (count != 1) { ! 3038: if (clear) { ! 3039: count = 1; ! 3040: star = 0; ! 3041: clear = 0; ! 3042: } else ! 3043: clear = 1; ! 3044: } ! 3045: tcount = count; ! 3046: offset = blkoff(fs, addr); ! 3047: ! 3048: if (style == '/') { ! 3049: if (type == NUMB) ! 3050: eof_flag = 0; ! 3051: else ! 3052: eof_flag = 1; ! 3053: switch (po) { ! 3054: ! 3055: case 'c': /* print as characters */ ! 3056: case 'b': /* or bytes */ ! 3057: if ((cptr = getblk(addr)) == 0) ! 3058: return; ! 3059: cptr += offset; ! 3060: objsz = CHAR; ! 3061: tcount = check_addr(eof_flag, &end, &eof, 0); ! 3062: if (tcount) { ! 3063: for (i=0; tcount--; i++) { ! 3064: if (i % 16 == 0) { ! 3065: if (i) ! 3066: printf("\n"); ! 3067: index(base); ! 3068: } ! 3069: if (po == 'c') { ! 3070: putf(*cptr++); ! 3071: if ((i + 1) % 16) ! 3072: printf(" "); ! 3073: } else { ! 3074: if ((i + 1) % 16 == 0) ! 3075: print(*cptr++ & 0377, ! 3076: 2,-2,0); ! 3077: else ! 3078: print(*cptr++ & 0377, ! 3079: 4,-2,0); ! 3080: } ! 3081: addr += CHAR; ! 3082: cur_bytes += CHAR; ! 3083: } ! 3084: printf("\n"); ! 3085: } ! 3086: addr -= CHAR; ! 3087: erraddr = addr; ! 3088: cur_bytes -= CHAR; ! 3089: errcur_bytes = cur_bytes; ! 3090: if (eof) { ! 3091: printf("end of file\n"); ! 3092: error++; ! 3093: } else if (end) { ! 3094: if (type == BLOCK) ! 3095: printf("end of block\n"); ! 3096: else ! 3097: printf("end of fragment\n"); ! 3098: error++; ! 3099: } ! 3100: return; ! 3101: ! 3102: case 'o': /* print as octal shorts */ ! 3103: tbase = OCTAL; ! 3104: goto otx; ! 3105: case 'd': /* print as decimal shorts */ ! 3106: tbase = DECIMAL; ! 3107: goto otx; ! 3108: case 'x': /* print as hex shorts */ ! 3109: tbase = HEX; ! 3110: otx: ! 3111: if ((cptr = getblk(addr)) == 0) ! 3112: return; ! 3113: taddr = addr; ! 3114: addr &= ~(SHORT - 1); ! 3115: cur_bytes -= taddr - addr; ! 3116: cptr += blkoff(fs, addr); ! 3117: sptr = (unsigned short *)cptr; ! 3118: objsz = SHORT; ! 3119: tcount = check_addr(eof_flag, &end, &eof, 0); ! 3120: if (tcount) { ! 3121: for (i=0; tcount--; i++) { ! 3122: sptr = (unsigned short *) ! 3123: print_check(sptr, &tcount, tbase, i); ! 3124: switch (po) { ! 3125: case 'o': ! 3126: printf("%06o ",*sptr++); ! 3127: break; ! 3128: case 'd': ! 3129: printf("%05d ",*sptr++); ! 3130: break; ! 3131: case 'x': ! 3132: printf("%04x ",*sptr++); ! 3133: } ! 3134: addr += SHORT; ! 3135: cur_bytes += SHORT; ! 3136: } ! 3137: printf("\n"); ! 3138: } ! 3139: addr -= SHORT; ! 3140: erraddr = addr; ! 3141: cur_bytes -= SHORT; ! 3142: errcur_bytes = cur_bytes; ! 3143: if (eof) { ! 3144: printf("end of file\n"); ! 3145: error++; ! 3146: } else if (end) { ! 3147: if (type == BLOCK) ! 3148: printf("end of block\n"); ! 3149: else ! 3150: printf("end of fragment\n"); ! 3151: error++; ! 3152: } ! 3153: return; ! 3154: ! 3155: case 'O': /* print as octal longs */ ! 3156: tbase = OCTAL; ! 3157: goto OTX; ! 3158: case 'D': /* print as decimal longs */ ! 3159: tbase = DECIMAL; ! 3160: goto OTX; ! 3161: case 'X': /* print as hex longs */ ! 3162: tbase = HEX; ! 3163: OTX: ! 3164: if ((cptr = getblk(addr)) == 0) ! 3165: return; ! 3166: taddr = addr; ! 3167: addr &= ~(LONG - 1); ! 3168: cur_bytes -= taddr - addr; ! 3169: cptr += blkoff(fs, addr); ! 3170: lptr = (unsigned long *)cptr; ! 3171: objsz = LONG; ! 3172: tcount = check_addr(eof_flag, &end, &eof, 0); ! 3173: if (tcount) { ! 3174: for (i=0; tcount--; i++) { ! 3175: lptr = ! 3176: print_check(lptr, &tcount, tbase, i); ! 3177: switch (po) { ! 3178: case 'O': ! 3179: printf("%011o ",*lptr++); ! 3180: break; ! 3181: case 'D': ! 3182: printf("%010u ",*lptr++); ! 3183: break; ! 3184: case 'X': ! 3185: printf("%08x ",*lptr++); ! 3186: } ! 3187: addr += LONG; ! 3188: cur_bytes += LONG; ! 3189: } ! 3190: printf("\n"); ! 3191: } ! 3192: addr -= LONG; ! 3193: erraddr = addr; ! 3194: cur_bytes -= LONG; ! 3195: errcur_bytes = cur_bytes; ! 3196: if (eof) { ! 3197: printf("end of file\n"); ! 3198: error++; ! 3199: } else if (end) { ! 3200: if (type == BLOCK) ! 3201: printf("end of block\n"); ! 3202: else ! 3203: printf("end of fragment\n"); ! 3204: error++; ! 3205: } ! 3206: return; ! 3207: ! 3208: default: ! 3209: error++; ! 3210: printf("no such print option\n"); ! 3211: return; ! 3212: } ! 3213: } else ! 3214: switch (po) { ! 3215: ! 3216: case 'c': /* print as cylinder group */ ! 3217: if (type != NUMB) ! 3218: if (cur_cgrp + count > fs->fs_ncg) { ! 3219: tcount = fs->fs_ncg - cur_cgrp; ! 3220: if (!star) ! 3221: end++; ! 3222: } ! 3223: addr &= ~(LONG - 1); ! 3224: for (; tcount--;) { ! 3225: erraddr = addr; ! 3226: errcur_bytes = cur_bytes; ! 3227: if (type != NUMB) { ! 3228: addr = cgtod(fs, cur_cgrp) ! 3229: << FRGSHIFT; ! 3230: cur_cgrp++; ! 3231: } ! 3232: if ((cptr = getblk(addr)) == 0) { ! 3233: if (cur_cgrp) ! 3234: cur_cgrp--; ! 3235: return; ! 3236: } ! 3237: cptr += blkoff(fs, addr); ! 3238: cg = (struct cg *)cptr; ! 3239: if (type == NUMB) { ! 3240: cur_cgrp = cg->cg_cgx + 1; ! 3241: type = objsz = CGRP; ! 3242: if (cur_cgrp + count - 1 > fs->fs_ncg) { ! 3243: tcount = fs->fs_ncg - cur_cgrp; ! 3244: if (!star) ! 3245: end++; ! 3246: } ! 3247: } ! 3248: if (!override && !cg_chkmagic(cg)) { ! 3249: printf("invalid cylinder group "); ! 3250: printf("magic word\n"); ! 3251: if (cur_cgrp) ! 3252: cur_cgrp--; ! 3253: error++; ! 3254: return; ! 3255: } ! 3256: printcg(cg); ! 3257: if (tcount) ! 3258: printf("\n"); ! 3259: } ! 3260: cur_cgrp--; ! 3261: if (end) { ! 3262: printf("end of cylinder groups\n"); ! 3263: error++; ! 3264: } ! 3265: return; ! 3266: ! 3267: case 'd': /* print as directories */ ! 3268: if ((cptr = getblk(addr)) == 0) ! 3269: return; ! 3270: if (type == NUMB) { ! 3271: if (fragoff(fs, addr)) { ! 3272: printf("address must be at the "); ! 3273: printf("beginning of a fragment\n"); ! 3274: error++; ! 3275: return; ! 3276: } ! 3277: bod_addr = addr; ! 3278: type = FRAGMENT; ! 3279: dirslot = 0; ! 3280: cur_bytes = 0; ! 3281: blocksize = FRGSIZE; ! 3282: filesize = FRGSIZE * 2; ! 3283: } ! 3284: cptr += offset; ! 3285: objsz = DIRECTORY; ! 3286: while (tcount-- && cur_bytes < filesize && ! 3287: cur_bytes < blocksize && !bcomp(addr)) { ! 3288: dirp = (struct direct *)cptr; ! 3289: tinode = dirp->d_ino; ! 3290: printf("i#: "); ! 3291: if (tinode == 0) ! 3292: printf("free\t"); ! 3293: else ! 3294: print(tinode, 12, -8, 0); ! 3295: printf("%s\n",&dirp->d_name[0]); ! 3296: erraddr = addr; ! 3297: errcur_bytes = cur_bytes; ! 3298: addr += dirp->d_reclen; ! 3299: cptr += dirp->d_reclen; ! 3300: cur_bytes += dirp->d_reclen; ! 3301: dirslot++; ! 3302: } ! 3303: addr = erraddr; ! 3304: cur_dir = addr; ! 3305: cur_bytes = errcur_bytes; ! 3306: stringsize = STRINGSIZE(dirp); ! 3307: dirslot--; ! 3308: if (tcount >= 0 && !star) { ! 3309: switch (type) { ! 3310: case FRAGMENT: ! 3311: printf("end of fragment\n"); ! 3312: break; ! 3313: case BLOCK: ! 3314: printf("end of block\n"); ! 3315: break; ! 3316: default: ! 3317: printf("end of directory\n"); ! 3318: } ! 3319: error++; ! 3320: } else ! 3321: error = 0; ! 3322: return; ! 3323: ! 3324: case 'i': /* print as inodes */ ! 3325: if ((ip = (struct dinode *)getblk(addr)) == 0) ! 3326: return; ! 3327: for (i=1; i < fs->fs_ncg; i++) ! 3328: if (addr < (cgimin(fs,i) << FRGSHIFT)) ! 3329: break; ! 3330: i--; ! 3331: offset /= INODE; ! 3332: temp = (addr - (cgimin(fs,i) << FRGSHIFT)) >> FRGSHIFT; ! 3333: temp = (i * fs->fs_ipg) + fragstoblks(fs,temp) * ! 3334: INOPB(fs) + offset; ! 3335: if (count + offset > INOPB(fs)) { ! 3336: tcount = INOPB(fs) - offset; ! 3337: if (!star) ! 3338: end++; ! 3339: } ! 3340: objsz = INODE; ! 3341: ip += offset; ! 3342: for (i=0; tcount--; ip++, temp++) { ! 3343: if ((mode = icheck(addr)) == 0) ! 3344: if (!override) ! 3345: continue; ! 3346: p = " ugtrwxrwxrwx"; ! 3347: ! 3348: switch (mode & IFMT) { ! 3349: case IFDIR: ! 3350: c = 'd'; ! 3351: break; ! 3352: case IFCHR: ! 3353: c = 'c'; ! 3354: break; ! 3355: case IFBLK: ! 3356: c = 'b'; ! 3357: break; ! 3358: case IFREG: ! 3359: c = '-'; ! 3360: break; ! 3361: case IFLNK: ! 3362: c = 'l'; ! 3363: break; ! 3364: case IFSOCK: ! 3365: c = 's'; ! 3366: break; ! 3367: default: ! 3368: c = '?'; ! 3369: if (!override) ! 3370: goto empty; ! 3371: ! 3372: } ! 3373: printf("i#: "); ! 3374: print(temp,12,-8,0); ! 3375: printf(" md: "); ! 3376: printf("%c", c); ! 3377: for (mode = mode << 4; *++p; mode = mode << 1) { ! 3378: if (mode & IFREG) ! 3379: printf("%c", *p); ! 3380: else ! 3381: printf("-"); ! 3382: } ! 3383: printf(" uid: "); ! 3384: print(ip->di_uid,8,-4,0); ! 3385: printf(" gid: "); ! 3386: print(ip->di_gid,8,-4,0); ! 3387: printf("\n"); ! 3388: printf("ln: "); ! 3389: print(ip->di_nlink,8,-4,0); ! 3390: printf(" bs: "); ! 3391: print(ip->di_blocks,12,-8,0); ! 3392: printf(" sz : "); ! 3393: print(ip->di_size,12,-8,0); ! 3394: printf("\n"); ! 3395: if (ip->di_mode & IFCHR) { ! 3396: printf("maj: "); ! 3397: print(ip->di_db[1] & 0377,4,-2,0); ! 3398: printf(" min: "); ! 3399: print(ip->di_db[0] & 0377,4,-2,0); ! 3400: printf("\n"); ! 3401: } else { ! 3402: for (i = 0; i < NDADDR; ) { ! 3403: if (ip->di_db[i] == 0) ! 3404: break; ! 3405: printf("db#%x: ",i); ! 3406: print(ip->di_db[i],11,-8,0); ! 3407: if (++i % 4 == 0) ! 3408: printf("\n"); ! 3409: else ! 3410: printf(" "); ! 3411: } ! 3412: if (i % 4) ! 3413: printf("\n"); ! 3414: for (i = 0; i < NIADDR; i++) { ! 3415: if (ip->di_ib[i] == 0) ! 3416: break; ! 3417: printf("ib#%x: ",i); ! 3418: print(ip->di_ib[i],11,-8,0); ! 3419: printf(" "); ! 3420: } ! 3421: if (i) ! 3422: printf("\n"); ! 3423: } ! 3424: if (count == 1) { ! 3425: printf("\taccessed: %s", ! 3426: ctime(&ip->di_atime)); ! 3427: printf("\tmodified: %s", ! 3428: ctime(&ip->di_mtime)); ! 3429: printf("\tcreated : %s", ! 3430: ctime(&ip->di_ctime)); ! 3431: } ! 3432: if (tcount) ! 3433: printf("\n"); ! 3434: empty: ! 3435: if (c == '?' && !override) { ! 3436: printf("i#: "); ! 3437: print(temp, 12, -8, 0); ! 3438: printf(" is unallocated\n"); ! 3439: if (count != 1) ! 3440: printf("\n"); ! 3441: } ! 3442: cur_ino = erraddr = addr; ! 3443: errcur_bytes = cur_bytes; ! 3444: cur_inum++; ! 3445: addr = addr + INODE; ! 3446: } ! 3447: addr = erraddr; ! 3448: cur_bytes = errcur_bytes; ! 3449: cur_inum--; ! 3450: if (end) { ! 3451: printf("end of block\n"); ! 3452: error++; ! 3453: } ! 3454: return; ! 3455: ! 3456: case 's': /* print as super block */ ! 3457: if (cur_cgrp == -1) { ! 3458: addr = SBLOCK * DEV_BSIZE; ! 3459: type = NUMB; ! 3460: } ! 3461: addr &= ~(LONG - 1); ! 3462: if (type != NUMB) ! 3463: if (cur_cgrp + count > fs->fs_ncg) { ! 3464: tcount = fs->fs_ncg - cur_cgrp; ! 3465: if (!star) ! 3466: end++; ! 3467: } ! 3468: for (; tcount--;) { ! 3469: erraddr = addr; ! 3470: cur_bytes = errcur_bytes; ! 3471: if (type != NUMB) { ! 3472: addr = cgsblock(fs, cur_cgrp) ! 3473: << FRGSHIFT; ! 3474: cur_cgrp++; ! 3475: } ! 3476: if ((cptr = getblk(addr)) == 0) { ! 3477: if (cur_cgrp) ! 3478: cur_cgrp--; ! 3479: return; ! 3480: } ! 3481: cptr += blkoff(fs, addr); ! 3482: sb = (struct fs *)cptr; ! 3483: if (type == NUMB) { ! 3484: for (i = 0; i < fs->fs_ncg; i++) ! 3485: if (addr == cgsblock(fs, i) << ! 3486: FRGSHIFT) ! 3487: break; ! 3488: if (i == fs->fs_ncg) ! 3489: cur_cgrp = 0; ! 3490: else ! 3491: cur_cgrp = i + 1; ! 3492: type = objsz = SB; ! 3493: if (cur_cgrp + count - 1 > fs->fs_ncg) { ! 3494: tcount = fs->fs_ncg - cur_cgrp; ! 3495: if (!star) ! 3496: end++; ! 3497: } ! 3498: } ! 3499: if (sb->fs_magic != FS_MAGIC) { ! 3500: cur_cgrp = 0; ! 3501: if (!override) { ! 3502: printf("invalid super block "); ! 3503: printf("magic word\n"); ! 3504: cur_cgrp--; ! 3505: error++; ! 3506: return; ! 3507: } ! 3508: } ! 3509: if (cur_cgrp == 0) ! 3510: printf("\tsuper block:\n"); ! 3511: else { ! 3512: printf("\tsuper block in cylinder "); ! 3513: printf("group "); ! 3514: print(cur_cgrp - 1, 0, 0, 0); ! 3515: printf(":\n"); ! 3516: } ! 3517: printsb(sb); ! 3518: if (tcount) ! 3519: printf("\n"); ! 3520: } ! 3521: cur_cgrp--; ! 3522: if (end) { ! 3523: printf("end of super blocks\n"); ! 3524: error++; ! 3525: } ! 3526: return; ! 3527: default: ! 3528: error++; ! 3529: printf("no such print option\n"); ! 3530: return; ! 3531: } ! 3532: } ! 3533: ! 3534: /* ! 3535: * valid_addr - call check_addr to validate the current address. ! 3536: */ ! 3537: valid_addr() ! 3538: { ! 3539: short eof_flag, end = 0, eof = 0; ! 3540: long tcount = count; ! 3541: ! 3542: if (!trapped) ! 3543: return(1); ! 3544: if (cur_bytes < 0) { ! 3545: cur_bytes = 0; ! 3546: if (blocksize > filesize) { ! 3547: printf("beginning of file\n"); ! 3548: } else { ! 3549: if (type == BLOCK) ! 3550: printf("beginning of block\n"); ! 3551: else ! 3552: printf("beginning of fragment\n"); ! 3553: } ! 3554: error++; ! 3555: return(0); ! 3556: } ! 3557: count = 1; ! 3558: check_addr(1, &end, &eof, (filesize < blocksize)); ! 3559: count = tcount; ! 3560: if (eof) { ! 3561: printf("end of file\n"); ! 3562: error++; ! 3563: return(0); ! 3564: } ! 3565: if (end == 2) { ! 3566: if (erraddr > addr) { ! 3567: if (type == BLOCK) ! 3568: printf("beginning of block\n"); ! 3569: else ! 3570: printf("beginning of fragment\n"); ! 3571: error++; ! 3572: return(0); ! 3573: } ! 3574: } ! 3575: if (end) { ! 3576: if (type == BLOCK) ! 3577: printf("end of block\n"); ! 3578: else ! 3579: printf("end of fragment\n"); ! 3580: error++; ! 3581: return(0); ! 3582: } ! 3583: return(1); ! 3584: } ! 3585: ! 3586: /* ! 3587: * check_addr - check if the address crosses the end of block or ! 3588: * end of file. Return the proper count. ! 3589: */ ! 3590: check_addr(eof_flag, end, eof, keep_on) ! 3591: short eof_flag, *end, *eof, keep_on; ! 3592: { ! 3593: long temp, tcount = count, taddr = addr, tcur_bytes = cur_bytes; ! 3594: ! 3595: if (bcomp(addr + count * objsz - 1) || ! 3596: (keep_on && taddr < (bmap(cur_block) << FRGSHIFT))) { ! 3597: error = 0; ! 3598: addr = taddr; ! 3599: cur_bytes = tcur_bytes; ! 3600: if (keep_on) { ! 3601: if (addr < erraddr) { ! 3602: if (cur_bytes < 0) { ! 3603: (*end) = 2; ! 3604: return; ! 3605: } ! 3606: temp = cur_block - lblkno(fs, cur_bytes); ! 3607: cur_block -= temp; ! 3608: if ((addr = bmap(cur_block) << FRGSHIFT) == 0) { ! 3609: cur_block += temp; ! 3610: return; ! 3611: } ! 3612: temp = tcur_bytes - cur_bytes; ! 3613: addr += temp; ! 3614: cur_bytes += temp; ! 3615: return; ! 3616: } else { ! 3617: if (cur_bytes >= filesize) { ! 3618: (*eof)++; ! 3619: return; ! 3620: } ! 3621: temp = lblkno(fs, cur_bytes) - cur_block; ! 3622: cur_block += temp; ! 3623: if ((addr = bmap(cur_block) << FRGSHIFT) == 0) { ! 3624: cur_block -= temp; ! 3625: return; ! 3626: } ! 3627: temp = tcur_bytes - cur_bytes; ! 3628: addr += temp; ! 3629: cur_bytes += temp; ! 3630: return; ! 3631: } ! 3632: } ! 3633: tcount = (blkroundup(fs, addr+1)-addr) / objsz; ! 3634: if (!star) ! 3635: (*end) = 2; ! 3636: } ! 3637: addr = taddr; ! 3638: cur_bytes = tcur_bytes; ! 3639: if (eof_flag) { ! 3640: if (blocksize > filesize) { ! 3641: if (cur_bytes >= filesize) { ! 3642: tcount = 0; ! 3643: (*eof)++; ! 3644: } else if (tcount > (filesize - cur_bytes) / objsz) { ! 3645: tcount = (filesize - cur_bytes) / objsz; ! 3646: if (!star || tcount == 0) ! 3647: (*eof)++; ! 3648: } ! 3649: } else { ! 3650: if (cur_bytes >= blocksize) { ! 3651: tcount = 0; ! 3652: (*end)++; ! 3653: } else if (tcount > (blocksize - cur_bytes) / objsz) { ! 3654: tcount = (blocksize - cur_bytes) / objsz; ! 3655: if (!star || tcount == 0) ! 3656: (*end)++; ! 3657: } ! 3658: } ! 3659: } ! 3660: return(tcount); ! 3661: } ! 3662: ! 3663: /* ! 3664: * print_check - check if the index needs to be printed and delete ! 3665: * rows of zeros from the output. ! 3666: */ ! 3667: unsigned long * ! 3668: print_check(lptr, tcount, tbase, i) ! 3669: unsigned long *lptr; ! 3670: long *tcount; ! 3671: short tbase; ! 3672: register int i; ! 3673: { ! 3674: register int j, k, temp = BYTESPERLINE / objsz; ! 3675: short first_time = 0; ! 3676: unsigned long *tlptr; ! 3677: unsigned short *tsptr, *sptr; ! 3678: ! 3679: sptr = (unsigned short *)lptr; ! 3680: if (i == 0) ! 3681: first_time = 1; ! 3682: if (i % temp == 0) { ! 3683: if (*tcount >= temp - 1) { ! 3684: if (objsz == SHORT) ! 3685: tsptr = sptr; ! 3686: else ! 3687: tlptr = lptr; ! 3688: k = *tcount - 1; ! 3689: for (j = i; k--; j++) ! 3690: if (objsz == SHORT) { ! 3691: if (*tsptr++ != 0) ! 3692: break; ! 3693: } else { ! 3694: if (*tlptr++ != 0) ! 3695: break; ! 3696: } ! 3697: if (j > (i + temp - 1)) { ! 3698: j = (j - i) / temp; ! 3699: while (j-- > 0) { ! 3700: if (objsz == SHORT) ! 3701: sptr += temp; ! 3702: else ! 3703: lptr += temp; ! 3704: *tcount -= temp; ! 3705: i += temp; ! 3706: addr += BYTESPERLINE; ! 3707: cur_bytes += BYTESPERLINE; ! 3708: } ! 3709: if (first_time) ! 3710: printf("*"); ! 3711: else ! 3712: printf("\n*"); ! 3713: } ! 3714: if (i) ! 3715: printf("\n"); ! 3716: index(tbase); ! 3717: } else { ! 3718: if (i) ! 3719: printf("\n"); ! 3720: index(tbase); ! 3721: } ! 3722: } ! 3723: if(objsz == SHORT) ! 3724: return((unsigned long *)sptr); ! 3725: else ! 3726: return(lptr); ! 3727: } ! 3728: ! 3729: /* ! 3730: * index - print a byte index for the printout in base b ! 3731: * with leading zeros. ! 3732: */ ! 3733: index(b) ! 3734: int b; ! 3735: { ! 3736: int tbase = base; ! 3737: ! 3738: base = b; ! 3739: print(addr, 8, 8, 1); ! 3740: printf(":\t"); ! 3741: base = tbase; ! 3742: } ! 3743: ! 3744: /* ! 3745: * print - print out the value to digits places with/without ! 3746: * leading zeros and right/left justified in the current base. ! 3747: */ ! 3748: print(value, fieldsz, digits, lead) ! 3749: int value, fieldsz, digits, lead; ! 3750: { ! 3751: register int i, left = 0; ! 3752: char mode = BASE[base - OCTAL]; ! 3753: char *string = &scratch[0]; ! 3754: ! 3755: if (digits < 0) { ! 3756: left = 1; ! 3757: digits *= -1; ! 3758: } ! 3759: if (base != HEX) ! 3760: if (digits) ! 3761: digits = digits + (digits - 1)/((base >> 1) - 1) + 1; ! 3762: else ! 3763: digits = 1; ! 3764: if (lead) { ! 3765: if (left) ! 3766: sprintf(string, "%%%c%d%d.%d%c", ! 3767: '-', 0, digits, lead, mode); ! 3768: else ! 3769: sprintf(string, "%%%d%d.%d%c", 0, digits, lead, mode); ! 3770: } else { ! 3771: if (left) ! 3772: sprintf(string, "%%%c%d%c", '-', digits, mode); ! 3773: else ! 3774: sprintf(string, "%%%d%c", digits, mode); ! 3775: } ! 3776: printf(string, value); ! 3777: for (i = 0; i < fieldsz - digits; i++) ! 3778: printf(" "); ! 3779: } ! 3780: ! 3781: /* ! 3782: * Print out the contents of a superblock. ! 3783: */ ! 3784: printsb(fs) ! 3785: struct fs *fs; ! 3786: { ! 3787: int c, i, j, k, size; ! 3788: ! 3789: if (fs->fs_postblformat == FS_42POSTBLFMT) ! 3790: fs->fs_nrpos = 8; ! 3791: printf("magic\t%x\tformat\t%s\ttime\t%s", fs->fs_magic, ! 3792: fs->fs_postblformat == FS_42POSTBLFMT ? "static" : "dynamic", ! 3793: ctime(&fs->fs_time)); ! 3794: printf("nbfree\t%d\tndir\t%d\tnifree\t%d\tnffree\t%d\n", ! 3795: fs->fs_cstotal.cs_nbfree, fs->fs_cstotal.cs_ndir, ! 3796: fs->fs_cstotal.cs_nifree, fs->fs_cstotal.cs_nffree); ! 3797: printf("ncg\t%d\tncyl\t%d\tsize\t%d\tblocks\t%d\n", ! 3798: fs->fs_ncg, fs->fs_ncyl, fs->fs_size, fs->fs_dsize); ! 3799: printf("bsize\t%d\tshift\t%d\tmask\t0x%08x\n", ! 3800: fs->fs_bsize, fs->fs_bshift, fs->fs_bmask); ! 3801: printf("fsize\t%d\tshift\t%d\tmask\t0x%08x\n", ! 3802: fs->fs_fsize, fs->fs_fshift, fs->fs_fmask); ! 3803: printf("frag\t%d\tshift\t%d\tfsbtodb\t%d\n", ! 3804: fs->fs_frag, fs->fs_fragshift, fs->fs_fsbtodb); ! 3805: printf("cpg\t%d\tbpg\t%d\tfpg\t%d\tipg\t%d\n", ! 3806: fs->fs_cpg, fs->fs_fpg / fs->fs_frag, fs->fs_fpg, fs->fs_ipg); ! 3807: printf("minfree\t%d%%\toptim\t%s\tmaxcontig %d\tmaxbpg\t%d\n", ! 3808: fs->fs_minfree, fs->fs_optim == FS_OPTSPACE ? "space" : "time", ! 3809: fs->fs_maxcontig, fs->fs_maxbpg); ! 3810: printf("rotdelay %dms\theadswitch %dus\ttrackseek %dus\trps\t%d\n", ! 3811: fs->fs_rotdelay, fs->fs_headswitch, fs->fs_trkseek, fs->fs_rps); ! 3812: printf("ntrak\t%d\tnsect\t%d\tnpsect\t%d\tspc\t%d\n", ! 3813: fs->fs_ntrak, fs->fs_nsect, fs->fs_npsect, fs->fs_spc); ! 3814: printf("trackskew %d\tinterleave %d\n", ! 3815: fs->fs_trackskew, fs->fs_interleave); ! 3816: printf("nindir\t%d\tinopb\t%d\tnspf\t%d\n", ! 3817: fs->fs_nindir, fs->fs_inopb, fs->fs_nspf); ! 3818: printf("sblkno\t%d\tcblkno\t%d\tiblkno\t%d\tdblkno\t%d\n", ! 3819: fs->fs_sblkno, fs->fs_cblkno, fs->fs_iblkno, fs->fs_dblkno); ! 3820: printf("sbsize\t%d\tcgsize\t%d\tcgoffset %d\tcgmask\t0x%08x\n", ! 3821: fs->fs_sbsize, fs->fs_cgsize, fs->fs_cgoffset, fs->fs_cgmask); ! 3822: printf("csaddr\t%d\tcssize\t%d\tshift\t%d\tmask\t0x%08x\n", ! 3823: fs->fs_csaddr, fs->fs_cssize, fs->fs_csshift, fs->fs_csmask); ! 3824: printf("cgrotor\t%d\tfmod\t%d\tronly\t%d\n", ! 3825: fs->fs_cgrotor, fs->fs_fmod, fs->fs_ronly); ! 3826: if (fs->fs_cpc != 0) ! 3827: printf("blocks available in each of %d rotational positions", ! 3828: fs->fs_nrpos); ! 3829: else ! 3830: printf("insufficient space to maintain rotational tables\n"); ! 3831: for (c = 0; c < fs->fs_cpc; c++) { ! 3832: printf("\ncylinder number %d:", c); ! 3833: for (i = 0; i < fs->fs_nrpos; i++) { ! 3834: if (fs_postbl(fs, c)[i] == -1) ! 3835: continue; ! 3836: printf("\n position %d:\t", i); ! 3837: for (j = fs_postbl(fs, c)[i], k = 1; ; ! 3838: j += fs_rotbl(fs)[j], k++) { ! 3839: printf("%5d", j); ! 3840: if (k % 12 == 0) ! 3841: printf("\n\t\t"); ! 3842: if (fs_rotbl(fs)[j] == 0) ! 3843: break; ! 3844: } ! 3845: } ! 3846: } ! 3847: printf("\ncs[].cs_(nbfree,ndir,nifree,nffree):\n\t"); ! 3848: for (i = 0, j = 0; i < fs->fs_cssize; i += fs->fs_bsize, j++) { ! 3849: size = fs->fs_cssize - i < fs->fs_bsize ? ! 3850: fs->fs_cssize - i : fs->fs_bsize; ! 3851: fs->fs_csp[j] = (struct csum *)calloc(1, size); ! 3852: lseek(fd, fsbtodb(fs, (fs->fs_csaddr + j * fs->fs_frag)) * ! 3853: fs->fs_fsize / fsbtodb(fs, 1), 0); ! 3854: if (read(fd, fs->fs_csp[j], size) != size) { ! 3855: for (j--; j >= 0; j--) ! 3856: free(fs->fs_csp[j]); ! 3857: return; ! 3858: } ! 3859: } ! 3860: for (i = 0; i < fs->fs_ncg; i++) { ! 3861: struct csum *cs = &fs->fs_cs(fs, i); ! 3862: if (i && i % 4 == 0) ! 3863: printf("\n\t"); ! 3864: printf("(%d,%d,%d,%d) ", ! 3865: cs->cs_nbfree, cs->cs_ndir, cs->cs_nifree, cs->cs_nffree); ! 3866: } ! 3867: for (j--; j >= 0; j--) ! 3868: free(fs->fs_csp[j]); ! 3869: printf("\n"); ! 3870: if (fs->fs_ncyl % fs->fs_cpg) { ! 3871: printf("cylinders in last group %d\n", ! 3872: i = fs->fs_ncyl % fs->fs_cpg); ! 3873: printf("blocks in last group %d\n", ! 3874: i * fs->fs_spc / NSPB(fs)); ! 3875: } ! 3876: } ! 3877: ! 3878: /* ! 3879: * Print out the contents of a cylinder group. ! 3880: */ ! 3881: printcg(cg) ! 3882: struct cg *cg; ! 3883: { ! 3884: int i,j; ! 3885: ! 3886: printf("\ncg %d:\n", cg->cg_cgx); ! 3887: printf("magic\t%x\ttell\t%x\ttime\t%s", ! 3888: fs->fs_postblformat == FS_42POSTBLFMT ? ! 3889: ((struct ocg *)cg)->cg_magic : cg->cg_magic, ! 3890: fsbtodb(fs, cgtod(fs, cg->cg_cgx)) * fs->fs_fsize / fsbtodb(fs, 1), ! 3891: ctime(&cg->cg_time)); ! 3892: printf("cgx\t%d\tncyl\t%d\tniblk\t%d\tndblk\t%d\n", ! 3893: cg->cg_cgx, cg->cg_ncyl, cg->cg_niblk, cg->cg_ndblk); ! 3894: printf("nbfree\t%d\tndir\t%d\tnifree\t%d\tnffree\t%d\n", ! 3895: cg->cg_cs.cs_nbfree, cg->cg_cs.cs_ndir, ! 3896: cg->cg_cs.cs_nifree, cg->cg_cs.cs_nffree); ! 3897: printf("rotor\t%d\tirotor\t%d\tfrotor\t%d\nfrsum", ! 3898: cg->cg_rotor, cg->cg_irotor, cg->cg_frotor); ! 3899: for (i = 1, j = 0; i < fs->fs_frag; i++) { ! 3900: printf("\t%d", cg->cg_frsum[i]); ! 3901: j += i * cg->cg_frsum[i]; ! 3902: } ! 3903: printf("\nsum of frsum: %d\niused:\t", j); ! 3904: pbits(cg_inosused(cg), fs->fs_ipg); ! 3905: printf("free:\t"); ! 3906: pbits(cg_blksfree(cg), fs->fs_fpg); ! 3907: printf("b:\n"); ! 3908: for (i = 0; i < fs->fs_cpg; i++) { ! 3909: if (cg_blktot(cg)[i] == 0) ! 3910: continue; ! 3911: printf(" c%d:\t(%d)\t", i, cg_blktot(cg)[i]); ! 3912: for (j = 0; j < fs->fs_nrpos; j++) { ! 3913: if (fs->fs_cpc == 0 || ! 3914: fs_postbl(fs, i % fs->fs_cpc)[j] == -1) ! 3915: continue; ! 3916: printf(" %d", cg_blks(fs, cg, i)[j]); ! 3917: } ! 3918: printf("\n"); ! 3919: } ! 3920: } ! 3921: ! 3922: /* ! 3923: * Print out the contents of a bit array. ! 3924: */ ! 3925: pbits(cp, max) ! 3926: register char *cp; ! 3927: int max; ! 3928: { ! 3929: register int i; ! 3930: int count = 0, j; ! 3931: ! 3932: for (i = 0; i < max; i++) ! 3933: if (isset(cp, i)) { ! 3934: if (count) ! 3935: printf(",%s", count % 6 ? " " : "\n\t"); ! 3936: count++; ! 3937: printf("%d", i); ! 3938: j = i; ! 3939: while ((i+1)<max && isset(cp, i+1)) ! 3940: i++; ! 3941: if (i != j) ! 3942: printf("-%d", i); ! 3943: } ! 3944: printf("\n"); ! 3945: } ! 3946: ! 3947: /* ! 3948: * bcomp - used to check for block over/under flows when stepping through ! 3949: * a file system. ! 3950: */ ! 3951: bcomp(addr) ! 3952: long addr; ! 3953: { ! 3954: if (override) ! 3955: return(0); ! 3956: if (lblkno(fs, addr) == (bhdr.fwd)->blkno) ! 3957: return(0); ! 3958: error++; ! 3959: return(1); ! 3960: } ! 3961: ! 3962: /* ! 3963: * bmap - maps the logical block number of a file into ! 3964: * the corresponding physical block on the file ! 3965: * system. ! 3966: */ ! 3967: long ! 3968: bmap(bn) ! 3969: long bn; ! 3970: { ! 3971: register int i, j; ! 3972: register struct dinode *ip; ! 3973: int sh; ! 3974: long nb; ! 3975: ! 3976: ip = (struct dinode *)cur_ino; ! 3977: if (bn < NDADDR) { ! 3978: addr = (long)&ip->di_db[bn]; ! 3979: cur_bytes = bn * BLKSIZE; ! 3980: return(nullblk(nb=get(LONG)) ? 0L : nb); ! 3981: } ! 3982: ! 3983: sh = 1; ! 3984: bn -= NDADDR; ! 3985: for (j = NIADDR; j > 0; j--) { ! 3986: sh *= NINDIR(fs); ! 3987: if (bn < sh) ! 3988: break; ! 3989: bn -= sh; ! 3990: } ! 3991: if (j == 0) { ! 3992: printf("file too big\n"); ! 3993: error++; ! 3994: return(0L); ! 3995: } ! 3996: addr = (long)&ip->di_ib[NIADDR - j]; ! 3997: nb = get(LONG); ! 3998: if (nb == 0) ! 3999: return(0L); ! 4000: for (; j <= NIADDR; j++) { ! 4001: sh /= NINDIR(fs); ! 4002: addr = (nb << FRGSHIFT) + ((bn / sh) % NINDIR(fs)) * LONG; ! 4003: if (nullblk(nb = get(LONG))) ! 4004: return(0L); ! 4005: } ! 4006: return(nb); ! 4007: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.