![[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] / 43BSD / etc / fsck|
Return to dir.c CVS log | Up to [CSRG BSD Unix] / 43BSD / 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.1 (Berkeley) 6/5/85"; ! 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: ! 28: descend(parentino, inumber) ! 29: struct inodesc *parentino; ! 30: ino_t inumber; ! 31: { ! 32: register DINODE *dp; ! 33: struct inodesc curino; ! 34: ! 35: bzero((char *)&curino, sizeof(struct inodesc)); ! 36: if (statemap[inumber] != DSTATE) ! 37: errexit("BAD INODE %d TO DESCEND", statemap[inumber]); ! 38: statemap[inumber] = DFOUND; ! 39: dp = ginode(inumber); ! 40: if (dp->di_size == 0) { ! 41: direrr(inumber, "ZERO LENGTH DIRECTORY"); ! 42: if (reply("REMOVE") == 1) ! 43: statemap[inumber] = DCLEAR; ! 44: return; ! 45: } ! 46: if (dp->di_size < MINDIRSIZE) { ! 47: direrr(inumber, "DIRECTORY TOO SHORT"); ! 48: dp->di_size = MINDIRSIZE; ! 49: if (reply("FIX") == 1) ! 50: inodirty(); ! 51: } ! 52: if ((dp->di_size & (DIRBLKSIZ - 1)) != 0) { ! 53: pwarn("DIRECTORY %s: LENGTH %d NOT MULTIPLE OF %d", ! 54: pathname, dp->di_size, DIRBLKSIZ); ! 55: dp->di_size = roundup(dp->di_size, DIRBLKSIZ); ! 56: if (preen) ! 57: printf(" (ADJUSTED)\n"); ! 58: if (preen || reply("ADJUST") == 1) ! 59: inodirty(); ! 60: } ! 61: curino.id_type = DATA; ! 62: curino.id_func = parentino->id_func; ! 63: curino.id_parent = parentino->id_number; ! 64: curino.id_number = inumber; ! 65: (void)ckinode(dp, &curino); ! 66: } ! 67: ! 68: dirscan(idesc) ! 69: register struct inodesc *idesc; ! 70: { ! 71: register DIRECT *dp; ! 72: int dsize, n; ! 73: long blksiz; ! 74: char dbuf[DIRBLKSIZ]; ! 75: ! 76: if (idesc->id_type != DATA) ! 77: errexit("wrong type to dirscan %d\n", idesc->id_type); ! 78: if (idesc->id_entryno == 0 && ! 79: (idesc->id_filesize & (DIRBLKSIZ - 1)) != 0) ! 80: idesc->id_filesize = roundup(idesc->id_filesize, DIRBLKSIZ); ! 81: blksiz = idesc->id_numfrags * sblock.fs_fsize; ! 82: if (outrange(idesc->id_blkno, idesc->id_numfrags)) { ! 83: idesc->id_filesize -= blksiz; ! 84: return (SKIP); ! 85: } ! 86: idesc->id_loc = 0; ! 87: for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) { ! 88: dsize = dp->d_reclen; ! 89: bcopy((char *)dp, dbuf, dsize); ! 90: idesc->id_dirp = (DIRECT *)dbuf; ! 91: if ((n = (*idesc->id_func)(idesc)) & ALTERED) { ! 92: getblk(&fileblk, idesc->id_blkno, blksiz); ! 93: if (fileblk.b_errs != NULL) { ! 94: n &= ~ALTERED; ! 95: } else { ! 96: bcopy(dbuf, (char *)dp, dsize); ! 97: dirty(&fileblk); ! 98: sbdirty(); ! 99: } ! 100: } ! 101: if (n & STOP) ! 102: return (n); ! 103: } ! 104: return (idesc->id_filesize > 0 ? KEEPON : STOP); ! 105: } ! 106: ! 107: /* ! 108: * get next entry in a directory. ! 109: */ ! 110: DIRECT * ! 111: fsck_readdir(idesc) ! 112: register struct inodesc *idesc; ! 113: { ! 114: register DIRECT *dp, *ndp; ! 115: long size, blksiz; ! 116: ! 117: blksiz = idesc->id_numfrags * sblock.fs_fsize; ! 118: getblk(&fileblk, idesc->id_blkno, blksiz); ! 119: if (fileblk.b_errs != NULL) { ! 120: idesc->id_filesize -= blksiz - idesc->id_loc; ! 121: return NULL; ! 122: } ! 123: if (idesc->id_loc % DIRBLKSIZ == 0 && idesc->id_filesize > 0 && ! 124: idesc->id_loc < blksiz) { ! 125: dp = (DIRECT *)(dirblk.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(&fileblk); ! 136: return (dp); ! 137: } ! 138: dpok: ! 139: if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz) ! 140: return NULL; ! 141: dp = (DIRECT *)(dirblk.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 *)(dirblk.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(&fileblk); ! 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: (void)ckinode(dp, &idesc); ! 310: if (idesc.id_parent >= ROOTINO && idesc.id_parent < imax) { ! 311: lfdir = idesc.id_parent; ! 312: } else { ! 313: pwarn("NO lost+found DIRECTORY"); ! 314: if (preen || reply("CREATE")) { ! 315: lfdir = allocdir(ROOTINO, 0); ! 316: if (lfdir != 0) { ! 317: if (makeentry(ROOTINO, lfdir, lfname) != 0) { ! 318: if (preen) ! 319: printf(" (CREATED)\n"); ! 320: } else { ! 321: freedir(lfdir, ROOTINO); ! 322: lfdir = 0; ! 323: if (preen) ! 324: printf("\n"); ! 325: } ! 326: } ! 327: } ! 328: } ! 329: if (lfdir == 0) { ! 330: pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY"); ! 331: printf("\n\n"); ! 332: return (0); ! 333: } ! 334: } ! 335: dp = ginode(lfdir); ! 336: if (!DIRCT(dp)) { ! 337: pfatal("lost+found IS NOT A DIRECTORY"); ! 338: if (reply("REALLOCATE") == 0) ! 339: return (0); ! 340: oldlfdir = lfdir; ! 341: if ((lfdir = allocdir(ROOTINO, 0)) == 0) { ! 342: pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n"); ! 343: return (0); ! 344: } ! 345: idesc.id_type = DATA; ! 346: idesc.id_func = chgino; ! 347: idesc.id_number = ROOTINO; ! 348: idesc.id_parent = lfdir; /* new inumber for lost+found */ ! 349: idesc.id_name = lfname; ! 350: if ((ckinode(ginode(ROOTINO), &idesc) & ALTERED) == 0) { ! 351: pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n"); ! 352: return (0); ! 353: } ! 354: inodirty(); ! 355: idesc.id_type = ADDR; ! 356: idesc.id_func = pass4check; ! 357: idesc.id_number = oldlfdir; ! 358: adjust(&idesc, lncntp[oldlfdir] + 1); ! 359: lncntp[oldlfdir] = 0; ! 360: dp = ginode(lfdir); ! 361: } ! 362: if (statemap[lfdir] != DFOUND) { ! 363: pfatal("SORRY. NO lost+found DIRECTORY\n\n"); ! 364: return (0); ! 365: } ! 366: len = strlen(lfname); ! 367: bcopy(lfname, pathp, len + 1); ! 368: pathp += len; ! 369: len = lftempname(tempname, orphan); ! 370: if (makeentry(lfdir, orphan, tempname) == 0) { ! 371: pfatal("SORRY. NO SPACE IN lost+found DIRECTORY"); ! 372: printf("\n\n"); ! 373: return (0); ! 374: } ! 375: lncntp[orphan]--; ! 376: *pathp++ = '/'; ! 377: bcopy(idesc.id_name, pathp, len + 1); ! 378: pathp += len; ! 379: if (lostdir) { ! 380: dp = ginode(orphan); ! 381: idesc.id_type = DATA; ! 382: idesc.id_func = chgino; ! 383: idesc.id_number = orphan; ! 384: idesc.id_fix = DONTKNOW; ! 385: idesc.id_name = ".."; ! 386: idesc.id_parent = lfdir; /* new value for ".." */ ! 387: (void)ckinode(dp, &idesc); ! 388: dp = ginode(lfdir); ! 389: dp->di_nlink++; ! 390: inodirty(); ! 391: lncntp[lfdir]++; ! 392: pwarn("DIR I=%u CONNECTED. ", orphan); ! 393: printf("PARENT WAS I=%u\n", pdir); ! 394: if (preen == 0) ! 395: printf("\n"); ! 396: } ! 397: return (1); ! 398: } ! 399: ! 400: /* ! 401: * make an entry in a directory ! 402: */ ! 403: makeentry(parent, ino, name) ! 404: ino_t parent, ino; ! 405: char *name; ! 406: { ! 407: DINODE *dp; ! 408: struct inodesc idesc; ! 409: ! 410: if (parent < ROOTINO || parent >= imax || ino < ROOTINO || ino >= imax) ! 411: return (0); ! 412: bzero(&idesc, sizeof(struct inodesc)); ! 413: idesc.id_type = DATA; ! 414: idesc.id_func = mkentry; ! 415: idesc.id_number = parent; ! 416: idesc.id_parent = ino; /* this is the inode to enter */ ! 417: idesc.id_fix = DONTKNOW; ! 418: idesc.id_name = name; ! 419: dp = ginode(parent); ! 420: if (dp->di_size % DIRBLKSIZ) { ! 421: dp->di_size = roundup(dp->di_size, DIRBLKSIZ); ! 422: inodirty(); ! 423: } ! 424: if ((ckinode(dp, &idesc) & ALTERED) != 0) ! 425: return (1); ! 426: if (expanddir(dp) == 0) ! 427: return (0); ! 428: return (ckinode(dp, &idesc) & ALTERED); ! 429: } ! 430: ! 431: /* ! 432: * Attempt to expand the size of a directory ! 433: */ ! 434: expanddir(dp) ! 435: register DINODE *dp; ! 436: { ! 437: daddr_t lastbn, newblk; ! 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: getblk(&fileblk, dp->di_db[lastbn + 1], ! 450: dblksize(&sblock, dp, lastbn + 1)); ! 451: if (fileblk.b_errs != NULL) ! 452: goto bad; ! 453: bcopy(dirblk.b_buf, firstblk, DIRBLKSIZ); ! 454: getblk(&fileblk, newblk, sblock.fs_bsize); ! 455: if (fileblk.b_errs != NULL) ! 456: goto bad; ! 457: bcopy(firstblk, dirblk.b_buf, DIRBLKSIZ); ! 458: for (cp = &dirblk.b_buf[DIRBLKSIZ]; ! 459: cp < &dirblk.b_buf[sblock.fs_bsize]; ! 460: cp += DIRBLKSIZ) ! 461: bcopy((char *)&emptydir, cp, sizeof emptydir); ! 462: dirty(&fileblk); ! 463: getblk(&fileblk, dp->di_db[lastbn + 1], ! 464: dblksize(&sblock, dp, lastbn + 1)); ! 465: if (fileblk.b_errs != NULL) ! 466: goto bad; ! 467: bcopy((char *)&emptydir, dirblk.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(&fileblk); ! 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: ! 495: ino = allocino(request, IFDIR|0755); ! 496: dirhead.dot_ino = ino; ! 497: dirhead.dotdot_ino = parent; ! 498: dp = ginode(ino); ! 499: getblk(&fileblk, dp->di_db[0], sblock.fs_fsize); ! 500: if (fileblk.b_errs != NULL) { ! 501: freeino(ino); ! 502: return (0); ! 503: } ! 504: bcopy((char *)&dirhead, dirblk.b_buf, sizeof dirhead); ! 505: for (cp = &dirblk.b_buf[DIRBLKSIZ]; ! 506: cp < &dirblk.b_buf[sblock.fs_fsize]; ! 507: cp += DIRBLKSIZ) ! 508: bcopy((char *)&emptydir, cp, sizeof emptydir); ! 509: dirty(&fileblk); ! 510: dp->di_nlink = 2; ! 511: inodirty(); ! 512: if (ino == ROOTINO) { ! 513: lncntp[ino] = dp->di_nlink; ! 514: return(ino); ! 515: } ! 516: if (statemap[parent] != DSTATE && statemap[parent] != DFOUND) { ! 517: freeino(ino); ! 518: return (0); ! 519: } ! 520: statemap[ino] = statemap[parent]; ! 521: if (statemap[ino] == DSTATE) { ! 522: lncntp[ino] = dp->di_nlink; ! 523: lncntp[parent]++; ! 524: } ! 525: dp = ginode(parent); ! 526: dp->di_nlink++; ! 527: inodirty(); ! 528: return (ino); ! 529: } ! 530: ! 531: /* ! 532: * free a directory inode ! 533: */ ! 534: freedir(ino, parent) ! 535: ino_t ino, parent; ! 536: { ! 537: DINODE *dp; ! 538: ! 539: if (ino != parent) { ! 540: dp = ginode(parent); ! 541: dp->di_nlink--; ! 542: inodirty(); ! 543: } ! 544: freeino(ino); ! 545: } ! 546: ! 547: /* ! 548: * generate a temporary name for the lost+found directory. ! 549: */ ! 550: lftempname(bufp, ino) ! 551: char *bufp; ! 552: ino_t ino; ! 553: { ! 554: register ino_t in; ! 555: register char *cp; ! 556: int namlen; ! 557: ! 558: cp = bufp + 2; ! 559: for (in = imax; in > 0; in /= 10) ! 560: cp++; ! 561: *--cp = 0; ! 562: namlen = cp - bufp; ! 563: in = ino; ! 564: while (cp > bufp) { ! 565: *--cp = (in % 10) + '0'; ! 566: in /= 10; ! 567: } ! 568: *cp = '#'; ! 569: return (namlen); ! 570: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.