![[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 [MW Coherent from dump] / coherent / d / bin / dump|
Return to restor.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / dump |
1.1 ! root 1: /* ! 2: * Restore. ! 3: * restor key [args] ! 4: * f [dump] Use this dump, not the default. ! 5: * v Verbose. ! 6: * t Print dates of the dump. ! 7: * x,X Extract. X asks for reel numbers and does ! 8: * a rewind between reels. ! 9: * r,R Mass restore. R asks for reel numbers and does ! 10: * a rewind between reels. ! 11: * ! 12: * Multiple dumps can be put on a single spool of ! 13: * tape by dumping to the no rewind device. The restore is ! 14: * done by positioning the tape using the `skip' command and ! 15: * restoring using the `x' option. ! 16: */ ! 17: #include <stdio.h> ! 18: #include <dumptape.h> ! 19: #include <canon.h> ! 20: #include <sys/filsys.h> ! 21: #include <sys/fblk.h> ! 22: #include <discbuf.h> ! 23: #include <signal.h> ! 24: ! 25: #define NRBUF 10 /* # of restore cache buffers */ ! 26: ! 27: /* ! 28: * This structure is used ! 29: * to remember the names and i numbers ! 30: * of the files being extracted. ! 31: */ ! 32: struct xf ! 33: { ! 34: char *xf_path; /* Path name */ ! 35: ino_t xf_ino; /* The associated inumber */ ! 36: }; ! 37: ! 38: /* ! 39: * Structure used to remember ! 40: * things about the directories that ! 41: * were on the tape. ! 42: */ ! 43: struct dlist ! 44: { ! 45: struct dlist *dl_dlp; /* Link */ ! 46: ino_t dl_ino; /* Inumber of the directory */ ! 47: long dl_seek; /* Temp file seek address */ ! 48: long dl_size; /* Size in bytes */ ! 49: }; ! 50: ! 51: int is_open; /* dump device open? */ ! 52: int key; /* Operation */ ! 53: int vflag; /* A verbose flag */ ! 54: char *dtn = DTAPE; /* Dump file name */ ! 55: FILE *dtp; /* Its file pointer */ ! 56: struct dumpheader dh; /* Header buffer */ ! 57: int reel = 1; /* Reel # */ ! 58: fsize_t length = 512; /* Length of volume */ ! 59: fsize_t nread; /* Bytes read from volume */ ! 60: char tfn[30] = "/tmp/ddxxxxxx"; /* Temp file name */ ! 61: FILE *tfp; /* Its file pointer */ ! 62: struct dlist *dlist; /* List of directory nodes */ ! 63: struct dlist *droot; /* Root (first) directory node */ ! 64: char *ddbuf; /* Big buffer */ ! 65: char *ddend; /* End of the big buffer */ ! 66: int ddnbuf; /* Size of the big buffer */ ! 67: union dumpdata *ddptr; /* Current buffer pointer */ ! 68: char *map; /* Directory map */ ! 69: int nxf; /* # of `x' files */ ! 70: ino_t nindisc; /* # of inodes on the disc */ ! 71: ino_t ningrab; /* # of inodes to grab */ ! 72: struct xf *xfp; /* Pointer for x names */ ! 73: ! 74: /* ! 75: * Block mapping tables. ! 76: */ ! 77: #define LNBN ((daddr_t) NBN) ! 78: ! 79: char offs[] = { ! 80: 0, ! 81: ND, ! 82: ND+1, ! 83: ND+1+1, ! 84: ND+1+1+1 ! 85: }; ! 86: ! 87: daddr_t ranges[] = { ! 88: ND, ! 89: ND + 1*LNBN, ! 90: ND + 1*LNBN + 1*LNBN*LNBN, ! 91: ND + 1*LNBN + 1*LNBN*LNBN + 1*LNBN*LNBN*LNBN ! 92: }; ! 93: ! 94: char shifts[] = { ! 95: 0, ! 96: L2NBN, ! 97: 2*L2NBN, ! 98: 3*L2NBN ! 99: }; ! 100: ! 101: daddr_t masks[] = { ! 102: 0, ! 103: LNBN-1, ! 104: LNBN*LNBN-1, ! 105: LNBN*LNBN*LNBN-1 ! 106: }; ! 107: ! 108: /* ! 109: * Forward references for the ! 110: * one pass compiler. ! 111: */ ! 112: ino_t lookup(); ! 113: ino_t numfile(); ! 114: daddr_t balloc(); ! 115: char *ctime(); ! 116: int cleanup(); ! 117: struct dlist *findnode(); ! 118: union dumpdata *readdump(); ! 119: char *calloc(); ! 120: DISCBUF *dbimap(); ! 121: ! 122: main(argc, argv) ! 123: char *argv[]; ! 124: { ! 125: register char *p; ! 126: register c, i; ! 127: register struct xf *rxfp; ! 128: char *name, *path; ! 129: ino_t ino; ! 130: ! 131: if (argc < 2) ! 132: usage(); ! 133: p = argv[1]; ! 134: i = 1; ! 135: while ((c = *p++) != '\0') { ! 136: switch (c) { ! 137: ! 138: case 'f': ! 139: if (++i >= argc) ! 140: usage(); ! 141: dtn = argv[i]; ! 142: break; ! 143: ! 144: case 'r': ! 145: case 'R': ! 146: case 'x': ! 147: case 'X': ! 148: case 't': ! 149: if (key != 0) ! 150: usage(); ! 151: key = c; ! 152: break; ! 153: ! 154: case 'v': ! 155: vflag = 1; ! 156: break; ! 157: ! 158: case '-': ! 159: { ! 160: /* Cf. nextvol() */ ! 161: extern long RESTMIN, RESTMAX; ! 162: ! 163: if (++i >= argc) ! 164: usage(); ! 165: RESTMIN = atoi(argv[i]); ! 166: if (++i >= argc) ! 167: usage(); ! 168: RESTMAX = atoi(argv[i]); ! 169: break; ! 170: } ! 171: ! 172: default: ! 173: usage(); ! 174: } ! 175: } ! 176: if (signal(SIGINT, SIG_IGN) != SIG_IGN) ! 177: signal(SIGINT, cleanup); ! 178: switch (key) { ! 179: ! 180: case 'r': ! 181: case 'R': ! 182: if (++i >= argc) ! 183: usage(); ! 184: if ((dbfp = fopen(argv[i], "r+w")) == NULL) ! 185: message(1, "%s: cannot open filesystem", argv[i]); ! 186: dbclaim(NRBUF); ! 187: if (key == 'r') ! 188: nextvol(1); ! 189: else { ! 190: for (;;) { ! 191: reel = getreel(); ! 192: opendump(); ! 193: if (readhead(0) != 0) ! 194: break; ! 195: fclose(dtp); ! 196: } ! 197: } ! 198: restore(); ! 199: dbflush(1); ! 200: break; ! 201: ! 202: case 'x': ! 203: case 'X': ! 204: nextvol(1); ! 205: mktemp(tfn); ! 206: if ((tfp = fopen(tfn, "w")) == NULL ! 207: || (tfp = freopen(tfn, "r+w", tfp)) == NULL) ! 208: message(1, "cannot create temporary file"); ! 209: readdirs(); ! 210: xfp = (struct xf *)malloc((argc-i)*sizeof(struct xf)); ! 211: if (xfp == NULL) ! 212: message(1, "too many restore names"); ! 213: rxfp = xfp; ! 214: while (++i < argc) { ! 215: name = argv[i]; ! 216: if ((ino = numfile(name)) != 0) { ! 217: if (ino<ROOTIN || ino>dh.dh_nino) { ! 218: message(0, "%s: bad inumber", name); ! 219: continue; ! 220: } ! 221: path = "(by ino)"; ! 222: } else if ((ino = lookup(name)) != 0) ! 223: path = name; ! 224: else { ! 225: message(0, "%s: not found", name); ! 226: continue; ! 227: } ! 228: if (getmap(ino) == 0) { ! 229: message(0, "%s: not dumped", name); ! 230: continue; ! 231: } ! 232: rxfp->xf_path = path; ! 233: rxfp->xf_ino = ino; ! 234: rxfp++; ! 235: ++nxf; ! 236: } ! 237: if (nxf == 0) ! 238: break; ! 239: for (i=0; i<nxf; ++i) ! 240: printf("%u\t%s\n", xfp[i].xf_ino, xfp[i].xf_path); ! 241: if (key == 'x') ! 242: readfile(0); ! 243: else { ! 244: for (;;) { ! 245: fclose(dtp); ! 246: reel = getreel(); ! 247: opendump(); ! 248: readfile(1); ! 249: for (i=0; i<nxf && xfp[i].xf_ino==0; ++i) ! 250: ; ! 251: if (i == nxf) ! 252: break; ! 253: } ! 254: } ! 255: fclose(dtp); ! 256: for (i=0; i<nxf; ++i) ! 257: if (xfp[i].xf_ino != 0) ! 258: message(0, "%s: not restored", xfp[i].xf_path); ! 259: break; ! 260: ! 261: case 't': ! 262: opendump(); ! 263: readhead(1); ! 264: fprintf(stderr, "Dump since %s", ctime(&dh.dh_ddate)); ! 265: fprintf(stderr, "Dumped on %s", ctime(&dh.dh_bdate)); ! 266: break; ! 267: ! 268: default: ! 269: usage(); ! 270: } ! 271: delexit(0); ! 272: } ! 273: ! 274: /* ! 275: * If the supplied character string ! 276: * is all number convert it to binary and ! 277: * return it. Otherwise return 0. A ! 278: * file name that is all numeric is taken ! 279: * to be an inumber. ! 280: */ ! 281: ino_t ! 282: numfile(s) ! 283: register char *s; ! 284: { ! 285: register ino_t ino; ! 286: register c; ! 287: ! 288: ino = 0; ! 289: while ((c = *s++)>='0' && c<='9') ! 290: ino = 10*ino + c - '0'; ! 291: if (c != '\0') ! 292: return (0); ! 293: return (ino); ! 294: } ! 295: ! 296: /* ! 297: * Open the dump tape. ! 298: * Die if the tape cannot be opened ! 299: * for any reason. ! 300: */ ! 301: opendump() ! 302: { ! 303: if ((dtp = fopen(dtn, "r")) == NULL) ! 304: message(1, "%s: cannot open dump file", dtn); ! 305: ++is_open; ! 306: } ! 307: ! 308: /* ! 309: * Read reel number. ! 310: */ ! 311: getreel() ! 312: { ! 313: register c, flag, reel; ! 314: ! 315: for (;;) { ! 316: fprintf(stderr, "restor: desired volume? "); ! 317: reel = 0; ! 318: flag = 0; ! 319: while ((c = getchar())>='0' && c<='9') { ! 320: flag = 1; ! 321: reel = 10*reel + c - '0'; ! 322: } ! 323: if (c == EOF) ! 324: delexit(1); ! 325: if (c=='\n' && flag!=0) ! 326: return (reel); ! 327: message(0, "bad reel number"); ! 328: while (c!=EOF && c!='\n') ! 329: c = getchar(); ! 330: if (c == EOF) ! 331: delexit(1); ! 332: } ! 333: } ! 334: ! 335: /* ! 336: * Do the hard work of a ! 337: * restore. ! 338: * (NOTE: I think that the flag is now a fossil). ! 339: */ ! 340: readfile(flag) ! 341: { ! 342: register union dumpdata *ddp; ! 343: register ino_t ino; ! 344: register FILE *rfp; ! 345: register i; ! 346: int bwerror, outsync; ! 347: char rfn[20]; ! 348: ! 349: if (flag) { ! 350: while ((ddp = readdump()) != NULL) ! 351: if (ddp->dd_type != DD_DATA) ! 352: break; ! 353: #if 0 ! 354: if (readhead(0) == 0) ! 355: return; ! 356: while ((ddp = readdump()) != NULL) { ! 357: if (ddp->dd_type != DD_MAP) ! 358: break; ! 359: canino(ddp->dd_ino); ! 360: canint(ddp->dd_nmap); ! 361: setmap(ddp); ! 362: } ! 363: #endif ! 364: } else ! 365: ddp = readdump(); ! 366: if (ddp==NULL || anyfiles()==0) ! 367: return; ! 368: outsync = 0; ! 369: do { ! 370: switch (ddp->dd_type) { ! 371: ! 372: case DD_EOT: ! 373: return; ! 374: ! 375: case DD_INO: ! 376: canino(ddp->dd_ino); ! 377: ino = ddp->dd_ino; ! 378: rfp = NULL; ! 379: bwerror = 0; ! 380: if (outsync == 1) ! 381: message(0, "skipped 1 item"); ! 382: else if (outsync != 0) ! 383: message(0, "skipped %d items", outsync); ! 384: outsync = 0; ! 385: for (i=0; i<nxf && xfp[i].xf_ino!=ino; ++i) ! 386: ; ! 387: if (i != nxf) { ! 388: sprintf(rfn, "%u", ino); ! 389: if ((rfp = fopen(rfn, "w")) == NULL) ! 390: message(0, "%s: cannot create", rfn); ! 391: else ! 392: xfp[i].xf_ino = 0; ! 393: } ! 394: while ((ddp = readdump()) != NULL) { ! 395: if (ddp->dd_type != DD_DATA) ! 396: break; ! 397: canino(ddp->dd_ino); ! 398: if (ddp->dd_ino != ino) { ! 399: if (outsync == 0) ! 400: message(0, "data sync"); ! 401: ++outsync; ! 402: continue; ! 403: } ! 404: if (rfp != NULL) { ! 405: candaddr(ddp->dd_block); ! 406: canint(ddp->dd_size); ! 407: if (bwrite(rfp, ddp) == 0) ! 408: bwerror = 1; ! 409: } ! 410: } ! 411: if (bwerror) ! 412: message("%s: write error", rfn); ! 413: if (rfp != NULL) ! 414: fclose(rfp); ! 415: if (anyfiles() == 0) ! 416: return; ! 417: break; ! 418: ! 419: default: ! 420: if (outsync == 0) ! 421: message(0, "inode sync"); ! 422: ++outsync; ! 423: } ! 424: } while (ddp != NULL); ! 425: } ! 426: ! 427: /* ! 428: * Do a restore. ! 429: * The tape is open and the header ! 430: * has been checked. ! 431: */ ! 432: restore() ! 433: { ! 434: register union dumpdata *ddp; ! 435: register DISCBUF *dbp; ! 436: struct filsys *fsp; ! 437: register ino_t ino; ! 438: struct dinode *dip; ! 439: struct dinode dinode; ! 440: int me, outsync; ! 441: int ifmt, ndeleted; ! 442: ! 443: /* ! 444: * If the target file system is not ! 445: * large enough, complain about it and pretend ! 446: * that all of the inodes that are beyond the ! 447: * end are not there. This may, of course, leave ! 448: * the file system addled. ! 449: */ ! 450: dbp = dbread((long) SUPERI); ! 451: fsp = (struct filsys *) dbp->db_data; ! 452: nindisc = fsp->s_isize; ! 453: canino(nindisc); ! 454: nindisc = INOPB * (nindisc-INODEI); ! 455: ningrab = dh.dh_nino; ! 456: if (ningrab > nindisc) { ! 457: message(0, "I-list too small, some I-nodes may be deleted"); ! 458: ningrab = nindisc; ! 459: } ! 460: /* ! 461: * Read in the map. ! 462: */ ! 463: while ((ddp=readdump()) != NULL) { ! 464: if (ddp->dd_type != DD_MAP) ! 465: break; ! 466: canino(ddp->dd_ino); ! 467: canint(ddp->dd_nmap); ! 468: setmap(ddp); ! 469: } ! 470: /* ! 471: * Do required inode clears. ! 472: * Never clear the badblock inode. ! 473: * Clear only as far as we are restoring; ! 474: * that is, ningrab inodes. ! 475: */ ! 476: for (ino=ROOTIN; ino<=ningrab; ++ino) { ! 477: me = getmap(ino); ! 478: if ((me&DD_BUSY)==0 || (me&DD_HERE)==DD_HERE) { ! 479: if (vflag) ! 480: message(0, "clri I#%u", ino); ! 481: clri(ino); ! 482: } ! 483: } ! 484: /* ! 485: * Read through the tape. ! 486: * Look for files that we are going to ! 487: * restore and do so. ! 488: */ ! 489: outsync = 0; ! 490: ndeleted = 0; ! 491: while (ddp!=NULL && ddp->dd_type!=DD_EOT) { ! 492: if (ddp->dd_type != DD_INO) { ! 493: if (outsync++ == 0) ! 494: message(0, "inode sync"); ! 495: ddp = readdump(); ! 496: continue; ! 497: } ! 498: /* ! 499: * Restore the file. ! 500: * Block by block. ! 501: * Don't move anything. ! 502: */ ! 503: canino(ddp->dd_ino); ! 504: if ((ino=ddp->dd_ino) > ningrab) { ! 505: if (vflag != 0) ! 506: message(0, "deleted I#%u", (unsigned)ino); ! 507: ++ndeleted; ! 508: printskip(outsync); ! 509: outsync = 0; ! 510: while ((ddp=readdump()) != NULL) { ! 511: if (ddp->dd_type != DD_DATA) ! 512: break; ! 513: canino(ddp->dd_ino); ! 514: if (ddp->dd_ino!=ino && outsync++==0) ! 515: message(0, "skip sync"); ! 516: } ! 517: continue; ! 518: } ! 519: if (vflag != 0) ! 520: message(0, "restoring I#%u", (unsigned)ino); ! 521: copyb(&dinode, &ddp->dd_dinode, sizeof(dinode)); ! 522: canshort(ddp->dd_dinode.di_mode); ! 523: ifmt = ddp->dd_dinode.di_mode&IFMT; ! 524: if (ifmt==IFREG || ifmt==IFDIR) ! 525: zerob(dinode.di_addr, sizeof(dinode.di_addr)); ! 526: printskip(outsync); ! 527: outsync = 0; ! 528: while ((ddp=readdump()) != NULL) { ! 529: if (ddp->dd_type != DD_DATA) ! 530: break; ! 531: canino(ddp->dd_ino); ! 532: if (ddp->dd_ino != ino) { ! 533: if (outsync++ == 0) ! 534: message(0, "data sync"); ! 535: continue; ! 536: } ! 537: candaddr(ddp->dd_block); ! 538: canint(ddp->dd_size); ! 539: dbp = dbimap(&dinode, ddp->dd_block); ! 540: copyb(dbp->db_data,ddp->dd_data,ddp->dd_size); ! 541: dbfree(dbp, DB_DIRT); ! 542: } ! 543: dbp = dbread((long) (--ino/INOPB + INODEI)); ! 544: dip = (struct dinode *)(dbp->db_data) + ino%INOPB; ! 545: if (dip->di_mode != 0) { ! 546: message(0, "I#%u busy", (unsigned)ino+1); ! 547: clri(ino+1); ! 548: } ! 549: copyb((char *)dip, (char *)&dinode, sizeof(dinode)); ! 550: dbfree(dbp, DB_DIRT); ! 551: } ! 552: if (ndeleted != 0) ! 553: message(0, "%d I-nodes deleted", ndeleted); ! 554: fixilist(); ! 555: } ! 556: ! 557: /* ! 558: * Print out a message that ! 559: * tells the number of data items that were ! 560: * skipped on the tape. Special stuff for ! 561: * handling 0 and 1 items. ! 562: */ ! 563: printskip(n) ! 564: { ! 565: if (n == 1) ! 566: message(0, "skipped 1 item"); ! 567: else if (n != 0) ! 568: message(0, "skipped %d items", n); ! 569: } ! 570: ! 571: /* ! 572: * Fix the ifree list in ! 573: * the super block. It is safer to ! 574: * always reconstruct it. ! 575: */ ! 576: fixilist() ! 577: { ! 578: DISCBUF *ibp, *sbp; ! 579: register struct filsys *fsp; ! 580: register struct dinode *dip; ! 581: register ino_t ino; ! 582: short ninode, tinode, minode; ! 583: ino_t tmpino; ! 584: ! 585: if (vflag) ! 586: message(0, "building I-free list"); ! 587: sbp = dbread((long) SUPERI); ! 588: fsp = (struct filsys *)(sbp->db_data); ! 589: tinode = 0; ! 590: ninode = 0; ! 591: minode = fsp->s_isize; ! 592: canshort(minode); ! 593: minode = INOPB * (minode-INODEI); ! 594: ibp = NULL; ! 595: for (ino=1; ino<=minode; ++ino) { ! 596: if ((ino-1)%INOPB == 0) { ! 597: if (ibp != NULL) ! 598: dbfree(ibp, 0); ! 599: ibp = dbread((long) ((ino-1)/INOPB + INODEI)); ! 600: dip = (struct dinode *)(ibp->db_data); ! 601: } ! 602: if (dip->di_mode == 0) { ! 603: ++tinode; ! 604: if (ninode < NICINOD) { ! 605: tmpino = ino; ! 606: canino(tmpino); ! 607: fsp->s_inode[ninode++] = tmpino; ! 608: } ! 609: } ! 610: ++dip; ! 611: } ! 612: dbfree(ibp, 0); ! 613: canshort(tinode); ! 614: fsp->s_tinode = tinode; ! 615: canshort(ninode); ! 616: fsp->s_ninode = ninode; ! 617: strncpy(fsp->s_fname, dh.dh_fname, sizeof(dh.dh_fname)); ! 618: strncpy(fsp->s_fpack, dh.dh_fpack, sizeof(dh.dh_fpack)); ! 619: dbfree(sbp, DB_DIRT); ! 620: } ! 621: ! 622: /* ! 623: * Clear an inode. ! 624: * Free all of its blocks and ! 625: * zero the on disc inode. Don't worry about ! 626: * the super block as it is always rebuilt ! 627: * at the end. ! 628: */ ! 629: clri(ino) ! 630: ino_t ino; ! 631: { ! 632: register DISCBUF *dbp; ! 633: register struct dinode *dip; ! 634: register i; ! 635: short dimode; ! 636: daddr_t addr[NADDR]; ! 637: ! 638: dbp = dbread((long) ((ino-1)/INOPB + INODEI)); ! 639: dip = (struct dinode *)(dbp->db_data) + (ino-1)%INOPB; ! 640: dimode = dip->di_mode; ! 641: canshort(dimode); ! 642: if ((dimode&IFMT)==IFDIR || (dimode&IFMT)==IFREG) { ! 643: l3tol(addr, dip->di_addr, NADDR); ! 644: for (i=0; i<NADDR-3; ++i) ! 645: bfree(addr[i], 0); ! 646: bfree(addr[NADDR-3], 1); ! 647: bfree(addr[NADDR-2], 2); ! 648: bfree(addr[NADDR-1], 3); ! 649: } ! 650: zerob((char *) dip, sizeof(struct dinode)); ! 651: dbfree(dbp, DB_DIRT); ! 652: } ! 653: ! 654: /* ! 655: * Free a block. ! 656: * The first argument is the block ! 657: * number. 0 here means no block is allocated ! 658: * and the call is a nop. The second argument ! 659: * is the number of levels of indirect blocks ! 660: * to read through. ! 661: */ ! 662: bfree(bn, nil) ! 663: daddr_t bn; ! 664: { ! 665: register DISCBUF *dbp, *dbp1; ! 666: struct filsys *fsp; ! 667: struct fblk *fbp; ! 668: int dbp1flag; ! 669: int i; ! 670: daddr_t ibn; ! 671: ! 672: if (bn == 0) ! 673: return; ! 674: dbp1 = NULL; ! 675: if (nil != 0) { ! 676: dbp1flag = 0; ! 677: dbp1 = dbread((long) bn); ! 678: for (i=0; i<NBN; ++i) { ! 679: ibn = ((daddr_t *) dbp1->db_data)[i]; ! 680: if (ibn != 0) { ! 681: candaddr(ibn); /* Added by Mike */ ! 682: bfree(ibn, nil-1); ! 683: } ! 684: } ! 685: } ! 686: dbp = dbread((long) SUPERI); ! 687: fsp = (struct filsys *) dbp->db_data; ! 688: canshort(fsp->s_nfree); ! 689: if (fsp->s_nfree == NICFREE) { ! 690: if (dbp1 == NULL) ! 691: dbp1 = dbread((long) bn); ! 692: dbp1flag = DB_DIRT; ! 693: fbp = (struct fblk *) dbp1->db_data; ! 694: fbp->df_nfree = fsp->s_nfree; ! 695: canshort(fbp->df_nfree); ! 696: copyb(fbp->df_free, fsp->s_free, sizeof(fsp->s_free)); ! 697: fsp->s_nfree = 0; ! 698: } ! 699: candaddr(bn); ! 700: fsp->s_free[fsp->s_nfree++] = bn; ! 701: canshort(fsp->s_nfree); ! 702: candaddr(fsp->s_tfree); ! 703: ++fsp->s_tfree; ! 704: candaddr(fsp->s_tfree); ! 705: if (dbp1 != NULL) ! 706: dbfree(dbp1, dbp1flag); ! 707: dbfree(dbp, DB_DIRT); ! 708: } ! 709: ! 710: /* ! 711: * Allocate a block. ! 712: * Return 0 if there are no blocks ! 713: * remaining. ! 714: */ ! 715: daddr_t ! 716: balloc() ! 717: { ! 718: register struct filsys *fsp; ! 719: register DISCBUF *dbp; ! 720: register DISCBUF *dbp1; ! 721: register struct fblk *fbp; ! 722: short nfree; ! 723: daddr_t tfree, bn; ! 724: ! 725: dbp = dbread((long) SUPERI); ! 726: fsp = (struct filsys *) dbp->db_data; ! 727: if ((tfree = fsp->s_tfree) == 0) ! 728: message(1, "out of space"); ! 729: candaddr(tfree); ! 730: nfree = fsp->s_nfree; ! 731: canshort(nfree); ! 732: if ((bn = fsp->s_free[--nfree]) == 0) ! 733: message(1, "out of space and tfree lied"); ! 734: candaddr(bn); ! 735: if (nfree == 0) { ! 736: dbp1 = dbread((long) bn); ! 737: fbp = (struct fblk *) dbp1->db_data; ! 738: nfree = fbp->df_nfree; ! 739: canshort(nfree); ! 740: copyb(fsp->s_free, fbp->df_free, sizeof(fsp->s_free)); ! 741: dbfree(dbp1, 0); ! 742: } ! 743: --tfree; ! 744: canshort(nfree); ! 745: fsp->s_nfree = nfree; ! 746: candaddr(tfree); ! 747: fsp->s_tfree = tfree; ! 748: dbfree(dbp, DB_DIRT); ! 749: return (bn); ! 750: } ! 751: ! 752: /* ! 753: * Quickly zero out a block of ! 754: * memory. Used to clear out disc inodes ! 755: * and other similar things. ! 756: */ ! 757: zerob(ap, an) ! 758: char *ap; ! 759: { ! 760: register char *p; ! 761: register n; ! 762: ! 763: if ((n = an) != 0) { ! 764: p = ap; ! 765: do { ! 766: *p++ = 0; ! 767: } while (--n); ! 768: } ! 769: } ! 770: ! 771: /* ! 772: * Quickly move a block of ! 773: * memory from one place to another ! 774: * place. ! 775: */ ! 776: copyb(atp, afp, an) ! 777: char *atp; ! 778: char *afp; ! 779: { ! 780: register char *tp, *fp; ! 781: register n; ! 782: ! 783: if ((n = an) != 0) { ! 784: tp = atp; ! 785: fp = afp; ! 786: do { ! 787: *tp++ = *fp++; ! 788: } while (--n); ! 789: } ! 790: } ! 791: ! 792: /* ! 793: * Yet another version of ! 794: * the inode mapping code. This version ! 795: * allocates blocks if they are not present ! 796: * in the file. It makes good use of the ! 797: * buffer cache. ! 798: * A pointer to a DISCBUF holding the ! 799: * block is returned. Usually this will be ! 800: * a buffer created by `dbzero'. ! 801: */ ! 802: DISCBUF * ! 803: dbimap(dip, lb) ! 804: struct dinode *dip; ! 805: daddr_t lb; ! 806: { ! 807: register DISCBUF *dbp; ! 808: register il, newblock; ! 809: daddr_t addr[NADDR]; ! 810: daddr_t pb, bpos, *bkp; ! 811: ! 812: l3tol(addr, dip->di_addr, NADDR); ! 813: for (il=0; il<4; ++il) { ! 814: if (lb < ranges[il]) { ! 815: if (il > 0) ! 816: lb -= ranges[il-1]; ! 817: bpos = lb >> shifts[il]; ! 818: lb &= masks[il]; ! 819: bkp = &addr[(int)bpos + offs[il]]; ! 820: newblock = 0; ! 821: if ((pb = *bkp) == 0) { ! 822: newblock = 1; ! 823: *bkp = pb = balloc(); ! 824: ltol3(dip->di_addr, addr, NADDR); ! 825: } ! 826: if (pb != 0) { ! 827: while (il-- > 0) { ! 828: if (newblock) ! 829: dbp = dbzero(pb); else ! 830: dbp = dbread(pb); ! 831: bpos = lb >> shifts[il]; ! 832: lb &= masks[il]; ! 833: bkp = (long *)dbp->db_data + bpos; ! 834: pb = *bkp; ! 835: candaddr(pb); ! 836: if (pb == 0) { ! 837: newblock = 1; ! 838: pb = balloc(); ! 839: *bkp = pb; ! 840: candaddr(*bkp); ! 841: dbfree(dbp, DB_DIRT); ! 842: } else { ! 843: newblock = 0; ! 844: dbfree(dbp, 0); ! 845: } ! 846: if (pb == 0) ! 847: break; ! 848: } ! 849: } ! 850: if (pb != 0) { ! 851: if (newblock) ! 852: dbp = dbzero(pb); else ! 853: dbp = dbread(pb); ! 854: return (dbp); ! 855: } ! 856: return (NULL); ! 857: } ! 858: } ! 859: message(0, "file too large to map"); ! 860: return (NULL); ! 861: } ! 862: ! 863: /* ! 864: * Write a block. ! 865: */ ! 866: bwrite(fp, ddp) ! 867: register FILE *fp; ! 868: register union dumpdata *ddp; ! 869: { ! 870: lseek(fileno(fp), BUFSIZ*ddp->dd_block, 0); ! 871: if (write(fileno(fp), ddp->dd_data, ddp->dd_size) != ddp->dd_size) ! 872: return (0); ! 873: return (1); ! 874: } ! 875: ! 876: /* ! 877: * Check if any files in the ! 878: * `x' file list remain on this ! 879: * tape (as indicated by the ! 880: * map). ! 881: */ ! 882: anyfiles() ! 883: { ! 884: register ino_t ino; ! 885: register i; ! 886: ! 887: for (i=0; i<nxf; ++i) { ! 888: if ((ino = xfp[i].xf_ino)!=0 && getmap(ino)!=0) ! 889: return (1); ! 890: } ! 891: return (0); ! 892: } ! 893: ! 894: /* ! 895: * Read and validate tape header. ! 896: * The `quit' flag is true if errors ! 897: * are fatal. ! 898: * Only allocate the map first time. ! 899: */ ! 900: readhead(quit) ! 901: { ! 902: register char *p; ! 903: register checksum; ! 904: ! 905: if (read(fileno(dtp), &dh, sizeof dh) != sizeof dh) { ! 906: message(quit, "header read error"); ! 907: return (0); ! 908: } ! 909: nread = sizeof dh; ! 910: canint(dh.dh_magic); ! 911: canino(dh.dh_nino); ! 912: cantime(dh.dh_bdate); ! 913: cantime(dh.dh_ddate); ! 914: canint(dh.dh_level); ! 915: canint(dh.dh_reel); ! 916: canint(dh.dh_blocking); ! 917: cansize(dh.dh_nbyte); ! 918: canint(dh.dh_checksum); ! 919: if (dh.dh_magic != DH_MAG) { ! 920: message(quit, "not a dump"); ! 921: return (0); ! 922: } ! 923: p = (char *) &dh; ! 924: checksum = 0; ! 925: while (p < (char *) &dh.dh_checksum) ! 926: checksum += (*p++) & 0377; ! 927: if (checksum != dh.dh_checksum) { ! 928: message(quit, "checksum error"); ! 929: return (0); ! 930: } ! 931: if (dh.dh_reel != reel) { ! 932: message(quit, "wrong reel (is %d, not %d)", dh.dh_reel, reel); ! 933: return (0); ! 934: } ! 935: ++reel; ! 936: length = dh.dh_nbyte; ! 937: if (map == NULL) { ! 938: if ((map = calloc(sizeof(char), dh.dh_nino)) == NULL) ! 939: message(1, "out of memory (map)"); ! 940: } ! 941: if (ddbuf != NULL) ! 942: free(ddbuf); ! 943: ddnbuf = dh.dh_blocking * sizeof(union dumpdata); ! 944: if ((ddbuf = malloc(ddnbuf)) == NULL) ! 945: message(1, "out of memory (big buffer)"); ! 946: ddend = &ddbuf[ddnbuf]; ! 947: ddptr = (union dumpdata *) ddend; ! 948: return (1); ! 949: } ! 950: ! 951: /* ! 952: * Read in directories and set up ! 953: * the map. The last tape record is ungotten ! 954: * so that the extract code can be made a ! 955: * little simpler. ! 956: */ ! 957: readdirs() ! 958: { ! 959: register union dumpdata *ddp; ! 960: register struct dlist *dlp; ! 961: unsigned short mode; ! 962: ! 963: while ((ddp = readdump()) != NULL) { ! 964: switch (ddp->dd_type) { ! 965: ! 966: case DD_EOT: ! 967: --ddptr; ! 968: return; ! 969: ! 970: case DD_MAP: ! 971: canino(ddp->dd_ino); ! 972: canint(ddp->dd_nmap); ! 973: setmap(ddp); ! 974: break; ! 975: ! 976: case DD_INO: ! 977: mode = ddp->dd_dinode.di_mode; ! 978: canshort(mode); ! 979: if ((mode&IFMT) != IFDIR) { ! 980: --ddptr; ! 981: return; ! 982: } ! 983: canino(ddp->dd_ino); ! 984: cansize(ddp->dd_dinode.di_size); ! 985: dlp = (struct dlist *) malloc(sizeof(struct dlist)); ! 986: if (dlp == NULL) ! 987: message(1, "out of memory (dlist)"); ! 988: dlp->dl_dlp = dlist; ! 989: dlist = dlp; ! 990: if (droot == NULL) ! 991: droot = dlp; ! 992: dlp->dl_ino = ddp->dd_ino; ! 993: dlp->dl_seek = ftell(tfp); ! 994: dlp->dl_size = ddp->dd_dinode.di_size; ! 995: break; ! 996: ! 997: case DD_DATA: ! 998: canino(ddp->dd_ino); ! 999: candaddr(ddp->dd_block); ! 1000: canint(ddp->dd_size); ! 1001: if (dlist==NULL || dlist->dl_ino!=ddp->dd_ino) ! 1002: message(1, "directory out of sync"); ! 1003: fseek(tfp, dlp->dl_seek+(BUFSIZ*ddp->dd_block), 0); ! 1004: fwrite(ddp->dd_data, sizeof(char), ddp->dd_size, tfp); ! 1005: if (ferror(tfp)) ! 1006: message(1, "directory write error"); ! 1007: break; ! 1008: ! 1009: default: ! 1010: message(1, "bad type %d", ddp->dd_type); ! 1011: } ! 1012: } ! 1013: } ! 1014: ! 1015: /* ! 1016: * Fill in map. ! 1017: */ ! 1018: setmap(ddp) ! 1019: union dumpdata *ddp; ! 1020: { ! 1021: register char *p1, *p2; ! 1022: register nb; ! 1023: ! 1024: if ((nb = ddp->dd_nmap) != 0) { ! 1025: p1 = &map[ddp->dd_ino-1]; ! 1026: p2 = ddp->dd_map; ! 1027: do { ! 1028: *p1++ = *p2++; ! 1029: } while (--nb); ! 1030: } ! 1031: } ! 1032: ! 1033: /* ! 1034: * Get map item. ! 1035: */ ! 1036: getmap(ino) ! 1037: ino_t ino; ! 1038: { ! 1039: return (map[ino-1]); ! 1040: } ! 1041: ! 1042: /* ! 1043: * Read dump file. ! 1044: * Canonize the type and look after ! 1045: * multi-volume (reel) dumps. ! 1046: */ ! 1047: union dumpdata * ! 1048: readdump() ! 1049: { ! 1050: register nb; ! 1051: ! 1052: while ((char *) ddptr == ddend) { ! 1053: if (length != 0 && (nread+ddnbuf) > length) { ! 1054: nextvol(0); ! 1055: continue; ! 1056: } ! 1057: if ((nb = read(fileno(dtp), ddbuf, ddnbuf)) != ddnbuf) { ! 1058: if (nb != 0) ! 1059: message(1, "dump read error"); ! 1060: nextvol(0); ! 1061: continue; ! 1062: } ! 1063: ddptr = (union dumpdata *) ddbuf; ! 1064: nread += nb; ! 1065: break; ! 1066: } ! 1067: canint(ddptr->dd_type); ! 1068: return (ddptr++); ! 1069: } ! 1070: ! 1071: /* ! 1072: * Read the next volume (reel or diskette) ! 1073: * from the dump. ! 1074: * The flag is passed onto readhead for quiting. ! 1075: * ! 1076: * RESTMIN, RESTMAX, and restime are used to bound the time taken ! 1077: * to restor a volume in hopes of preventing unbounded copies of ! 1078: * Coherent dump distributions. The values are passed with an ! 1079: * undocumented '-' option which specifies RESTMIN and RESTMAX. ! 1080: */ ! 1081: long RESTMIN, RESTMAX, restime, time(); ! 1082: ! 1083: nextvol(flag) ! 1084: int flag; ! 1085: { ! 1086: register int c; ! 1087: register char *vtype = "reel"; ! 1088: ! 1089: restime += time(NULL); ! 1090: /* Spurious error to detect copies of dump volumes ! 1091: * made with ms-dos formatter/copier. Activated by ! 1092: * '-' key modifier in command list. ! 1093: * Not documented in manual. ! 1094: */ ! 1095: if (RESTMIN && reel > 1 && (restime < RESTMIN || restime > RESTMAX)) ! 1096: message(1, "volume sync: %ld", restime); ! 1097: for (;;) { ! 1098: if (is_open) { ! 1099: fclose(dtp); ! 1100: is_open = 0; ! 1101: } ! 1102: if (length != 0) ! 1103: vtype = "volume"; ! 1104: fprintf(stderr, "restor: mount %s %d, type return key...", ! 1105: vtype, reel); ! 1106: while ((c = getchar())!=EOF && c!='\n') ! 1107: ; ! 1108: if (c == EOF) ! 1109: delexit(1); ! 1110: restime = -time(NULL); ! 1111: opendump(); ! 1112: if (readhead(flag) != 0) ! 1113: break; ! 1114: } ! 1115: } ! 1116: ! 1117: /* ! 1118: * Lookup a file, by name. ! 1119: * Return the inumber. ! 1120: * This routine only looks in ! 1121: * directories. The file may ! 1122: * not actually be on the tape. ! 1123: */ ! 1124: ino_t ! 1125: lookup(cp) ! 1126: register char *cp; ! 1127: { ! 1128: char db[DIRSIZ]; ! 1129: struct direct dirbuf; ! 1130: ino_t ino; ! 1131: long seek; ! 1132: struct dlist *dlp; ! 1133: ! 1134: ino = ROOTIN; ! 1135: for (;;) { ! 1136: { ! 1137: register char *dp; ! 1138: register c; ! 1139: ! 1140: while ((c = *cp++) == '/') ! 1141: ; ! 1142: if (c == '\0') ! 1143: return (ino); ! 1144: dp = db; ! 1145: for (;;) { ! 1146: if (dp < &db[DIRSIZ]) ! 1147: *dp++ = c; ! 1148: if ((c = *cp)=='\0' || c=='/') ! 1149: break; ! 1150: ++cp; ! 1151: } ! 1152: while (dp < &db[DIRSIZ]) ! 1153: *dp++ = 0; ! 1154: } ! 1155: if ((dlp = findnode(ino)) == NULL) ! 1156: return (0); ! 1157: seek = dlp->dl_seek; ! 1158: for (;;) { ! 1159: if (seek-dlp->dl_seek >= dlp->dl_size) ! 1160: return (0); ! 1161: fseek(tfp, seek, 0); ! 1162: fread(&dirbuf, sizeof(dirbuf), 1, tfp); ! 1163: if (ferror(tfp)) ! 1164: message(1, "temporary file read error"); ! 1165: canino(dirbuf.d_ino); ! 1166: ino = dirbuf.d_ino; ! 1167: if (ino!=0 && strncmp(db, dirbuf.d_name, DIRSIZ)==0) ! 1168: break; ! 1169: seek += sizeof(struct direct); ! 1170: } ! 1171: } ! 1172: } ! 1173: ! 1174: /* ! 1175: * Look for a directory inode ! 1176: * in the dlist. ! 1177: */ ! 1178: struct dlist * ! 1179: findnode(ino) ! 1180: register ino_t ino; ! 1181: { ! 1182: register struct dlist *dlp; ! 1183: ! 1184: dlp = dlist; ! 1185: while (dlp != NULL) { ! 1186: if (dlp->dl_ino == ino) ! 1187: break; ! 1188: dlp = dlp->dl_dlp; ! 1189: } ! 1190: return (dlp); ! 1191: } ! 1192: ! 1193: /* ! 1194: * Usage message. ! 1195: */ ! 1196: usage() ! 1197: { ! 1198: fprintf(stderr, "Usage: restor key [args]\n"); ! 1199: delexit(1); ! 1200: } ! 1201: ! 1202: /* ! 1203: * Message output. ! 1204: */ ! 1205: message(quit, a) ! 1206: { ! 1207: fprintf(stderr, "restor: %r\n", &a); ! 1208: if (quit) ! 1209: delexit(1); ! 1210: } ! 1211: ! 1212: /* ! 1213: * Cleanup function. ! 1214: * Called from the interrupt signal. ! 1215: */ ! 1216: cleanup() ! 1217: { ! 1218: delexit(1); ! 1219: } ! 1220: ! 1221: /* ! 1222: * Exit. ! 1223: * Delete the temp file, if there. ! 1224: */ ! 1225: delexit(s) ! 1226: { ! 1227: if (tfp != NULL) ! 1228: unlink(tfn); ! 1229: exit(s); ! 1230: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.