![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to restor.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / sys / stand|
Return to restor.c CVS log | Up to [CSRG BSD Unix] / 3BSD / sys / stand |
1.1 ! root 1: #define MAXINO 3000 ! 2: #define BITS 8 ! 3: #define MAXXTR 60 ! 4: #define NCACHE 3 ! 5: ! 6: #ifndef STANDALONE ! 7: #include <stdio.h> ! 8: #include <signal.h> ! 9: #endif ! 10: #include <sys/param.h> ! 11: #include <sys/inode.h> ! 12: #include <sys/ino.h> ! 13: #include <sys/fblk.h> ! 14: #include <sys/filsys.h> ! 15: #include <sys/dir.h> ! 16: #include <dumprestor.h> ! 17: ! 18: #define MWORD(m,i) (m[(unsigned)(i-1)/MLEN]) ! 19: #define MBIT(i) (1<<((unsigned)(i-1)%MLEN)) ! 20: #define BIS(i,w) (MWORD(w,i) |= MBIT(i)) ! 21: #define BIC(i,w) (MWORD(w,i) &= ~MBIT(i)) ! 22: #define BIT(i,w) (MWORD(w,i) & MBIT(i)) ! 23: ! 24: struct filsys sblock; ! 25: ! 26: int fi; ! 27: ino_t ino, maxi, curino; ! 28: ! 29: int mt; ! 30: char tapename[] = "/dev/rmt1"; ! 31: char *magtape = tapename; ! 32: #ifdef STANDALONE ! 33: char mbuf[50]; ! 34: #endif ! 35: ! 36: #ifndef STANDALONE ! 37: daddr_t seekpt; ! 38: int df, ofile; ! 39: char dirfile[] = "rstXXXXXX"; ! 40: ! 41: struct { ! 42: ino_t t_ino; ! 43: daddr_t t_seekpt; ! 44: } inotab[MAXINO]; ! 45: int ipos; ! 46: ! 47: #define ONTAPE 1 ! 48: #define XTRACTD 2 ! 49: #define XINUSE 4 ! 50: struct xtrlist { ! 51: ino_t x_ino; ! 52: char x_flags; ! 53: } xtrlist[MAXXTR]; ! 54: ! 55: char name[12]; ! 56: ! 57: char drblock[BSIZE]; ! 58: int bpt; ! 59: #endif ! 60: ! 61: int eflag; ! 62: ! 63: int volno = 1; ! 64: ! 65: struct dinode tino, dino; ! 66: daddr_t taddr[NADDR]; ! 67: ! 68: daddr_t curbno; ! 69: ! 70: short dumpmap[MSIZ]; ! 71: short clrimap[MSIZ]; ! 72: ! 73: ! 74: int bct = NTREC+1; ! 75: char tbf[NTREC*BSIZE]; ! 76: ! 77: struct cache { ! 78: daddr_t c_bno; ! 79: int c_time; ! 80: char c_block[BSIZE]; ! 81: } cache[NCACHE]; ! 82: int curcache; ! 83: ! 84: main(argc, argv) ! 85: char *argv[]; ! 86: { ! 87: register char *cp; ! 88: char command; ! 89: int done(); ! 90: ! 91: #ifndef STANDALONE ! 92: mktemp(dirfile); ! 93: if (argc < 2) { ! 94: usage: ! 95: printf("Usage: restor x file file..., restor r filesys, or restor t\n"); ! 96: exit(1); ! 97: } ! 98: argv++; ! 99: argc -= 2; ! 100: for (cp = *argv++; *cp; cp++) { ! 101: switch (*cp) { ! 102: case '-': ! 103: break; ! 104: case 'f': ! 105: magtape = *argv++; ! 106: argc--; ! 107: break; ! 108: case 'r': ! 109: case 'R': ! 110: case 't': ! 111: case 'x': ! 112: command = *cp; ! 113: break; ! 114: default: ! 115: printf("Bad key character %c\n", *cp); ! 116: goto usage; ! 117: } ! 118: } ! 119: if (command == 'x') { ! 120: if (signal(SIGINT, done) == SIG_IGN) ! 121: signal(SIGINT, SIG_IGN); ! 122: if (signal(SIGTERM, done) == SIG_IGN) ! 123: signal(SIGTERM, SIG_IGN); ! 124: ! 125: df = creat(dirfile, 0666); ! 126: if (df < 0) { ! 127: printf("restor: %s - cannot create directory temporary\n", dirfile); ! 128: exit(1); ! 129: } ! 130: close(df); ! 131: df = open(dirfile, 2); ! 132: } ! 133: doit(command, argc, argv); ! 134: if (command == 'x') ! 135: unlink(dirfile); ! 136: exit(0); ! 137: #else ! 138: magtape = "tape"; ! 139: doit('r', 1, 0); ! 140: #endif ! 141: } ! 142: ! 143: doit(command, argc, argv) ! 144: char command; ! 145: int argc; ! 146: char *argv[]; ! 147: { ! 148: extern char *ctime(); ! 149: register i, k; ! 150: ino_t d; ! 151: #ifndef STANDALONE ! 152: int xtrfile(), skip(); ! 153: #endif ! 154: int rstrfile(), rstrskip(); ! 155: struct dinode *ip, *ip1; ! 156: ! 157: #ifndef STANDALONE ! 158: if ((mt = open(magtape, 0)) < 0) { ! 159: printf("%s: cannot open tape\n", magtape); ! 160: exit(1); ! 161: } ! 162: #else ! 163: do { ! 164: printf("Tape? "); ! 165: gets(mbuf); ! 166: mt = open(mbuf, 0); ! 167: } while (mt == -1); ! 168: magtape = mbuf; ! 169: #endif ! 170: switch(command) { ! 171: #ifndef STANDALONE ! 172: case 't': ! 173: if (readhdr(&spcl) == 0) { ! 174: printf("Tape is not a dump tape\n"); ! 175: exit(1); ! 176: } ! 177: printf("Dump date: %s", ctime(&spcl.c_date)); ! 178: printf("Dumped from: %s", ctime(&spcl.c_ddate)); ! 179: return; ! 180: case 'x': ! 181: if (readhdr(&spcl) == 0) { ! 182: printf("Tape is not a dump tape\n"); ! 183: exit(1); ! 184: } ! 185: if (checkvol(&spcl, 1) == 0) { ! 186: printf("Tape is not volume 1 of the dump\n"); ! 187: exit(1); ! 188: } ! 189: pass1(); /* This sets the various maps on the way by */ ! 190: i = 0; ! 191: while (i < MAXXTR-1 && argc--) { ! 192: if ((d = psearch(*argv)) == 0 || BIT(d, dumpmap) == 0) { ! 193: printf("%s: not on the tape\n", *argv++); ! 194: continue; ! 195: } ! 196: xtrlist[i].x_ino = d; ! 197: xtrlist[i].x_flags |= XINUSE; ! 198: printf("%s: inode %u\n", *argv, d); ! 199: argv++; ! 200: i++; ! 201: } ! 202: newvol: ! 203: flsht(); ! 204: close(mt); ! 205: getvol: ! 206: printf("Mount desired tape volume: Specify volume #: "); ! 207: if (gets(tbf) == NULL) ! 208: return; ! 209: volno = atoi(tbf); ! 210: if (volno <= 0) { ! 211: printf("Volume numbers are positive numerics\n"); ! 212: goto getvol; ! 213: } ! 214: mt = open(magtape, 0); ! 215: if (readhdr(&spcl) == 0) { ! 216: printf("tape is not dump tape\n"); ! 217: goto newvol; ! 218: } ! 219: if (checkvol(&spcl, volno) == 0) { ! 220: printf("Wrong volume (%d)\n", spcl.c_volume); ! 221: goto newvol; ! 222: } ! 223: rbits: ! 224: while (gethead(&spcl) == 0) ! 225: ; ! 226: if (checktype(&spcl, TS_INODE) == 1) { ! 227: printf("Can't find inode mask!\n"); ! 228: goto newvol; ! 229: } ! 230: if (checktype(&spcl, TS_BITS) == 0) ! 231: goto rbits; ! 232: readbits(dumpmap); ! 233: i = 0; ! 234: for (k = 0; xtrlist[k].x_flags; k++) { ! 235: if (BIT(xtrlist[k].x_ino, dumpmap)) { ! 236: xtrlist[k].x_flags |= ONTAPE; ! 237: i++; ! 238: } ! 239: } ! 240: while (i > 0) { ! 241: again: ! 242: if (ishead(&spcl) == 0) ! 243: while(gethead(&spcl) == 0) ! 244: ; ! 245: if (checktype(&spcl, TS_END) == 1) { ! 246: printf("end of tape\n"); ! 247: checkdone: ! 248: for (k = 0; xtrlist[k].x_flags; k++) ! 249: if ((xtrlist[k].x_flags&XTRACTD) == 0) ! 250: goto newvol; ! 251: return; ! 252: } ! 253: if (checktype(&spcl, TS_INODE) == 0) { ! 254: gethead(&spcl); ! 255: goto again; ! 256: } ! 257: d = spcl.c_inumber; ! 258: for (k = 0; xtrlist[k].x_flags; k++) { ! 259: if (d == xtrlist[k].x_ino) { ! 260: printf("extract file %u\n", xtrlist[k].x_ino); ! 261: sprintf(name, "%u", xtrlist[k].x_ino); ! 262: if ((ofile = creat(name, 0666)) < 0) { ! 263: printf("%s: cannot create file\n", name); ! 264: i--; ! 265: continue; ! 266: } ! 267: chown(name, spcl.c_dinode.di_uid, spcl.c_dinode.di_gid); ! 268: getfile(ino, xtrfile, skip, spcl.c_dinode.di_size); ! 269: i--; ! 270: xtrlist[k].x_flags |= XTRACTD; ! 271: close(ofile); ! 272: goto done; ! 273: } ! 274: } ! 275: gethead(&spcl); ! 276: done: ! 277: ; ! 278: } ! 279: goto checkdone; ! 280: #endif ! 281: case 'r': ! 282: case 'R': ! 283: #ifndef STANDALONE ! 284: if ((fi = open(*argv, 2)) < 0) { ! 285: printf("%s: cannot open\n", *argv); ! 286: exit(1); ! 287: } ! 288: #else ! 289: do { ! 290: char charbuf[50]; ! 291: ! 292: printf("Disk? "); ! 293: gets(charbuf); ! 294: fi = open(charbuf, 2); ! 295: } while (fi == -1); ! 296: #endif ! 297: #ifndef STANDALONE ! 298: if (command == 'R') { ! 299: printf("Enter starting volume number: "); ! 300: if (gets(tbf) == EOF) { ! 301: volno = 1; ! 302: printf("\n"); ! 303: } ! 304: else ! 305: volno = atoi(tbf); ! 306: } ! 307: else ! 308: #endif ! 309: volno = 1; ! 310: printf("Last chance before scribbling on %s. ", ! 311: #ifdef STANDALONE ! 312: "disk"); ! 313: #else ! 314: *argv); ! 315: #endif ! 316: while (getchar() != '\n'); ! 317: dread((daddr_t)1, (char *)&sblock, sizeof(sblock)); ! 318: maxi = (sblock.s_isize-2)*INOPB; ! 319: if (readhdr(&spcl) == 0) { ! 320: printf("Missing volume record\n"); ! 321: exit(1); ! 322: } ! 323: if (checkvol(&spcl, volno) == 0) { ! 324: printf("Tape is not volume %d\n", volno); ! 325: exit(1); ! 326: } ! 327: gethead(&spcl); ! 328: for (;;) { ! 329: ragain: ! 330: if (ishead(&spcl) == 0) { ! 331: printf("Missing header block\n"); ! 332: while (gethead(&spcl) == 0) ! 333: ; ! 334: eflag++; ! 335: } ! 336: if (checktype(&spcl, TS_END) == 1) { ! 337: printf("End of tape\n"); ! 338: close(mt); ! 339: dwrite( (daddr_t) 1, (char *) &sblock); ! 340: return; ! 341: } ! 342: if (checktype(&spcl, TS_CLRI) == 1) { ! 343: readbits(clrimap); ! 344: for (ino = 1; ino <= maxi; ino++) ! 345: if (BIT(ino, clrimap) == 0) { ! 346: getdino(ino, &tino); ! 347: if (tino.di_mode == 0) ! 348: continue; ! 349: itrunc(&tino); ! 350: clri(&tino); ! 351: putdino(ino, &tino); ! 352: } ! 353: dwrite( (daddr_t) 1, (char *) &sblock); ! 354: goto ragain; ! 355: } ! 356: if (checktype(&spcl, TS_BITS) == 1) { ! 357: readbits(dumpmap); ! 358: goto ragain; ! 359: } ! 360: if (checktype(&spcl, TS_INODE) == 0) { ! 361: printf("Unknown header type\n"); ! 362: eflag++; ! 363: gethead(&spcl); ! 364: goto ragain; ! 365: } ! 366: ino = spcl.c_inumber; ! 367: if (eflag) ! 368: printf("Resynced at inode %u\n", ino); ! 369: eflag = 0; ! 370: if (ino > maxi) { ! 371: printf("%u: ilist too small\n", ino); ! 372: gethead(&spcl); ! 373: goto ragain; ! 374: } ! 375: dino = spcl.c_dinode; ! 376: getdino(ino, &tino); ! 377: curbno = 0; ! 378: itrunc(&tino); ! 379: clri(&tino); ! 380: for (i = 0; i < NADDR; i++) ! 381: taddr[i] = 0; ! 382: l3tol(taddr, dino.di_addr, 1); ! 383: getfile(d, rstrfile, rstrskip, dino.di_size); ! 384: ip = &tino; ! 385: ltol3(ip->di_addr, taddr, NADDR); ! 386: ip1 = &dino; ! 387: ip->di_mode = ip1->di_mode; ! 388: ip->di_nlink = ip1->di_nlink; ! 389: ip->di_uid = ip1->di_uid; ! 390: ip->di_gid = ip1->di_gid; ! 391: ip->di_size = ip1->di_size; ! 392: ip->di_atime = ip1->di_atime; ! 393: ip->di_mtime = ip1->di_mtime; ! 394: ip->di_ctime = ip1->di_ctime; ! 395: putdino(ino, &tino); ! 396: } ! 397: } ! 398: } ! 399: ! 400: /* ! 401: * Read the tape, bulding up a directory structure for extraction ! 402: * by name ! 403: */ ! 404: #ifndef STANDALONE ! 405: pass1() ! 406: { ! 407: register i; ! 408: struct dinode *ip; ! 409: int putdir(), null(); ! 410: ! 411: while (gethead(&spcl) == 0) { ! 412: printf("Can't find directory header!\n"); ! 413: } ! 414: for (;;) { ! 415: if (checktype(&spcl, TS_BITS) == 1) { ! 416: readbits(dumpmap); ! 417: continue; ! 418: } ! 419: if (checktype(&spcl, TS_CLRI) == 1) { ! 420: readbits(clrimap); ! 421: continue; ! 422: } ! 423: if (checktype(&spcl, TS_INODE) == 0) { ! 424: finish: ! 425: flsh(); ! 426: close(mt); ! 427: return; ! 428: } ! 429: ip = &spcl.c_dinode; ! 430: i = ip->di_mode & IFMT; ! 431: if (i != IFDIR) { ! 432: goto finish; ! 433: } ! 434: inotab[ipos].t_ino = spcl.c_inumber; ! 435: inotab[ipos++].t_seekpt = seekpt; ! 436: getfile(spcl.c_inumber, putdir, null, spcl.c_dinode.di_size); ! 437: putent("\000\000/"); ! 438: } ! 439: } ! 440: #endif ! 441: ! 442: /* ! 443: * Do the file extraction, calling the supplied functions ! 444: * with the blocks ! 445: */ ! 446: getfile(n, f1, f2, size) ! 447: ino_t n; ! 448: int (*f2)(), (*f1)(); ! 449: long size; ! 450: { ! 451: register i; ! 452: struct spcl addrblock; ! 453: char buf[BSIZE]; ! 454: ! 455: addrblock = spcl; ! 456: curino = n; ! 457: goto start; ! 458: for (;;) { ! 459: if (gethead(&addrblock) == 0) { ! 460: printf("Missing address (header) block\n"); ! 461: goto eloop; ! 462: } ! 463: if (checktype(&addrblock, TS_ADDR) == 0) { ! 464: spcl = addrblock; ! 465: curino = 0; ! 466: curino = 0; ! 467: return; ! 468: } ! 469: start: ! 470: for (i = 0; i < addrblock.c_count; i++) { ! 471: if (addrblock.c_addr[i]) { ! 472: readtape(buf); ! 473: (*f1)(buf, size > BSIZE ? (long) BSIZE : size); ! 474: } ! 475: else { ! 476: clearbuf(buf); ! 477: (*f2)(buf, size > BSIZE ? (long) BSIZE : size); ! 478: } ! 479: if ((size -= BSIZE) <= 0) { ! 480: eloop: ! 481: while (gethead(&spcl) == 0) ! 482: ; ! 483: if (checktype(&spcl, TS_ADDR) == 1) ! 484: goto eloop; ! 485: curino = 0; ! 486: return; ! 487: } ! 488: } ! 489: } ! 490: } ! 491: ! 492: /* ! 493: * Do the tape i\/o, dealling with volume changes ! 494: * etc.. ! 495: */ ! 496: readtape(b) ! 497: char *b; ! 498: { ! 499: register i; ! 500: struct spcl tmpbuf; ! 501: ! 502: if (bct >= NTREC) { ! 503: for (i = 0; i < NTREC; i++) ! 504: ((struct spcl *)&tbf[i*BSIZE])->c_magic = 0; ! 505: bct = 0; ! 506: if ((i = read(mt, tbf, NTREC*BSIZE)) < 0) { ! 507: printf("Tape read error: inode %u\n", curino); ! 508: eflag++; ! 509: exit(1); ! 510: } ! 511: if (i == 0) { ! 512: bct = NTREC + 1; ! 513: volno++; ! 514: loop: ! 515: flsht(); ! 516: close(mt); ! 517: printf("Mount volume %d\n", volno); ! 518: while (getchar() != '\n') ! 519: ; ! 520: if ((mt = open(magtape, 0)) == -1) { ! 521: printf("Cannot open tape!\n"); ! 522: goto loop; ! 523: } ! 524: if (readhdr(&tmpbuf) == 0) { ! 525: printf("Not a dump tape.Try again\n"); ! 526: goto loop; ! 527: } ! 528: if (checkvol(&tmpbuf, volno) == 0) { ! 529: printf("Wrong tape. Try again\n"); ! 530: goto loop; ! 531: } ! 532: readtape(b); ! 533: return; ! 534: } ! 535: } ! 536: copy(&tbf[(bct++*BSIZE)], b, BSIZE); ! 537: } ! 538: ! 539: flsht() ! 540: { ! 541: bct = NTREC+1; ! 542: } ! 543: ! 544: copy(f, t, s) ! 545: register char *f, *t; ! 546: { ! 547: register i; ! 548: ! 549: i = s; ! 550: do ! 551: *t++ = *f++; ! 552: while (--i); ! 553: } ! 554: ! 555: clearbuf(cp) ! 556: register char *cp; ! 557: { ! 558: register i; ! 559: ! 560: i = BSIZE; ! 561: do ! 562: *cp++ = 0; ! 563: while (--i); ! 564: } ! 565: ! 566: /* ! 567: * Put and get the directory entries from the compressed ! 568: * directory file ! 569: */ ! 570: #ifndef STANDALONE ! 571: putent(cp) ! 572: char *cp; ! 573: { ! 574: register i; ! 575: ! 576: for (i = 0; i < sizeof(ino_t); i++) ! 577: writec(*cp++); ! 578: for (i = 0; i < DIRSIZ; i++) { ! 579: writec(*cp); ! 580: if (*cp++ == 0) ! 581: return; ! 582: } ! 583: return; ! 584: } ! 585: ! 586: getent(bf) ! 587: register char *bf; ! 588: { ! 589: register i; ! 590: ! 591: for (i = 0; i < sizeof(ino_t); i++) ! 592: *bf++ = readc(); ! 593: for (i = 0; i < DIRSIZ; i++) ! 594: if ((*bf++ = readc()) == 0) ! 595: return; ! 596: return; ! 597: } ! 598: ! 599: /* ! 600: * read/write te directory file ! 601: */ ! 602: writec(c) ! 603: char c; ! 604: { ! 605: drblock[bpt++] = c; ! 606: seekpt++; ! 607: if (bpt >= BSIZE) { ! 608: bpt = 0; ! 609: write(df, drblock, BSIZE); ! 610: } ! 611: } ! 612: ! 613: readc() ! 614: { ! 615: if (bpt >= BSIZE) { ! 616: read(df, drblock, BSIZE); ! 617: bpt = 0; ! 618: } ! 619: return(drblock[bpt++]); ! 620: } ! 621: ! 622: mseek(pt) ! 623: daddr_t pt; ! 624: { ! 625: bpt = BSIZE; ! 626: lseek(df, pt, 0); ! 627: } ! 628: ! 629: flsh() ! 630: { ! 631: write(df, drblock, bpt+1); ! 632: } ! 633: ! 634: /* ! 635: * search the directory inode ino ! 636: * looking for entry cp ! 637: */ ! 638: ino_t ! 639: search(inum, cp) ! 640: ino_t inum; ! 641: char *cp; ! 642: { ! 643: register i; ! 644: struct direct dir; ! 645: ! 646: for (i = 0; i < MAXINO; i++) ! 647: if (inotab[i].t_ino == inum) { ! 648: goto found; ! 649: } ! 650: return(0); ! 651: found: ! 652: mseek(inotab[i].t_seekpt); ! 653: do { ! 654: getent((char *)&dir); ! 655: if (direq(dir.d_name, "/")) ! 656: return(0); ! 657: } while (direq(dir.d_name, cp) == 0); ! 658: return(dir.d_ino); ! 659: } ! 660: ! 661: /* ! 662: * Search the directory tree rooted at inode 2 ! 663: * for the path pointed at by n ! 664: */ ! 665: psearch(n) ! 666: char *n; ! 667: { ! 668: register char *cp, *cp1; ! 669: char c; ! 670: ! 671: ino = 2; ! 672: if (*(cp = n) == '/') ! 673: cp++; ! 674: next: ! 675: cp1 = cp + 1; ! 676: while (*cp1 != '/' && *cp1) ! 677: cp1++; ! 678: c = *cp1; ! 679: *cp1 = 0; ! 680: ino = search(ino, cp); ! 681: if (ino == 0) { ! 682: *cp1 = c; ! 683: return(0); ! 684: } ! 685: *cp1 = c; ! 686: if (c == '/') { ! 687: cp = cp1+1; ! 688: goto next; ! 689: } ! 690: return(ino); ! 691: } ! 692: ! 693: direq(s1, s2) ! 694: register char *s1, *s2; ! 695: { ! 696: register i; ! 697: ! 698: for (i = 0; i < DIRSIZ; i++) ! 699: if (*s1++ == *s2) { ! 700: if (*s2++ == 0) ! 701: return(1); ! 702: } else ! 703: return(0); ! 704: return(1); ! 705: } ! 706: #endif ! 707: ! 708: /* ! 709: * read/write a disk block, be sure to update the buffer ! 710: * cache if needed. ! 711: */ ! 712: dwrite(bno, b) ! 713: daddr_t bno; ! 714: char *b; ! 715: { ! 716: register i; ! 717: ! 718: for (i = 0; i < NCACHE; i++) { ! 719: if (cache[i].c_bno == bno) { ! 720: copy(b, cache[i].c_block, BSIZE); ! 721: cache[i].c_time = 0; ! 722: break; ! 723: } ! 724: else ! 725: cache[i].c_time++; ! 726: } ! 727: lseek(fi, bno*BSIZE, 0); ! 728: if(write(fi, b, BSIZE) != BSIZE) { ! 729: #ifdef STANDALONE ! 730: printf("disk write error %D\n", bno); ! 731: #else ! 732: fprintf(stderr, "disk write error %ld\n", bno); ! 733: #endif ! 734: exit(1); ! 735: } ! 736: } ! 737: ! 738: dread(bno, buf, cnt) ! 739: daddr_t bno; ! 740: char *buf; ! 741: { ! 742: register i, j; ! 743: ! 744: j = 0; ! 745: for (i = 0; i < NCACHE; i++) { ! 746: if (++curcache >= NCACHE) ! 747: curcache = 0; ! 748: if (cache[curcache].c_bno == bno) { ! 749: copy(cache[curcache].c_block, buf, cnt); ! 750: cache[curcache].c_time = 0; ! 751: return; ! 752: } ! 753: else { ! 754: cache[curcache].c_time++; ! 755: if (cache[j].c_time < cache[curcache].c_time) ! 756: j = curcache; ! 757: } ! 758: } ! 759: ! 760: lseek(fi, bno*BSIZE, 0); ! 761: if (read(fi, cache[j].c_block, BSIZE) != BSIZE) { ! 762: #ifdef STANDALONE ! 763: printf("read error %D\n", bno); ! 764: #else ! 765: printf("read error %ld\n", bno); ! 766: #endif ! 767: exit(1); ! 768: } ! 769: copy(cache[j].c_block, buf, cnt); ! 770: cache[j].c_time = 0; ! 771: cache[j].c_bno = bno; ! 772: } ! 773: ! 774: /* ! 775: * the inode manpulation routines. Like the system. ! 776: * ! 777: * clri zeros the inode ! 778: */ ! 779: clri(ip) ! 780: struct dinode *ip; ! 781: { ! 782: int i, *p; ! 783: i = sizeof(struct dinode)/sizeof(int); ! 784: p = (int *)ip; ! 785: do ! 786: *p++ = 0; ! 787: while(--i); ! 788: } ! 789: ! 790: /* ! 791: * itrunc/tloop/bfree free all of the blocks pointed at by the inode ! 792: */ ! 793: itrunc(ip) ! 794: register struct dinode *ip; ! 795: { ! 796: register i; ! 797: daddr_t bn, iaddr[NADDR]; ! 798: ! 799: if (ip->di_mode == 0) ! 800: return; ! 801: i = ip->di_mode & IFMT; ! 802: if (i != IFDIR && i != IFREG) ! 803: return; ! 804: l3tol(iaddr, ip->di_addr, NADDR); ! 805: for(i=NADDR-1;i>=0;i--) { ! 806: bn = iaddr[i]; ! 807: if(bn == 0) continue; ! 808: switch(i) { ! 809: ! 810: default: ! 811: bfree(bn); ! 812: break; ! 813: ! 814: case NADDR-3: ! 815: tloop(bn, 0, 0); ! 816: break; ! 817: ! 818: case NADDR-2: ! 819: tloop(bn, 1, 0); ! 820: break; ! 821: ! 822: case NADDR-1: ! 823: tloop(bn, 1, 1); ! 824: } ! 825: } ! 826: ip->di_size = 0; ! 827: } ! 828: ! 829: tloop(bn, f1, f2) ! 830: daddr_t bn; ! 831: int f1, f2; ! 832: { ! 833: register i; ! 834: daddr_t nb; ! 835: union { ! 836: char data[BSIZE]; ! 837: daddr_t indir[NINDIR]; ! 838: } ibuf; ! 839: ! 840: dread(bn, ibuf.data, BSIZE); ! 841: for(i=NINDIR-1;i>=0;i--) { ! 842: nb = ibuf.indir[i]; ! 843: if(nb) { ! 844: if(f1) ! 845: tloop(nb, f2, 0); ! 846: else ! 847: bfree(nb); ! 848: } ! 849: } ! 850: bfree(bn); ! 851: } ! 852: ! 853: bfree(bn) ! 854: daddr_t bn; ! 855: { ! 856: register i; ! 857: union { ! 858: char data[BSIZE]; ! 859: struct fblk frees; ! 860: } fbuf; ! 861: ! 862: if(sblock.s_nfree >= NICFREE) { ! 863: fbuf.df_nfree = sblock.s_nfree; ! 864: for(i=0;i<NICFREE;i++) ! 865: fbuf.df_free[i] = sblock.s_free[i]; ! 866: sblock.s_nfree = 0; ! 867: dwrite(bn, fbuf.data); ! 868: } ! 869: sblock.s_free[sblock.s_nfree++] = bn; ! 870: } ! 871: ! 872: /* ! 873: * allocate a block off the free list. ! 874: */ ! 875: daddr_t ! 876: balloc() ! 877: { ! 878: daddr_t bno; ! 879: register i; ! 880: static char zeroes[BSIZE]; ! 881: union { ! 882: char data[BSIZE]; ! 883: struct fblk frees; ! 884: } fbuf; ! 885: ! 886: if(sblock.s_nfree == 0 || (bno=sblock.s_free[--sblock.s_nfree]) == 0) { ! 887: #ifdef STANDALONE ! 888: printf("Out of space\n"); ! 889: #else ! 890: fprintf(stderr, "Out of space.\n"); ! 891: #endif ! 892: exit(1); ! 893: } ! 894: if(sblock.s_nfree == 0) { ! 895: dread(bno, fbuf.data, BSIZE); ! 896: sblock.s_nfree = fbuf.df_nfree; ! 897: for(i=0;i<NICFREE;i++) ! 898: sblock.s_free[i] = fbuf.df_free[i]; ! 899: } ! 900: dwrite(bno, zeroes); ! 901: return(bno); ! 902: } ! 903: ! 904: /* ! 905: * map a block number into a block address, ensuring ! 906: * all of the correct indirect blocks are around. Allocate ! 907: * the block requested. ! 908: */ ! 909: daddr_t ! 910: bmap(iaddr, bn) ! 911: daddr_t iaddr[NADDR]; ! 912: daddr_t bn; ! 913: { ! 914: register i; ! 915: int j, sh; ! 916: daddr_t nb, nnb; ! 917: daddr_t indir[NINDIR]; ! 918: ! 919: /* ! 920: * blocks 0..NADDR-4 are direct blocks ! 921: */ ! 922: if(bn < NADDR-3) { ! 923: iaddr[bn] = nb = balloc(); ! 924: return(nb); ! 925: } ! 926: ! 927: /* ! 928: * addresses NADDR-3, NADDR-2, and NADDR-1 ! 929: * have single, double, triple indirect blocks. ! 930: * the first step is to determine ! 931: * how many levels of indirection. ! 932: */ ! 933: sh = 0; ! 934: nb = 1; ! 935: bn -= NADDR-3; ! 936: for(j=3; j>0; j--) { ! 937: sh += NSHIFT; ! 938: nb <<= NSHIFT; ! 939: if(bn < nb) ! 940: break; ! 941: bn -= nb; ! 942: } ! 943: if(j == 0) { ! 944: return((daddr_t)0); ! 945: } ! 946: ! 947: /* ! 948: * fetch the address from the inode ! 949: */ ! 950: if((nb = iaddr[NADDR-j]) == 0) { ! 951: iaddr[NADDR-j] = nb = balloc(); ! 952: } ! 953: ! 954: /* ! 955: * fetch through the indirect blocks ! 956: */ ! 957: for(; j<=3; j++) { ! 958: dread(nb, (char *)indir, BSIZE); ! 959: sh -= NSHIFT; ! 960: i = (bn>>sh) & NMASK; ! 961: nnb = indir[i]; ! 962: if(nnb == 0) { ! 963: nnb = balloc(); ! 964: indir[i] = nnb; ! 965: dwrite(nb, (char *)indir); ! 966: } ! 967: nb = nnb; ! 968: } ! 969: return(nb); ! 970: } ! 971: ! 972: /* ! 973: * read the tape into buf, then return whether or ! 974: * or not it is a header block. ! 975: */ ! 976: gethead(buf) ! 977: struct spcl *buf; ! 978: { ! 979: readtape((char *)buf); ! 980: if (buf->c_magic != MAGIC || checksum((int *) buf) == 0) ! 981: return(0); ! 982: return(1); ! 983: } ! 984: ! 985: /* ! 986: * return whether or not the buffer contains a header block ! 987: */ ! 988: ishead(buf) ! 989: struct spcl *buf; ! 990: { ! 991: if (buf->c_magic != MAGIC || checksum((int *) buf) == 0) ! 992: return(0); ! 993: return(1); ! 994: } ! 995: ! 996: checktype(b, t) ! 997: struct spcl *b; ! 998: int t; ! 999: { ! 1000: return(b->c_type == t); ! 1001: } ! 1002: ! 1003: ! 1004: checksum(b) ! 1005: int *b; ! 1006: { ! 1007: register i, j; ! 1008: ! 1009: j = BSIZE/sizeof(int); ! 1010: i = 0; ! 1011: do ! 1012: i += *b++; ! 1013: while (--j); ! 1014: if (i != CHECKSUM) { ! 1015: printf("Checksum error %o\n", i); ! 1016: return(0); ! 1017: } ! 1018: return(1); ! 1019: } ! 1020: ! 1021: checkvol(b, t) ! 1022: struct spcl *b; ! 1023: int t; ! 1024: { ! 1025: if (b->c_volume == t) ! 1026: return(1); ! 1027: return(0); ! 1028: } ! 1029: ! 1030: readhdr(b) ! 1031: struct spcl *b; ! 1032: { ! 1033: if (gethead(b) == 0) ! 1034: return(0); ! 1035: if (checktype(b, TS_TAPE) == 0) ! 1036: return(0); ! 1037: return(1); ! 1038: } ! 1039: ! 1040: /* ! 1041: * The next routines are called during file extraction to ! 1042: * put the data into the right form and place. ! 1043: */ ! 1044: #ifndef STANDALONE ! 1045: xtrfile(b, size) ! 1046: char *b; ! 1047: long size; ! 1048: { ! 1049: write(ofile, b, (int) size); ! 1050: } ! 1051: ! 1052: null() {;} ! 1053: ! 1054: skip() ! 1055: { ! 1056: lseek(ofile, (long) BSIZE, 1); ! 1057: } ! 1058: #endif ! 1059: ! 1060: ! 1061: rstrfile(b, s) ! 1062: char *b; ! 1063: long s; ! 1064: { ! 1065: daddr_t d; ! 1066: ! 1067: d = bmap(taddr, curbno); ! 1068: dwrite(d, b); ! 1069: curbno += 1; ! 1070: } ! 1071: ! 1072: rstrskip(b, s) ! 1073: char *b; ! 1074: long s; ! 1075: { ! 1076: curbno += 1; ! 1077: } ! 1078: ! 1079: #ifndef STANDALONE ! 1080: putdir(b) ! 1081: char *b; ! 1082: { ! 1083: register struct direct *dp; ! 1084: register i; ! 1085: ! 1086: for (dp = (struct direct *) b, i = 0; i < BSIZE; dp++, i += sizeof(*dp)) { ! 1087: if (dp->d_ino == 0) ! 1088: continue; ! 1089: putent((char *) dp); ! 1090: } ! 1091: } ! 1092: #endif ! 1093: ! 1094: /* ! 1095: * read/write an inode from the disk ! 1096: */ ! 1097: getdino(inum, b) ! 1098: ino_t inum; ! 1099: struct dinode *b; ! 1100: { ! 1101: daddr_t bno; ! 1102: char buf[BSIZE]; ! 1103: ! 1104: bno = (ino - 1)/INOPB; ! 1105: bno += 2; ! 1106: dread(bno, buf, BSIZE); ! 1107: copy(&buf[((inum-1)%INOPB)*sizeof(struct dinode)], (char *) b, sizeof(struct dinode)); ! 1108: } ! 1109: ! 1110: putdino(inum, b) ! 1111: ino_t inum; ! 1112: struct dinode *b; ! 1113: { ! 1114: daddr_t bno; ! 1115: char buf[BSIZE]; ! 1116: ! 1117: bno = ((ino - 1)/INOPB) + 2; ! 1118: dread(bno, buf, BSIZE); ! 1119: copy((char *) b, &buf[((inum-1)%INOPB)*sizeof(struct dinode)], sizeof(struct dinode)); ! 1120: dwrite(bno, buf); ! 1121: } ! 1122: ! 1123: /* ! 1124: * read a bit mask from the tape into m. ! 1125: */ ! 1126: readbits(m) ! 1127: short *m; ! 1128: { ! 1129: register i; ! 1130: ! 1131: i = spcl.c_count; ! 1132: ! 1133: while (i--) { ! 1134: readtape((char *) m); ! 1135: m += (BSIZE/(MLEN/BITS)); ! 1136: } ! 1137: while (gethead(&spcl) == 0) ! 1138: ; ! 1139: } ! 1140: ! 1141: done() ! 1142: { ! 1143: #ifndef STANDALONE ! 1144: unlink(dirfile); ! 1145: #endif ! 1146: exit(0); ! 1147: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.