![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to unmkfs.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 / etc|
Return to unmkfs.c CVS log | Up to [MW Coherent from dump] / coherent / d / etc |
1.1 ! root 1: /* ! 2: * $Header: /usr.src/local/unmkfs.c,v 1.4 90/07/06 11:43:38 root Exp $ ! 3: * $Log: /usr.src/local/unmkfs.c,v $ ! 4: * Revision 1.4 90/07/06 11:43:38 root ! 5: * steve 7/6/90 ! 6: * Changed usage to ! 7: * /etc/unmkfs [ -prefix ] directory nblocks [ file ] ! 8: * Corrected bug with 14-character filenames, which caused garbage in ! 9: * some lines (because of missing NUL terminator). Changed error messages. ! 10: * Added forward declarations of all functions. ! 11: * This corresponds to V3.0.1 object. ! 12: * ,. ! 13: * ! 14: * Revision 1.3 89/02/24 12:44:05 bin ! 15: * Defined realloc to remove integer pointer pun message. ! 16: * ! 17: * Revision 1.2 89/02/24 12:40:52 bin ! 18: * Change to generate file names for multiple prototypes based on ! 19: * a command-line supplied prefix. ! 20: * ! 21: * Revision 1.1 89/02/24 12:32:32 wgl ! 22: * Initial revision ! 23: * ! 24: */ ! 25: static char *revision = "$Revision 1.1 $"; ! 26: static char *header = ! 27: "$Header: /usr.src/local/unmkfs.c,v 1.4 90/07/06 11:43:38 root Exp $"; ! 28: ! 29: /* ! 30: * Given a directory tree root and a filesystem size, ! 31: * write the fewest mkfs proto files necessary to ! 32: * copy the directory tree onto floppies. ! 33: * Preserve the ownerships, modes, dates, links, and order of links ! 34: * within a directory. ! 35: * Make each fragment root based so that a series of ! 36: * mount /dev/fd0 /f0; cpdir /f0 destination; umount /dev/fd0 ! 37: * can be used to reinstall the original directory. ! 38: * ! 39: * The algorithm for partitioning is empirical and may not work very ! 40: * well for directories other than the pc coherent distribution. ! 41: * Some degree of interaction is probably desirable for getting ! 42: * reasonable partitioning of arbitrary directory trees. ! 43: * ! 44: * Overview: ! 45: * After minimal checks for necessary conditions, ! 46: * Read the source directory tree into a memory ! 47: * resident pseudo file system in which MINODE inumbers ! 48: * identify unique files and replace dp->d_ino in the ! 49: * directories. ! 50: * While the original root directory is not flagged I_DONE, ! 51: * copy those parts of the tree that are not flagged I_DONE. ! 52: * While the copy is too big for the floppy partition ! 53: * prune the copy. ! 54: * For each pruned copy produced, write the mkfs proto. ! 55: * ! 56: * -- rec 26.VI.84 -- invent cpfrag. ! 57: * -- rec 12.IX.84 -- reconstruct cpfrag -> unmkfs. ! 58: * -- norm 04.I.85 -- fix misc. bugs for z8000 ! 59: */ ! 60: #include <stdio.h> ! 61: #include <sys/dir.h> ! 62: #include <assert.h> ! 63: #include <sys/const.h> ! 64: #include <sys/types.h> ! 65: #include <sys/stat.h> ! 66: #include <sys/filsys.h> ! 67: #include <sys/ino.h> ! 68: ! 69: extern char *realloc(); ! 70: extern char edata[]; ! 71: ! 72: #define USAGE "Usage: /etc/unmkfs [ -prefix ] directory nblocks [ file ]\n" ! 73: #define IHASH 128 ! 74: #define MAXFNAME 512 ! 75: #define NDISK 32 ! 76: ! 77: typedef struct MINODE { ! 78: struct MINODE *i_link1; /* dev x ino hash linkage */ ! 79: struct MINODE *i_link2; /* my inumbering hash linkage */ ! 80: char *i_linkname; /* Name of first instance of file in copy */ ! 81: int i_mino; /* My inumber */ ! 82: int i_flag; /* Miscellaneous flags */ ! 83: int i_blks; /* Cumulative block size, includes indirects */ ! 84: int i_inos; /* Cumulative inodes used */ ! 85: int i_size; /* Total data, indir, and inode blocks */ ! 86: int i_isdir; /* Simplify many tests */ ! 87: dev_t i_dev; /* Some fields from stat() */ ! 88: ino_t i_ino; ! 89: int i_mode; ! 90: int i_nlink; ! 91: int i_uid; ! 92: int i_gid; ! 93: int i_rdev; ! 94: time_t i_mtime; ! 95: int i_nent; /* Number of directory entries */ ! 96: struct direct i_elem[]; /* Directory entries */ ! 97: } MINODE; ! 98: ! 99: #define I_DONE 1 /* Inode is done */ ! 100: #define I_COUNT 2 /* Inode is counted */ ! 101: #define I_PUT 8 /* Inode size reported */ ! 102: #define I_DONE1 16 /* Inode has been done once, for directories */ ! 103: #define I_PURGE 32 /* Inode should be purged */ ! 104: #define I_KEEP 64 /* Keep entire subdirectory */ ! 105: #define I_CANFIT 128 /* Subdirectory could fit on disk */ ! 106: #define I_ISMADE 256 /* Inode is made, do link */ ! 107: ! 108: MINODE *disks[NDISK]; ! 109: int dsize; ! 110: int dused; ! 111: int vflag = 1; ! 112: int outf = 0; /* Use file outpre.outsuf instead of stdout */ ! 113: int excess; ! 114: int ndisk; ! 115: int myuid; ! 116: int mygid; ! 117: ! 118: char outpre[64]; /* Settable output file prefix */ ! 119: char outsuf[] = ".p??"; /* Suffix for output file name */ ! 120: ! 121: FILE *ofp; ! 122: ! 123: /* Forward. */ ! 124: MINODE *makeroot(); ! 125: void makedir(); ! 126: void printroot(); ! 127: void printdir(); ! 128: void splat(); ! 129: void makedisk(); ! 130: void mkfs(); ! 131: void insdir(); ! 132: void indent(); ! 133: void uflagroot(); ! 134: void uflagdir(); ! 135: void flagroot(); ! 136: void flagdir(); ! 137: void sizeroot(); ! 138: void sizedir(); ! 139: MINODE *cpyroot(); ! 140: MINODE *cpydir(); ! 141: void keepers(); ! 142: MINODE *select(); ! 143: void purge(); ! 144: void donedir(); ! 145: void markdir(); ! 146: int entermi(); ! 147: int duplmi(); ! 148: MINODE *fetchmi(); ! 149: void freemi(); ! 150: long blkuse(); ! 151: char *string(); ! 152: char *myalloc(); ! 153: void usage(); ! 154: void fatal(); ! 155: ! 156: char fname[MAXFNAME]; /* Filename buffer */ ! 157: char fname1[MAXFNAME]; /* Second file name buffer */ ! 158: char cmdbuf[128]; ! 159: struct stat sbuf; /* Stat buffer */ ! 160: struct stat tbuf; /* Time buffer, leave zero for all times */ ! 161: char *argv0; /* For error recovery */ ! 162: ! 163: main(argc, argv) int argc; char *argv[]; ! 164: { ! 165: int i; ! 166: MINODE *rip, *tip, *sip; ! 167: ! 168: argv0 = argv[0]; ! 169: if (argc > 1 && argv[1][0] == '-') { ! 170: strcpy(outpre, &argv[1][1]); ! 171: outf = 1; ! 172: ++argv; ! 173: --argc; ! 174: } ! 175: if (argc < 3 || argc > 4) ! 176: usage(); ! 177: if ((dsize = atoi(argv[2])) <= 0) ! 178: fatal("illegal size \"%s\"", argv[2]); ! 179: if (argc == 4) { ! 180: if (stat(argv[3], &tbuf) < 0) ! 181: fatal("cannot stat \"%s\"", argv[3]); ! 182: } else ! 183: tbuf.st_mtime = 0; /* make time == 0 to get all files */ ! 184: rip = makeroot(argv[1]); ! 185: while ((rip->i_flag & I_DONE) == 0) { ! 186: tip = cpyroot(rip); ! 187: dused = 4; ! 188: keepers(tip); ! 189: excess = tip->i_size + 2 - dsize; ! 190: while (excess > 0) { ! 191: while ((sip = select(tip)) == NULL) { ! 192: excess += 1; ! 193: } ! 194: flagroot(sip, I_PURGE); ! 195: purge(tip); ! 196: sizeroot(tip); ! 197: excess = tip->i_size + 2 - dsize; ! 198: } ! 199: donedir(tip); ! 200: markdir(rip); ! 201: disks[ndisk] = tip; ! 202: ndisk += 1; ! 203: } ! 204: for (i = 0; i < ndisk; i += 1) ! 205: makedisk(i, argv[1]); ! 206: } ! 207: ! 208: /* ! 209: ** Get the MINODE * corresponding to fname, and call ! 210: ** makedir() to build the in-memory tree. Call sizeroot() ! 211: ** return the MINODE corresponding to the root. ! 212: */ ! 213: MINODE * ! 214: makeroot(cp) char *cp; ! 215: { ! 216: MINODE *rip; ! 217: ! 218: if (strlen(cp) >= MAXFNAME) ! 219: fatal("directory path name too long"); ! 220: strcpy(fname, cp); ! 221: if (stat(fname, &sbuf) < 0) ! 222: fatal("cannot stat \"%s\"", fname); ! 223: if ((sbuf.st_mode&S_IFMT) != S_IFDIR) ! 224: fatal("\"%s\" is not a directory"); ! 225: rip = fetchmi(entermi()); ! 226: if (cp[0] == '/' && cp[1] == '\0') ! 227: fname[0] = 0; ! 228: makedir(rip); ! 229: sizeroot(rip); ! 230: return (rip); ! 231: } ! 232: ! 233: /* ! 234: ** Recursively build a tree of MINODE pointers ! 235: ** for the directory ip. ! 236: */ ! 237: void ! 238: makedir(ip) MINODE *ip; ! 239: { ! 240: int fd; ! 241: int i; ! 242: struct direct *dp1, *dp2; ! 243: MINODE *tip; ! 244: char *cp; ! 245: ! 246: cp = fname + strlen(fname); ! 247: if (cp + DIRSIZ + 2 >= fname + MAXFNAME) ! 248: fatal("directory tree too deep"); ! 249: if ((fd = open(fname, 0)) < 0) ! 250: fatal("cannot open \"%s\"", fname); ! 251: i = ip->i_nent * sizeof(struct direct); ! 252: if (read(fd, ip->i_elem, i) != i) ! 253: fatal("%s: read error", fname); ! 254: close(fd); ! 255: *cp = '/'; ! 256: dp1 = dp2 = ip->i_elem; ! 257: for (i = 0; i < ip->i_nent; i += 1) { ! 258: if (dp2->d_name[0] == '.') { ! 259: if (dp2->d_name[1] == 0 ! 260: || (dp2->d_name[1] == '.' && dp2->d_name[2] == 0)) ! 261: dp2->d_ino = 0; ! 262: } ! 263: if (dp2->d_ino != 0) { ! 264: strncpy(cp+1, dp2->d_name, DIRSIZ); ! 265: if (stat(fname, &sbuf) < 0) ! 266: fatal("cannot stat \"%s\"", fname); ! 267: dp2->d_ino = entermi(); ! 268: } ! 269: if (dp2->d_ino != 0) { ! 270: if (dp1 != dp2) ! 271: *dp1 = *dp2; ! 272: dp1 += 1; ! 273: } ! 274: dp2 += 1; ! 275: } ! 276: ip->i_nent = dp1 - ip->i_elem; ! 277: i = sizeof(MINODE) + ip->i_nent * sizeof(struct direct); ! 278: if (realloc(ip, i) != ip) ! 279: fatal("realloc moved block"); ! 280: dp1 = ip->i_elem; ! 281: for (i = 0; i < ip->i_nent; i += 1) { ! 282: tip = fetchmi(dp1->d_ino); ! 283: if (tip->i_isdir) { ! 284: strncpy(cp+1, dp1->d_name, DIRSIZ); ! 285: makedir(tip); ! 286: } ! 287: dp1 += 1; ! 288: } ! 289: *cp = 0; ! 290: } ! 291: ! 292: void ! 293: printroot(cp, rip) char *cp; MINODE *rip; ! 294: { ! 295: uflagroot(rip, I_PUT); ! 296: strcpy(fname, cp); ! 297: splat(rip); ! 298: if (cp[0] == '/' && cp[1] == 0) ! 299: fname[0] = 0; ! 300: printdir(rip); ! 301: } ! 302: ! 303: void ! 304: printdir(ip) MINODE *ip; ! 305: { ! 306: int i; ! 307: MINODE *tip; ! 308: struct direct *dp; ! 309: char *cp; ! 310: ! 311: dp = ip->i_elem; ! 312: cp = fname + strlen(fname); ! 313: *cp = '/'; ! 314: for (i = 0; i < ip->i_nent; i += 1) { ! 315: tip = fetchmi(dp->d_ino); ! 316: strncpy(cp+1, dp->d_name, DIRSIZ); ! 317: splat(tip); ! 318: if (tip->i_isdir) ! 319: printdir(tip); ! 320: dp += 1; ! 321: } ! 322: *cp = 0; ! 323: } ! 324: ! 325: void ! 326: splat(ip) MINODE *ip; ! 327: { ! 328: printf("(%2d,%2d,%4d) ", ! 329: major(ip->i_dev), minor(ip->i_dev), ip->i_ino); ! 330: if ((ip->i_flag & I_PUT) != 0) ! 331: printf("%6d %4d %6d ", 0, 0, 0); ! 332: else ! 333: printf("%6d %4d %6d ", ip->i_size, ip->i_inos, ip->i_blks); ! 334: printf("%s\n", fname); ! 335: ip->i_flag |= I_PUT; ! 336: } ! 337: ! 338: void ! 339: makedisk(n, cp) char *cp; ! 340: { ! 341: MINODE *ip; ! 342: char outfile[72]; ! 343: ! 344: ip = disks[n]; ! 345: fprintf(stderr, "Disk %d: %d inodes, %d data blocks\n", ! 346: n+1, ip->i_inos, ip->i_blks); ! 347: if (outf == 1) { ! 348: outsuf[2] = (n+1)/10 + '0'; ! 349: outsuf[3] = (n+1)%10 + '0'; ! 350: outsuf[4] = '\0'; ! 351: strcpy(outfile, outpre); ! 352: strcat(outfile, outsuf); ! 353: if ((ofp = fopen(outfile, "w")) == NULL) ! 354: fatal("cannot open output file \"%s\"", outfile); ! 355: } else ! 356: ofp = stdout; ! 357: mkfs(ip->i_inos); ! 358: if (cp[0] == '/' && cp[1] == 0) ! 359: fname[0] = 0; ! 360: else ! 361: strcpy(fname, cp); ! 362: fprintf(ofp, "d--%03o %3d %3d\n", ip->i_mode&0777, ip->i_uid, ! 363: ip->i_gid); ! 364: indent(1); ! 365: insdir(ip); ! 366: indent(-1); ! 367: fprintf(ofp, "$\n"); ! 368: } ! 369: ! 370: void ! 371: mkfs(nino) ! 372: { ! 373: fprintf(ofp, "/dev/null xxxxx xxxxx\n"); ! 374: fprintf(ofp, "%d %d 1 1\n", dsize, nino); ! 375: } ! 376: ! 377: void ! 378: insdir(ip) MINODE *ip; ! 379: { ! 380: int i; ! 381: MINODE *tip; ! 382: struct direct *dp; ! 383: char *cp, *cp1, buf[DIRSIZ+1]; ! 384: char dtype; ! 385: ! 386: cp = fname + strlen(fname); ! 387: cp1 = fname1 + strlen(fname1); ! 388: *cp = '/'; ! 389: *cp1 = '/'; ! 390: dp = ip->i_elem; ! 391: for (i = 0; i < ip->i_nent; i += 1) { ! 392: tip = fetchmi(dp->d_ino); ! 393: strncpy(buf, dp->d_name, DIRSIZ); ! 394: buf[DIRSIZ] = '\0'; ! 395: strcpy(cp+1, buf); ! 396: strcpy(cp1+1, buf); ! 397: indent(0); ! 398: fprintf(ofp, "%-14s", buf); ! 399: if (tip->i_flag & I_ISMADE) { ! 400: fprintf(ofp, " l----- 0 0 %s\n", tip->i_linkname); ! 401: dp += 1; ! 402: continue; ! 403: } ! 404: switch (tip->i_mode & S_IFMT) { ! 405: case S_IFDIR: ! 406: dtype = 'd'; ! 407: break; ! 408: case S_IFCHR: ! 409: dtype = 'c'; ! 410: break; ! 411: case S_IFBLK: ! 412: dtype = 'b'; ! 413: break; ! 414: case S_IFREG: ! 415: dtype = '-'; ! 416: break; ! 417: default: ! 418: fatal("%s: bad file type %d", fname, tip->i_mode&S_IFMT); ! 419: } ! 420: ! 421: fprintf(ofp, " %c%c%c%03o %3d %3d", ! 422: dtype, ! 423: (tip->i_mode&ISUID) ? 'u' : '-', ! 424: (tip->i_mode&ISGID) ? 'g' : '-', ! 425: tip->i_mode&0777, ! 426: tip->i_uid, tip->i_gid); ! 427: switch (tip->i_mode & S_IFMT) { ! 428: case S_IFDIR: ! 429: fputc('\n', ofp); ! 430: indent(1); ! 431: insdir(tip); ! 432: indent(-1); ! 433: indent(0); ! 434: fprintf(ofp, "$\n"); ! 435: break; ! 436: case S_IFCHR: ! 437: case S_IFBLK: ! 438: fprintf(ofp, "%3d %3d\n", major(tip->i_rdev), ! 439: minor(tip->i_rdev)); ! 440: break; ! 441: case S_IFREG: ! 442: fprintf(ofp, " %s\n", fname); ! 443: break; ! 444: } ! 445: if (tip->i_nlink > 1) ! 446: tip->i_linkname = string(fname1); ! 447: tip->i_flag |= I_ISMADE; ! 448: dp += 1; ! 449: } ! 450: *cp = 0; ! 451: *cp1 = 0; ! 452: } ! 453: ! 454: void ! 455: indent(n) int n; ! 456: { ! 457: static int indent; ! 458: ! 459: if (n < 0) ! 460: indent -= 1; ! 461: else if (n > 0) ! 462: indent += 1; ! 463: else for (n = indent; --n >= 0; fprintf(ofp, " ")); ! 464: } ! 465: ! 466: void ! 467: uflagroot(rip, flag) MINODE *rip; ! 468: { ! 469: uflagdir(rip, flag); ! 470: rip->i_flag &= ~flag; ! 471: } ! 472: ! 473: /* ! 474: ** Recursively turn off flag in ip and ! 475: ** all directories below ip. ! 476: */ ! 477: void ! 478: uflagdir(ip, flag) MINODE *ip; ! 479: { ! 480: int i; ! 481: MINODE *tip; ! 482: struct direct *dp; ! 483: ! 484: dp = ip->i_elem; ! 485: for (i = 0; i < ip->i_nent; i += 1) { ! 486: tip = fetchmi(dp->d_ino); ! 487: tip->i_flag &= ~flag; ! 488: if (tip->i_isdir) ! 489: uflagdir(tip, flag); ! 490: dp += 1; ! 491: } ! 492: } ! 493: ! 494: void ! 495: flagroot(ip, flag) MINODE *ip; int flag; ! 496: { ! 497: if (ip->i_isdir) ! 498: flagdir(ip, flag); ! 499: ip->i_flag |= flag; ! 500: } ! 501: ! 502: void ! 503: flagdir(ip, flag) MINODE *ip; int flag; ! 504: { ! 505: int i; ! 506: MINODE *tip; ! 507: struct direct *dp; ! 508: ! 509: dp = ip->i_elem; ! 510: for (i = 0; i < ip->i_nent; i += 1) { ! 511: tip = fetchmi(dp->d_ino); ! 512: if (tip->i_isdir) ! 513: flagdir(tip, flag); ! 514: tip->i_flag |= flag; ! 515: dp += 1; ! 516: } ! 517: } ! 518: ! 519: void ! 520: sizeroot(rip) MINODE *rip; ! 521: { ! 522: uflagroot(rip, I_COUNT); ! 523: sizedir(rip); ! 524: /* Add in bad block inode */ ! 525: rip->i_size = rip->i_blks + (++rip->i_inos+INOPB-1) / INOPB; ! 526: } ! 527: ! 528: /* ! 529: ** For subdirectories not flagged I_COUNT, ! 530: ** add the isize and blksize to that of ip. ! 531: */ ! 532: void ! 533: sizedir(ip) MINODE *ip; ! 534: { ! 535: int i; ! 536: MINODE *tip; ! 537: struct direct *dp; ! 538: ! 539: ip->i_blks = 0; ! 540: ip->i_inos = 0; ! 541: dp = ip->i_elem; ! 542: for (i = 0; i < ip->i_nent; i += 1) { ! 543: tip = fetchmi(dp->d_ino); ! 544: if (tip->i_isdir) ! 545: sizedir(tip); ! 546: if ((tip->i_flag&I_COUNT) == 0) { ! 547: ip->i_inos += tip->i_inos; ! 548: ip->i_blks += tip->i_blks; ! 549: tip->i_flag |= I_COUNT; ! 550: } ! 551: dp += 1; ! 552: } ! 553: ip->i_inos += 1; /* For me */ ! 554: ip->i_blks += blkuse((long)(ip->i_nent+2)*sizeof(struct direct)); ! 555: ip->i_size = ip->i_blks + (ip->i_inos+INOPB-1) / INOPB; ! 556: } ! 557: ! 558: MINODE * ! 559: cpyroot(rip) MINODE *rip; ! 560: { ! 561: uflagdir(rip, I_PURGE|I_KEEP); ! 562: rip = cpydir(rip); ! 563: sizeroot(rip); ! 564: return (rip); ! 565: } ! 566: ! 567: MINODE * ! 568: cpydir(ip) MINODE *ip; ! 569: { ! 570: int i; ! 571: MINODE *nip, *tip; ! 572: struct direct *dp1, *dp2; ! 573: ! 574: nip = fetchmi(duplmi(ip)); ! 575: nip->i_nent = 0; ! 576: dp1 = ip->i_elem; ! 577: dp2 = nip->i_elem; ! 578: for (i = 0; i < ip->i_nent; i += 1) { ! 579: tip = fetchmi(dp1->d_ino); ! 580: if ((tip->i_flag&I_DONE) != 0) ! 581: tip = NULL; ! 582: else if (tip->i_isdir) ! 583: tip = cpydir(tip); ! 584: if (tip != NULL) { ! 585: dp2->d_ino = tip->i_mino; ! 586: strncpy(dp2->d_name, dp1->d_name, DIRSIZ); ! 587: nip->i_nent += 1; ! 588: dp2 += 1; ! 589: } ! 590: dp1 += 1; ! 591: } ! 592: if (nip->i_nent < ip->i_nent) { ! 593: i = sizeof(MINODE) + nip->i_nent * sizeof(struct direct); ! 594: if (realloc(nip, i) != nip) ! 595: fatal("realloc moved block"); ! 596: } ! 597: return (nip); ! 598: } ! 599: ! 600: void ! 601: keepers(ip) MINODE *ip; ! 602: { ! 603: int i; ! 604: MINODE *tip; ! 605: struct direct *dp; ! 606: ! 607: dp = ip->i_elem; ! 608: for (i = 0; i < ip->i_nent; i += 1) { ! 609: tip = fetchmi(dp->d_ino); ! 610: if (tip->i_isdir == 0) { ! 611: dp += 1; ! 612: continue; ! 613: } ! 614: if (tip->i_size < dsize - 4) ! 615: tip->i_flag |= I_CANFIT; ! 616: if (dused + tip->i_size < dsize) { ! 617: tip->i_flag |= I_KEEP; ! 618: dused += tip->i_size; ! 619: } ! 620: dp += 1; ! 621: } ! 622: dp = ip->i_elem; ! 623: for (i = 0; i < ip->i_nent; i += 1) { ! 624: tip = fetchmi(dp->d_ino); ! 625: if (tip->i_isdir != 0 ! 626: && (tip->i_flag & (I_CANFIT|I_KEEP)) == 0) ! 627: keepers(tip); ! 628: dp += 1; ! 629: } ! 630: } ! 631: ! 632: MINODE * ! 633: select(ip) MINODE *ip; ! 634: { ! 635: int i; ! 636: MINODE *uip, *lip, *tip; ! 637: struct direct *dp; ! 638: ! 639: uip = lip = NULL; ! 640: dp = ip->i_elem; ! 641: for (i = 0; i < ip->i_nent; i += 1) { ! 642: tip = fetchmi(dp->d_ino); ! 643: if (tip->i_flag & I_KEEP) { ! 644: dp += 1; ! 645: continue; ! 646: } ! 647: if (tip->i_flag & I_CANFIT) ! 648: return (tip); ! 649: if (tip->i_size == excess) ! 650: return (tip); ! 651: else if (tip->i_size > excess) { ! 652: if (uip == NULL || uip->i_size > tip->i_size) ! 653: uip = tip; ! 654: } else { ! 655: if (lip == NULL || lip->i_size < tip->i_size) ! 656: lip = tip; ! 657: } ! 658: dp += 1; ! 659: } ! 660: if (lip != NULL) ! 661: return (lip); ! 662: if (uip->i_isdir) ! 663: return (select(uip)); ! 664: return (uip); ! 665: } ! 666: ! 667: void ! 668: purge(rip) MINODE *rip; ! 669: { ! 670: int i; ! 671: MINODE *tip; ! 672: struct direct *dp1, *dp2; ! 673: ! 674: assert(rip->i_isdir); ! 675: #if I8086 ! 676: assert((char *)&dp2 > edata + 16); ! 677: #endif ! 678: dp1 = dp2 = rip->i_elem; ! 679: for (i = 0; i < rip->i_nent; i += 1) { ! 680: tip = fetchmi(dp1->d_ino); ! 681: if (tip->i_isdir) { ! 682: purge(tip); ! 683: if ((tip->i_flag & I_PURGE) && tip->i_nent == 0) { ! 684: dp1->d_ino = 0; ! 685: freemi(tip->i_mino); ! 686: } ! 687: } else if (tip->i_flag & I_PURGE) ! 688: dp1->d_ino = 0; ! 689: if (dp1->d_ino != 0) { ! 690: if (dp1 != dp2) ! 691: *dp2 = *dp1; ! 692: dp2 += 1; ! 693: } ! 694: dp1 += 1; ! 695: } ! 696: rip->i_nent = dp2 - rip->i_elem; ! 697: } ! 698: ! 699: void ! 700: donedir(ip) ! 701: MINODE *ip; ! 702: { ! 703: int i; ! 704: MINODE *tip; ! 705: struct direct *dp; ! 706: ! 707: ip->i_link1->i_flag |= I_DONE1; ! 708: dp = ip->i_elem; ! 709: for (i = 0; i < ip->i_nent; i += 1) { ! 710: tip = fetchmi(dp->d_ino); ! 711: if (tip->i_isdir) ! 712: donedir(tip); ! 713: else ! 714: tip->i_flag |= I_DONE|I_DONE1; ! 715: dp += 1; ! 716: } ! 717: } ! 718: ! 719: void ! 720: markdir(ip) MINODE *ip; ! 721: { ! 722: int i; ! 723: MINODE *tip; ! 724: struct direct *dp; ! 725: int flag; ! 726: ! 727: if (ip->i_flag & I_DONE) ! 728: return; ! 729: dp = ip->i_elem; ! 730: flag = I_DONE; ! 731: for (i = 0; i < ip->i_nent; i += 1) { ! 732: tip = fetchmi(dp->d_ino); ! 733: if (tip->i_isdir) ! 734: markdir(tip); ! 735: flag &= tip->i_flag; ! 736: dp += 1; ! 737: } ! 738: if ((flag & I_DONE) != 0 && (ip->i_flag & I_DONE1) != 0) ! 739: ip->i_flag |= I_DONE; ! 740: } ! 741: ! 742: MINODE *ihash1[IHASH]; /* dev x ino hash */ ! 743: MINODE *ihash2[IHASH]; /* mino hash */ ! 744: int minumber = 1; ! 745: ! 746: /* ! 747: ** Return the mino in the hash table ihash1 corresponding to ! 748: ** the statbuf. If not found, enter it and return the resulting ! 749: ** entry. ! 750: */ ! 751: int ! 752: entermi() ! 753: { ! 754: MINODE *ip, **ipp; ! 755: int nent; ! 756: ! 757: ipp = &ihash1[sbuf.st_ino % IHASH]; ! 758: while ((ip = *ipp) != NULL) { ! 759: if (ip->i_ino == sbuf.st_ino ! 760: && ip->i_dev == sbuf.st_dev) ! 761: return (ip->i_mino); ! 762: ipp = &ip->i_link1; ! 763: } ! 764: nent = 0; ! 765: if ((sbuf.st_mode&S_IFMT) == S_IFDIR) ! 766: nent = sbuf.st_size / sizeof(struct direct); ! 767: else if (sbuf.st_mtime < tbuf.st_mtime) ! 768: return 0; ! 769: else if (blkuse(sbuf.st_size) > dsize-5) { ! 770: fprintf(stderr, "unmkfs: file %s too large - omitted\n", fname); ! 771: return 0; ! 772: } ! 773: *ipp = ip = myalloc(sizeof(MINODE) + nent * sizeof(struct direct)); ! 774: ip->i_dev = sbuf.st_dev; ! 775: ip->i_ino = sbuf.st_ino; ! 776: ip->i_mode = sbuf.st_mode; ! 777: ip->i_nlink = sbuf.st_nlink; ! 778: ip->i_uid = sbuf.st_uid; ! 779: ip->i_gid = sbuf.st_gid; ! 780: ip->i_rdev = sbuf.st_rdev; ! 781: ip->i_mtime = sbuf.st_mtime; ! 782: ip->i_blks = blkuse(sbuf.st_size); ! 783: ip->i_inos = 1; ! 784: ip->i_size = ip->i_blks; ! 785: ip->i_nent = nent; ! 786: ip->i_mino = minumber++; ! 787: ip->i_isdir = (nent != 0); ! 788: ipp = &ihash2[ip->i_mino % IHASH]; ! 789: ip->i_link2 = *ipp; ! 790: *ipp = ip; ! 791: return (ip->i_mino); ! 792: } ! 793: ! 794: int ! 795: duplmi(ip) MINODE *ip; ! 796: { ! 797: MINODE *nip, **ipp; ! 798: ! 799: nip = myalloc(sizeof(MINODE) + ip->i_nent * sizeof(struct direct)); ! 800: nip->i_dev = ip->i_dev; ! 801: nip->i_ino = ip->i_ino; ! 802: nip->i_mode = ip->i_mode; ! 803: nip->i_nlink = ip->i_nlink; ! 804: nip->i_uid = ip->i_uid; ! 805: nip->i_gid = ip->i_gid; ! 806: nip->i_rdev = ip->i_rdev; ! 807: nip->i_blks = ip->i_blks; ! 808: nip->i_inos = ip->i_inos; ! 809: nip->i_size = ip->i_size; ! 810: nip->i_nent = ip->i_nent; ! 811: nip->i_mino = minumber++; ! 812: nip->i_isdir = ip->i_isdir; ! 813: ipp = &ihash2[nip->i_mino % IHASH]; ! 814: nip->i_link2 = *ipp; ! 815: *ipp = nip; ! 816: nip->i_link1 = ip; ! 817: return (nip->i_mino); ! 818: } ! 819: ! 820: /* ! 821: ** Find the entry i ihash2 corresponding to mino. ! 822: ** Die with message if not there. ! 823: */ ! 824: MINODE * ! 825: fetchmi(mino) int mino; ! 826: { ! 827: MINODE *ip, **ipp; ! 828: ! 829: ipp = &ihash2[mino % IHASH]; ! 830: while ((ip = *ipp) != NULL) ! 831: if (ip->i_mino == mino) ! 832: return (ip); ! 833: else ! 834: ipp = &ip->i_link2; ! 835: fatal("nonexistent internal inumber %d", mino); ! 836: } ! 837: ! 838: void ! 839: freemi(mino) int mino; ! 840: { ! 841: MINODE *ip, **ipp; ! 842: ! 843: ipp = &ihash2[mino % IHASH]; ! 844: while ((ip = *ipp) != NULL) ! 845: if (ip->i_mino == mino) { ! 846: *ipp = ip->i_link2; ! 847: free(ip); ! 848: return; ! 849: } else ! 850: ipp = &ip->i_link2; ! 851: fatal("nonexistent internal inumber %d", mino); ! 852: } ! 853: ! 854: /* ! 855: * A corrected disk usage computation ! 856: * for retrofit into /usr/src/cmd/du.c, /usr/src/cmd/ls.c/prsize(), ! 857: * and /usr/src/cmd/quot.c since they are all wrong. ! 858: * ! 859: * And this is not quite right either since it doesn't deal with sparse ! 860: * blocks. ! 861: */ ! 862: long ! 863: blkuse(nb) long nb; ! 864: { ! 865: #undef NBN ! 866: #define NBN 128L ! 867: #define nindir(x) (((x)+NBN-1)/NBN) ! 868: #define nblock(x) (((x)+BSIZE-1)/BSIZE) ! 869: #define min(x, y) ((x)<(y) ? (x) : (y)) ! 870: long bu, ndir, nidir, niidir; ! 871: ! 872: nb = nblock(nb); ! 873: ndir = min(nb, ND); ! 874: nb -= ndir; ! 875: bu = ndir; ! 876: if (nb) { ! 877: nidir = min(nb, NBN); ! 878: nb -= nidir; ! 879: bu += nidir + 1; ! 880: if (nb) { ! 881: niidir = min(nb, NBN*NBN); ! 882: nb -= niidir; ! 883: bu += niidir + 1 + nindir(niidir); ! 884: if (nb) ! 885: bu += nb + 1 + nindir(nindir(nb)) + nindir(nb); ! 886: } ! 887: } ! 888: return (bu); ! 889: } ! 890: ! 891: char * ! 892: string(cp) char *cp; ! 893: { ! 894: char *sp; ! 895: ! 896: sp = myalloc(strlen(cp)+1); ! 897: strcpy(sp, cp); ! 898: return (sp); ! 899: } ! 900: ! 901: char * ! 902: myalloc(nb) int nb; ! 903: { ! 904: char *p; ! 905: ! 906: if ((p = malloc(nb)) == NULL) ! 907: fatal("out of space"); ! 908: while (--nb >= 0) ! 909: p[nb] = 0; ! 910: return (p); ! 911: } ! 912: ! 913: void ! 914: usage() ! 915: { ! 916: fprintf(stderr, USAGE); ! 917: exit(1); ! 918: } ! 919: ! 920: void ! 921: fatal(args) char *args; ! 922: { ! 923: fprintf(stderr, "%s: %r\n", argv0, &args); ! 924: exit(1); ! 925: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.