![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dir.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / etc / fsck|
Return to dir.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / etc / fsck |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: static char sccsid[] = "@(#)dir.c 5.4 (Berkeley) 5/7/88"; ! 9: #endif not lint ! 10: ! 11: #include <sys/param.h> ! 12: #include <sys/inode.h> ! 13: #include <sys/fs.h> ! 14: #define KERNEL ! 15: #include <sys/dir.h> ! 16: #undef KERNEL ! 17: #include "fsck.h" ! 18: ! 19: #define MINDIRSIZE (sizeof (struct dirtemplate)) ! 20: ! 21: char *endpathname = &pathname[BUFSIZ - 2]; ! 22: char *lfname = "lost+found"; ! 23: struct dirtemplate emptydir = { 0, DIRBLKSIZ }; ! 24: struct dirtemplate dirhead = { 0, 12, 1, ".", 0, DIRBLKSIZ - 12, 2, ".." }; ! 25: ! 26: DIRECT *fsck_readdir(); ! 27: BUFAREA *getdirblk(); ! 28: ! 29: descend(parentino, inumber) ! 30: struct inodesc *parentino; ! 31: ino_t inumber; ! 32: { ! 33: register DINODE *dp; ! 34: struct inodesc curino; ! 35: ! 36: bzero((char *)&curino, sizeof(struct inodesc)); ! 37: if (statemap[inumber] != DSTATE) ! 38: errexit("BAD INODE %d TO DESCEND", statemap[inumber]); ! 39: statemap[inumber] = DFOUND; ! 40: dp = ginode(inumber); ! 41: if (dp->di_size == 0) { ! 42: direrr(inumber, "ZERO LENGTH DIRECTORY"); ! 43: if (reply("REMOVE") == 1) ! 44: statemap[inumber] = DCLEAR; ! 45: return; ! 46: } ! 47: if (dp->di_size < MINDIRSIZE) { ! 48: direrr(inumber, "DIRECTORY TOO SHORT"); ! 49: dp->di_size = MINDIRSIZE; ! 50: if (reply("FIX") == 1) ! 51: inodirty(); ! 52: } ! 53: if ((dp->di_size & (DIRBLKSIZ - 1)) != 0) { ! 54: pwarn("DIRECTORY %s: LENGTH %d NOT MULTIPLE OF %d", ! 55: pathname, dp->di_size, DIRBLKSIZ); ! 56: dp->di_size = roundup(dp->di_size, DIRBLKSIZ); ! 57: if (preen) ! 58: printf(" (ADJUSTED)\n"); ! 59: if (preen || reply("ADJUST") == 1) ! 60: inodirty(); ! 61: } ! 62: curino.id_type = DATA; ! 63: curino.id_func = parentino->id_func; ! 64: curino.id_parent = parentino->id_number; ! 65: curino.id_number = inumber; ! 66: (void)ckinode(dp, &curino); ! 67: if (curino.id_entryno < 2) { ! 68: direrr(inumber, "NULL DIRECTORY"); ! 69: if (reply("REMOVE") == 1) ! 70: statemap[inumber] = DCLEAR; ! 71: } ! 72: } ! 73: ! 74: dirscan(idesc) ! 75: register struct inodesc *idesc; ! 76: { ! 77: register DIRECT *dp; ! 78: register BUFAREA *bp; ! 79: int dsize, n; ! 80: long blksiz; ! 81: char dbuf[DIRBLKSIZ]; ! 82: ! 83: if (idesc->id_type != DATA) ! 84: errexit("wrong type to dirscan %d\n", idesc->id_type); ! 85: if (idesc->id_entryno == 0 && ! 86: (idesc->id_filesize & (DIRBLKSIZ - 1)) != 0) ! 87: idesc->id_filesize = roundup(idesc->id_filesize, DIRBLKSIZ); ! 88: blksiz = idesc->id_numfrags * sblock.fs_fsize; ! 89: if (outrange(idesc->id_blkno, idesc->id_numfrags)) { ! 90: idesc->id_filesize -= blksiz; ! 91: return (SKIP); ! 92: } ! 93: idesc->id_loc = 0; ! 94: for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) { ! 95: dsize = dp->d_reclen; ! 96: bcopy((char *)dp, dbuf, dsize); ! 97: idesc->id_dirp = (DIRECT *)dbuf; ! 98: if ((n = (*idesc->id_func)(idesc)) & ALTERED) { ! 99: bp = getdirblk(idesc->id_blkno, blksiz); ! 100: bcopy(dbuf, (char *)dp, dsize); ! 101: dirty(bp); ! 102: sbdirty(); ! 103: } ! 104: if (n & STOP) ! 105: return (n); ! 106: } ! 107: return (idesc->id_filesize > 0 ? KEEPON : STOP); ! 108: } ! 109: ! 110: /* ! 111: * get next entry in a directory. ! 112: */ ! 113: DIRECT * ! 114: fsck_readdir(idesc) ! 115: register struct inodesc *idesc; ! 116: { ! 117: register DIRECT *dp, *ndp; ! 118: register BUFAREA *bp; ! 119: long size, blksiz; ! 120: ! 121: blksiz = idesc->id_numfrags * sblock.fs_fsize; ! 122: bp = getdirblk(idesc->id_blkno, blksiz); ! 123: if (idesc->id_loc % DIRBLKSIZ == 0 && idesc->id_filesize > 0 && ! 124: idesc->id_loc < blksiz) { ! 125: dp = (DIRECT *)(bp->b_un.b_buf + idesc->id_loc); ! 126: if (dircheck(idesc, dp)) ! 127: goto dpok; ! 128: idesc->id_loc += DIRBLKSIZ; ! 129: idesc->id_filesize -= DIRBLKSIZ; ! 130: dp->d_reclen = DIRBLKSIZ; ! 131: dp->d_ino = 0; ! 132: dp->d_namlen = 0; ! 133: dp->d_name[0] = '\0'; ! 134: if (dofix(idesc, "DIRECTORY CORRUPTED")) ! 135: dirty(bp); ! 136: return (dp); ! 137: } ! 138: dpok: ! 139: if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz) ! 140: return NULL; ! 141: dp = (DIRECT *)(bp->b_un.b_buf + idesc->id_loc); ! 142: idesc->id_loc += dp->d_reclen; ! 143: idesc->id_filesize -= dp->d_reclen; ! 144: if ((idesc->id_loc % DIRBLKSIZ) == 0) ! 145: return (dp); ! 146: ndp = (DIRECT *)(bp->b_un.b_buf + idesc->id_loc); ! 147: if (idesc->id_loc < blksiz && idesc->id_filesize > 0 && ! 148: dircheck(idesc, ndp) == 0) { ! 149: size = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ); ! 150: dp->d_reclen += size; ! 151: idesc->id_loc += size; ! 152: idesc->id_filesize -= size; ! 153: if (dofix(idesc, "DIRECTORY CORRUPTED")) ! 154: dirty(bp); ! 155: } ! 156: return (dp); ! 157: } ! 158: ! 159: /* ! 160: * Verify that a directory entry is valid. ! 161: * This is a superset of the checks made in the kernel. ! 162: */ ! 163: dircheck(idesc, dp) ! 164: struct inodesc *idesc; ! 165: register DIRECT *dp; ! 166: { ! 167: register int size; ! 168: register char *cp; ! 169: int spaceleft; ! 170: ! 171: size = DIRSIZ(dp); ! 172: spaceleft = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ); ! 173: if (dp->d_ino < imax && ! 174: dp->d_reclen != 0 && ! 175: dp->d_reclen <= spaceleft && ! 176: (dp->d_reclen & 0x3) == 0 && ! 177: dp->d_reclen >= size && ! 178: idesc->id_filesize >= size && ! 179: dp->d_namlen <= MAXNAMLEN) { ! 180: if (dp->d_ino == 0) ! 181: return (1); ! 182: for (cp = dp->d_name, size = 0; size < dp->d_namlen; size++) ! 183: if (*cp == 0 || (*cp++ & 0200)) ! 184: return (0); ! 185: if (*cp == 0) ! 186: return (1); ! 187: } ! 188: return (0); ! 189: } ! 190: ! 191: direrr(ino, s) ! 192: ino_t ino; ! 193: char *s; ! 194: { ! 195: register DINODE *dp; ! 196: ! 197: pwarn("%s ", s); ! 198: pinode(ino); ! 199: printf("\n"); ! 200: if (ino < ROOTINO || ino > imax) { ! 201: pfatal("NAME=%s\n", pathname); ! 202: return; ! 203: } ! 204: dp = ginode(ino); ! 205: if (ftypeok(dp)) ! 206: pfatal("%s=%s\n", DIRCT(dp) ? "DIR" : "FILE", pathname); ! 207: else ! 208: pfatal("NAME=%s\n", pathname); ! 209: } ! 210: ! 211: adjust(idesc, lcnt) ! 212: register struct inodesc *idesc; ! 213: short lcnt; ! 214: { ! 215: register DINODE *dp; ! 216: ! 217: dp = ginode(idesc->id_number); ! 218: if (dp->di_nlink == lcnt) { ! 219: if (linkup(idesc->id_number, (ino_t)0) == 0) ! 220: clri(idesc, "UNREF", 0); ! 221: } else { ! 222: pwarn("LINK COUNT %s", (lfdir == idesc->id_number) ? lfname : ! 223: (DIRCT(dp) ? "DIR" : "FILE")); ! 224: pinode(idesc->id_number); ! 225: printf(" COUNT %d SHOULD BE %d", ! 226: dp->di_nlink, dp->di_nlink-lcnt); ! 227: if (preen) { ! 228: if (lcnt < 0) { ! 229: printf("\n"); ! 230: pfatal("LINK COUNT INCREASING"); ! 231: } ! 232: printf(" (ADJUSTED)\n"); ! 233: } ! 234: if (preen || reply("ADJUST") == 1) { ! 235: dp->di_nlink -= lcnt; ! 236: inodirty(); ! 237: } ! 238: } ! 239: } ! 240: ! 241: mkentry(idesc) ! 242: struct inodesc *idesc; ! 243: { ! 244: register DIRECT *dirp = idesc->id_dirp; ! 245: DIRECT newent; ! 246: int newlen, oldlen; ! 247: ! 248: newent.d_namlen = 11; ! 249: newlen = DIRSIZ(&newent); ! 250: if (dirp->d_ino != 0) ! 251: oldlen = DIRSIZ(dirp); ! 252: else ! 253: oldlen = 0; ! 254: if (dirp->d_reclen - oldlen < newlen) ! 255: return (KEEPON); ! 256: newent.d_reclen = dirp->d_reclen - oldlen; ! 257: dirp->d_reclen = oldlen; ! 258: dirp = (struct direct *)(((char *)dirp) + oldlen); ! 259: dirp->d_ino = idesc->id_parent; /* ino to be entered is in id_parent */ ! 260: dirp->d_reclen = newent.d_reclen; ! 261: dirp->d_namlen = strlen(idesc->id_name); ! 262: bcopy(idesc->id_name, dirp->d_name, dirp->d_namlen + 1); ! 263: return (ALTERED|STOP); ! 264: } ! 265: ! 266: chgino(idesc) ! 267: struct inodesc *idesc; ! 268: { ! 269: register DIRECT *dirp = idesc->id_dirp; ! 270: ! 271: if (bcmp(dirp->d_name, idesc->id_name, dirp->d_namlen + 1)) ! 272: return (KEEPON); ! 273: dirp->d_ino = idesc->id_parent;; ! 274: return (ALTERED|STOP); ! 275: } ! 276: ! 277: linkup(orphan, pdir) ! 278: ino_t orphan; ! 279: ino_t pdir; ! 280: { ! 281: register DINODE *dp; ! 282: int lostdir, len; ! 283: ino_t oldlfdir; ! 284: struct inodesc idesc; ! 285: char tempname[BUFSIZ]; ! 286: extern int pass4check(); ! 287: ! 288: bzero((char *)&idesc, sizeof(struct inodesc)); ! 289: dp = ginode(orphan); ! 290: lostdir = DIRCT(dp); ! 291: pwarn("UNREF %s ", lostdir ? "DIR" : "FILE"); ! 292: pinode(orphan); ! 293: if (preen && dp->di_size == 0) ! 294: return (0); ! 295: if (preen) ! 296: printf(" (RECONNECTED)\n"); ! 297: else ! 298: if (reply("RECONNECT") == 0) ! 299: return (0); ! 300: pathp = pathname; ! 301: *pathp++ = '/'; ! 302: *pathp = '\0'; ! 303: if (lfdir == 0) { ! 304: dp = ginode(ROOTINO); ! 305: idesc.id_name = lfname; ! 306: idesc.id_type = DATA; ! 307: idesc.id_func = findino; ! 308: idesc.id_number = ROOTINO; ! 309: if ((ckinode(dp, &idesc) & FOUND) != 0) { ! 310: lfdir = idesc.id_parent; ! 311: } else { ! 312: pwarn("NO lost+found DIRECTORY"); ! 313: if (preen || reply("CREATE")) { ! 314: lfdir = allocdir(ROOTINO, 0); ! 315: if (lfdir != 0) { ! 316: if (makeentry(ROOTINO, lfdir, lfname) != 0) { ! 317: if (preen) ! 318: printf(" (CREATED)\n"); ! 319: } else { ! 320: freedir(lfdir, ROOTINO); ! 321: lfdir = 0; ! 322: if (preen) ! 323: printf("\n"); ! 324: } ! 325: } ! 326: } ! 327: } ! 328: if (lfdir == 0) { ! 329: pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY"); ! 330: printf("\n\n"); ! 331: return (0); ! 332: } ! 333: } ! 334: dp = ginode(lfdir); ! 335: if (!DIRCT(dp)) { ! 336: pfatal("lost+found IS NOT A DIRECTORY"); ! 337: if (reply("REALLOCATE") == 0) ! 338: return (0); ! 339: oldlfdir = lfdir; ! 340: if ((lfdir = allocdir(ROOTINO, 0)) == 0) { ! 341: pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n"); ! 342: return (0); ! 343: } ! 344: idesc.id_type = DATA; ! 345: idesc.id_func = chgino; ! 346: idesc.id_number = ROOTINO; ! 347: idesc.id_parent = lfdir; /* new inumber for lost+found */ ! 348: idesc.id_name = lfname; ! 349: if ((ckinode(ginode(ROOTINO), &idesc) & ALTERED) == 0) { ! 350: pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n"); ! 351: return (0); ! 352: } ! 353: inodirty(); ! 354: idesc.id_type = ADDR; ! 355: idesc.id_func = pass4check; ! 356: idesc.id_number = oldlfdir; ! 357: adjust(&idesc, lncntp[oldlfdir] + 1); ! 358: lncntp[oldlfdir] = 0; ! 359: dp = ginode(lfdir); ! 360: } ! 361: if (statemap[lfdir] != DFOUND) { ! 362: pfatal("SORRY. NO lost+found DIRECTORY\n\n"); ! 363: return (0); ! 364: } ! 365: len = strlen(lfname); ! 366: bcopy(lfname, pathp, len + 1); ! 367: pathp += len; ! 368: len = lftempname(tempname, orphan); ! 369: if (makeentry(lfdir, orphan, tempname) == 0) { ! 370: pfatal("SORRY. NO SPACE IN lost+found DIRECTORY"); ! 371: printf("\n\n"); ! 372: return (0); ! 373: } ! 374: lncntp[orphan]--; ! 375: *pathp++ = '/'; ! 376: bcopy(tempname, pathp, len + 1); ! 377: pathp += len; ! 378: if (lostdir) { ! 379: dp = ginode(orphan); ! 380: idesc.id_type = DATA; ! 381: idesc.id_func = chgino; ! 382: idesc.id_number = orphan; ! 383: idesc.id_fix = DONTKNOW; ! 384: idesc.id_name = ".."; ! 385: idesc.id_parent = lfdir; /* new value for ".." */ ! 386: (void)ckinode(dp, &idesc); ! 387: dp = ginode(lfdir); ! 388: dp->di_nlink++; ! 389: inodirty(); ! 390: lncntp[lfdir]++; ! 391: pwarn("DIR I=%u CONNECTED. ", orphan); ! 392: printf("PARENT WAS I=%u\n", pdir); ! 393: if (preen == 0) ! 394: printf("\n"); ! 395: } ! 396: return (1); ! 397: } ! 398: ! 399: /* ! 400: * make an entry in a directory ! 401: */ ! 402: makeentry(parent, ino, name) ! 403: ino_t parent, ino; ! 404: char *name; ! 405: { ! 406: DINODE *dp; ! 407: struct inodesc idesc; ! 408: ! 409: if (parent < ROOTINO || parent >= imax || ino < ROOTINO || ino >= imax) ! 410: return (0); ! 411: bzero(&idesc, sizeof(struct inodesc)); ! 412: idesc.id_type = DATA; ! 413: idesc.id_func = mkentry; ! 414: idesc.id_number = parent; ! 415: idesc.id_parent = ino; /* this is the inode to enter */ ! 416: idesc.id_fix = DONTKNOW; ! 417: idesc.id_name = name; ! 418: dp = ginode(parent); ! 419: if (dp->di_size % DIRBLKSIZ) { ! 420: dp->di_size = roundup(dp->di_size, DIRBLKSIZ); ! 421: inodirty(); ! 422: } ! 423: if ((ckinode(dp, &idesc) & ALTERED) != 0) ! 424: return (1); ! 425: if (expanddir(dp) == 0) ! 426: return (0); ! 427: return (ckinode(dp, &idesc) & ALTERED); ! 428: } ! 429: ! 430: /* ! 431: * Attempt to expand the size of a directory ! 432: */ ! 433: expanddir(dp) ! 434: register DINODE *dp; ! 435: { ! 436: daddr_t lastbn, newblk; ! 437: register BUFAREA *bp; ! 438: char *cp, firstblk[DIRBLKSIZ]; ! 439: ! 440: lastbn = lblkno(&sblock, dp->di_size); ! 441: if (lastbn >= NDADDR - 1) ! 442: return (0); ! 443: if ((newblk = allocblk(sblock.fs_frag)) == 0) ! 444: return (0); ! 445: dp->di_db[lastbn + 1] = dp->di_db[lastbn]; ! 446: dp->di_db[lastbn] = newblk; ! 447: dp->di_size += sblock.fs_bsize; ! 448: dp->di_blocks += btodb(sblock.fs_bsize); ! 449: bp = getdirblk(dp->di_db[lastbn + 1], ! 450: dblksize(&sblock, dp, lastbn + 1)); ! 451: if (bp->b_errs != NULL) ! 452: goto bad; ! 453: bcopy(bp->b_un.b_buf, firstblk, DIRBLKSIZ); ! 454: bp = getdirblk(newblk, sblock.fs_bsize); ! 455: if (bp->b_errs != NULL) ! 456: goto bad; ! 457: bcopy(firstblk, bp->b_un.b_buf, DIRBLKSIZ); ! 458: for (cp = &bp->b_un.b_buf[DIRBLKSIZ]; ! 459: cp < &bp->b_un.b_buf[sblock.fs_bsize]; ! 460: cp += DIRBLKSIZ) ! 461: bcopy((char *)&emptydir, cp, sizeof emptydir); ! 462: dirty(bp); ! 463: bp = getdirblk(dp->di_db[lastbn + 1], ! 464: dblksize(&sblock, dp, lastbn + 1)); ! 465: if (bp->b_errs != NULL) ! 466: goto bad; ! 467: bcopy((char *)&emptydir, bp->b_un.b_buf, sizeof emptydir); ! 468: pwarn("NO SPACE LEFT IN %s", pathname); ! 469: if (preen) ! 470: printf(" (EXPANDED)\n"); ! 471: else if (reply("EXPAND") == 0) ! 472: goto bad; ! 473: dirty(bp); ! 474: inodirty(); ! 475: return (1); ! 476: bad: ! 477: dp->di_db[lastbn] = dp->di_db[lastbn + 1]; ! 478: dp->di_db[lastbn + 1] = 0; ! 479: dp->di_size -= sblock.fs_bsize; ! 480: dp->di_blocks -= btodb(sblock.fs_bsize); ! 481: freeblk(newblk, sblock.fs_frag); ! 482: return (0); ! 483: } ! 484: ! 485: /* ! 486: * allocate a new directory ! 487: */ ! 488: allocdir(parent, request) ! 489: ino_t parent, request; ! 490: { ! 491: ino_t ino; ! 492: char *cp; ! 493: DINODE *dp; ! 494: register BUFAREA *bp; ! 495: ! 496: ino = allocino(request, IFDIR|0755); ! 497: dirhead.dot_ino = ino; ! 498: dirhead.dotdot_ino = parent; ! 499: dp = ginode(ino); ! 500: bp = getdirblk(dp->di_db[0], sblock.fs_fsize); ! 501: if (bp->b_errs != NULL) { ! 502: freeino(ino); ! 503: return (0); ! 504: } ! 505: bcopy((char *)&dirhead, bp->b_un.b_buf, sizeof dirhead); ! 506: for (cp = &bp->b_un.b_buf[DIRBLKSIZ]; ! 507: cp < &bp->b_un.b_buf[sblock.fs_fsize]; ! 508: cp += DIRBLKSIZ) ! 509: bcopy((char *)&emptydir, cp, sizeof emptydir); ! 510: dirty(bp); ! 511: dp->di_nlink = 2; ! 512: inodirty(); ! 513: if (ino == ROOTINO) { ! 514: lncntp[ino] = dp->di_nlink; ! 515: return(ino); ! 516: } ! 517: if (statemap[parent] != DSTATE && statemap[parent] != DFOUND) { ! 518: freeino(ino); ! 519: return (0); ! 520: } ! 521: statemap[ino] = statemap[parent]; ! 522: if (statemap[ino] == DSTATE) { ! 523: lncntp[ino] = dp->di_nlink; ! 524: lncntp[parent]++; ! 525: } ! 526: dp = ginode(parent); ! 527: dp->di_nlink++; ! 528: inodirty(); ! 529: return (ino); ! 530: } ! 531: ! 532: /* ! 533: * free a directory inode ! 534: */ ! 535: freedir(ino, parent) ! 536: ino_t ino, parent; ! 537: { ! 538: DINODE *dp; ! 539: ! 540: if (ino != parent) { ! 541: dp = ginode(parent); ! 542: dp->di_nlink--; ! 543: inodirty(); ! 544: } ! 545: freeino(ino); ! 546: } ! 547: ! 548: /* ! 549: * generate a temporary name for the lost+found directory. ! 550: */ ! 551: lftempname(bufp, ino) ! 552: char *bufp; ! 553: ino_t ino; ! 554: { ! 555: register ino_t in; ! 556: register char *cp; ! 557: int namlen; ! 558: ! 559: cp = bufp + 2; ! 560: for (in = imax; in > 0; in /= 10) ! 561: cp++; ! 562: *--cp = 0; ! 563: namlen = cp - bufp; ! 564: in = ino; ! 565: while (cp > bufp) { ! 566: *--cp = (in % 10) + '0'; ! 567: in /= 10; ! 568: } ! 569: *cp = '#'; ! 570: return (namlen); ! 571: } ! 572: ! 573: /* ! 574: * Get a directory block. ! 575: * Insure that it is held until another is requested. ! 576: */ ! 577: BUFAREA * ! 578: getdirblk(blkno, size) ! 579: daddr_t blkno; ! 580: long size; ! 581: { ! 582: static BUFAREA *pbp = 0; ! 583: ! 584: if (pbp != 0) ! 585: pbp->b_flags &= ~B_INUSE; ! 586: pbp = getdatablk(blkno, size); ! 587: return (pbp); ! 588: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.