1 /* 2 * Copyright (c) 1980, 1986, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 #ifndef lint 35 #if 0 36 static const char sccsid[] = "@(#)dir.c 8.8 (Berkeley) 4/28/95"; 37 #endif 38 static const char rcsid[] = 39 "$FreeBSD: src/sbin/fsck/dir.c,v 1.15 1999/08/28 00:12:45 peter Exp $"; 40 #endif /* not lint */ 41 42 #include <sys/param.h> 43 #include <sys/time.h> 44 45 #include <ufs/ufs/dinode.h> 46 #include <ufs/ufs/dir.h> 47 #include <ufs/ffs/fs.h> 48 49 #include <err.h> 50 #include <string.h> 51 52 #include "fsck.h" 53 54 char *lfname = "lost+found"; 55 int lfmode = 01777; 56 struct dirtemplate emptydir = { 0, DIRBLKSIZ }; 57 struct dirtemplate dirhead = { 58 0, 12, DT_DIR, 1, ".", 59 0, DIRBLKSIZ - 12, DT_DIR, 2, ".." 60 }; 61 struct odirtemplate odirhead = { 62 0, 12, 1, ".", 63 0, DIRBLKSIZ - 12, 2, ".." 64 }; 65 66 static int chgino __P((struct inodesc *)); 67 static int dircheck __P((struct inodesc *, struct direct *)); 68 static int expanddir __P((struct dinode *dp, char *name)); 69 static void freedir __P((ino_t ino, ino_t parent)); 70 static struct direct *fsck_readdir __P((struct inodesc *)); 71 static struct bufarea *getdirblk __P((ufs_daddr_t blkno, long size)); 72 static int lftempname __P((char *bufp, ino_t ino)); 73 static int mkentry __P((struct inodesc *)); 74 75 /* 76 * Propagate connected state through the tree. 77 */ 78 void 79 propagate() 80 { 81 register struct inoinfo **inpp, *inp; 82 struct inoinfo **inpend; 83 long change; 84 85 inpend = &inpsort[inplast]; 86 do { 87 change = 0; 88 for (inpp = inpsort; inpp < inpend; inpp++) { 89 inp = *inpp; 90 if (inp->i_parent == 0) 91 continue; 92 if (inoinfo(inp->i_parent)->ino_state == DFOUND && 93 inoinfo(inp->i_number)->ino_state == DSTATE) { 94 inoinfo(inp->i_number)->ino_state = DFOUND; 95 change++; 96 } 97 } 98 } while (change > 0); 99 } 100 101 /* 102 * Scan each entry in a directory block. 103 */ 104 int 105 dirscan(idesc) 106 register struct inodesc *idesc; 107 { 108 register struct direct *dp; 109 register struct bufarea *bp; 110 int dsize, n; 111 long blksiz; 112 char dbuf[DIRBLKSIZ]; 113 114 if (idesc->id_type != DATA) 115 errx(EEXIT, "wrong type to dirscan %d", idesc->id_type); 116 if (idesc->id_entryno == 0 && 117 (idesc->id_filesize & (DIRBLKSIZ - 1)) != 0) 118 idesc->id_filesize = roundup(idesc->id_filesize, DIRBLKSIZ); 119 blksiz = idesc->id_numfrags * sblock.fs_fsize; 120 if (chkrange(idesc->id_blkno, idesc->id_numfrags)) { 121 idesc->id_filesize -= blksiz; 122 return (SKIP); 123 } 124 idesc->id_loc = 0; 125 for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) { 126 dsize = dp->d_reclen; 127 if (dsize > sizeof(dbuf)) 128 dsize = sizeof(dbuf); 129 memmove(dbuf, dp, (size_t)dsize); 130 # if (BYTE_ORDER == LITTLE_ENDIAN) 131 if (!newinofmt) { 132 struct direct *tdp = (struct direct *)dbuf; 133 u_char tmp; 134 135 tmp = tdp->d_namlen; 136 tdp->d_namlen = tdp->d_type; 137 tdp->d_type = tmp; 138 } 139 # endif 140 idesc->id_dirp = (struct direct *)dbuf; 141 if ((n = (*idesc->id_func)(idesc)) & ALTERED) { 142 # if (BYTE_ORDER == LITTLE_ENDIAN) 143 if (!newinofmt && !doinglevel2) { 144 struct direct *tdp; 145 u_char tmp; 146 147 tdp = (struct direct *)dbuf; 148 tmp = tdp->d_namlen; 149 tdp->d_namlen = tdp->d_type; 150 tdp->d_type = tmp; 151 } 152 # endif 153 bp = getdirblk(idesc->id_blkno, blksiz); 154 memmove(bp->b_un.b_buf + idesc->id_loc - dsize, dbuf, 155 (size_t)dsize); 156 dirty(bp); 157 sbdirty(); 158 } 159 if (n & STOP) 160 return (n); 161 } 162 return (idesc->id_filesize > 0 ? KEEPON : STOP); 163 } 164 165 /* 166 * get next entry in a directory. 167 */ 168 static struct direct * 169 fsck_readdir(idesc) 170 register struct inodesc *idesc; 171 { 172 register struct direct *dp, *ndp; 173 register struct bufarea *bp; 174 long size, blksiz, fix, dploc; 175 176 blksiz = idesc->id_numfrags * sblock.fs_fsize; 177 bp = getdirblk(idesc->id_blkno, blksiz); 178 if (idesc->id_loc % DIRBLKSIZ == 0 && idesc->id_filesize > 0 && 179 idesc->id_loc < blksiz) { 180 dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc); 181 if (dircheck(idesc, dp)) 182 goto dpok; 183 if (idesc->id_fix == IGNORE) 184 return (0); 185 fix = dofix(idesc, "DIRECTORY CORRUPTED"); 186 bp = getdirblk(idesc->id_blkno, blksiz); 187 dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc); 188 dp->d_reclen = DIRBLKSIZ; 189 dp->d_ino = 0; 190 dp->d_type = 0; 191 dp->d_namlen = 0; 192 dp->d_name[0] = '\0'; 193 if (fix) 194 dirty(bp); 195 idesc->id_loc += DIRBLKSIZ; 196 idesc->id_filesize -= DIRBLKSIZ; 197 return (dp); 198 } 199 dpok: 200 if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz) 201 return NULL; 202 dploc = idesc->id_loc; 203 dp = (struct direct *)(bp->b_un.b_buf + dploc); 204 idesc->id_loc += dp->d_reclen; 205 idesc->id_filesize -= dp->d_reclen; 206 if ((idesc->id_loc % DIRBLKSIZ) == 0) 207 return (dp); 208 ndp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc); 209 if (idesc->id_loc < blksiz && idesc->id_filesize > 0 && 210 dircheck(idesc, ndp) == 0) { 211 size = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ); 212 idesc->id_loc += size; 213 idesc->id_filesize -= size; 214 if (idesc->id_fix == IGNORE) 215 return (0); 216 fix = dofix(idesc, "DIRECTORY CORRUPTED"); 217 bp = getdirblk(idesc->id_blkno, blksiz); 218 dp = (struct direct *)(bp->b_un.b_buf + dploc); 219 dp->d_reclen += size; 220 if (fix) 221 dirty(bp); 222 } 223 return (dp); 224 } 225 226 /* 227 * Verify that a directory entry is valid. 228 * This is a superset of the checks made in the kernel. 229 */ 230 static int 231 dircheck(idesc, dp) 232 struct inodesc *idesc; 233 register struct direct *dp; 234 { 235 register int size; 236 register char *cp; 237 u_char namlen, type; 238 int spaceleft; 239 240 spaceleft = DIRBLKSIZ - (idesc->id_loc % DIRBLKSIZ); 241 if (dp->d_reclen == 0 || 242 dp->d_reclen > spaceleft || 243 (dp->d_reclen & 0x3) != 0) 244 return (0); 245 if (dp->d_ino == 0) 246 return (1); 247 size = DIRSIZ(!newinofmt, dp); 248 # if (BYTE_ORDER == LITTLE_ENDIAN) 249 if (!newinofmt) { 250 type = dp->d_namlen; 251 namlen = dp->d_type; 252 } else { 253 namlen = dp->d_namlen; 254 type = dp->d_type; 255 } 256 # else 257 namlen = dp->d_namlen; 258 type = dp->d_type; 259 # endif 260 if (dp->d_reclen < size || 261 idesc->id_filesize < size || 262 namlen > MAXNAMLEN || 263 type > 15) 264 return (0); 265 for (cp = dp->d_name, size = 0; size < namlen; size++) 266 if (*cp == '\0' || (*cp++ == '/')) 267 return (0); 268 if (*cp != '\0') 269 return (0); 270 return (1); 271 } 272 273 void 274 direrror(ino, errmesg) 275 ino_t ino; 276 char *errmesg; 277 { 278 279 fileerror(ino, ino, errmesg); 280 } 281 282 void 283 fileerror(cwd, ino, errmesg) 284 ino_t cwd, ino; 285 char *errmesg; 286 { 287 register struct dinode *dp; 288 char pathbuf[MAXPATHLEN + 1]; 289 290 pwarn("%s ", errmesg); 291 pinode(ino); 292 printf("\n"); 293 getpathname(pathbuf, cwd, ino); 294 if (ino < ROOTINO || ino > maxino) { 295 pfatal("NAME=%s\n", pathbuf); 296 return; 297 } 298 dp = ginode(ino); 299 if (ftypeok(dp)) 300 pfatal("%s=%s\n", 301 (dp->di_mode & IFMT) == IFDIR ? "DIR" : "FILE", pathbuf); 302 else 303 pfatal("NAME=%s\n", pathbuf); 304 } 305 306 void 307 adjust(idesc, lcnt) 308 register struct inodesc *idesc; 309 int lcnt; 310 { 311 struct dinode *dp; 312 int saveresolved; 313 314 dp = ginode(idesc->id_number); 315 if (dp->di_nlink == lcnt) { 316 /* 317 * If we have not hit any unresolved problems, are running 318 * in preen mode, and are on a filesystem using soft updates, 319 * then just toss any partially allocated files. 320 */ 321 if (resolved && preen && usedsoftdep) { 322 clri(idesc, "UNREF", 1); 323 return; 324 } else { 325 /* 326 * The filesystem can be marked clean even if 327 * a file is not linked up, but is cleared. 328 * Hence, resolved should not be cleared when 329 * linkup is answered no, but clri is answered yes. 330 */ 331 saveresolved = resolved; 332 if (linkup(idesc->id_number, (ino_t)0, NULL) == 0) { 333 resolved = saveresolved; 334 clri(idesc, "UNREF", 0); 335 return; 336 } 337 /* 338 * Account for the new reference created by linkup(). 339 */ 340 dp = ginode(idesc->id_number); 341 lcnt--; 342 } 343 } 344 if (lcnt != 0) { 345 pwarn("LINK COUNT %s", (lfdir == idesc->id_number) ? lfname : 346 ((dp->di_mode & IFMT) == IFDIR ? "DIR" : "FILE")); 347 pinode(idesc->id_number); 348 printf(" COUNT %d SHOULD BE %d", 349 dp->di_nlink, dp->di_nlink - lcnt); 350 if (preen || usedsoftdep) { 351 if (lcnt < 0) { 352 printf("\n"); 353 pfatal("LINK COUNT INCREASING"); 354 } 355 if (preen) 356 printf(" (ADJUSTED)\n"); 357 } 358 if (preen || reply("ADJUST") == 1) { 359 dp->di_nlink -= lcnt; 360 inodirty(); 361 } 362 } 363 } 364 365 static int 366 mkentry(idesc) 367 struct inodesc *idesc; 368 { 369 register struct direct *dirp = idesc->id_dirp; 370 struct direct newent; 371 int newlen, oldlen; 372 373 newent.d_namlen = strlen(idesc->id_name); 374 newlen = DIRSIZ(0, &newent); 375 if (dirp->d_ino != 0) 376 oldlen = DIRSIZ(0, dirp); 377 else 378 oldlen = 0; 379 if (dirp->d_reclen - oldlen < newlen) 380 return (KEEPON); 381 newent.d_reclen = dirp->d_reclen - oldlen; 382 dirp->d_reclen = oldlen; 383 dirp = (struct direct *)(((char *)dirp) + oldlen); 384 dirp->d_ino = idesc->id_parent; /* ino to be entered is in id_parent */ 385 dirp->d_reclen = newent.d_reclen; 386 if (newinofmt) 387 dirp->d_type = inoinfo(idesc->id_parent)->ino_type; 388 else 389 dirp->d_type = 0; 390 dirp->d_namlen = newent.d_namlen; 391 memmove(dirp->d_name, idesc->id_name, (size_t)newent.d_namlen + 1); 392 # if (BYTE_ORDER == LITTLE_ENDIAN) 393 /* 394 * If the entry was split, dirscan() will only reverse the byte 395 * order of the original entry, and not the new one, before 396 * writing it back out. So, we reverse the byte order here if 397 * necessary. 398 */ 399 if (oldlen != 0 && !newinofmt && !doinglevel2) { 400 u_char tmp; 401 402 tmp = dirp->d_namlen; 403 dirp->d_namlen = dirp->d_type; 404 dirp->d_type = tmp; 405 } 406 # endif 407 return (ALTERED|STOP); 408 } 409 410 static int 411 chgino(idesc) 412 struct inodesc *idesc; 413 { 414 register struct direct *dirp = idesc->id_dirp; 415 416 if (memcmp(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1)) 417 return (KEEPON); 418 dirp->d_ino = idesc->id_parent; 419 if (newinofmt) 420 dirp->d_type = inoinfo(idesc->id_parent)->ino_type; 421 else 422 dirp->d_type = 0; 423 return (ALTERED|STOP); 424 } 425 426 int 427 linkup(orphan, parentdir, name) 428 ino_t orphan; 429 ino_t parentdir; 430 char *name; 431 { 432 register struct dinode *dp; 433 int lostdir; 434 ino_t oldlfdir; 435 struct inodesc idesc; 436 char tempname[BUFSIZ]; 437 438 memset(&idesc, 0, sizeof(struct inodesc)); 439 dp = ginode(orphan); 440 lostdir = (dp->di_mode & IFMT) == IFDIR; 441 pwarn("UNREF %s ", lostdir ? "DIR" : "FILE"); 442 pinode(orphan); 443 if (preen && dp->di_size == 0) 444 return (0); 445 if (preen) 446 printf(" (RECONNECTED)\n"); 447 else 448 if (reply("RECONNECT") == 0) 449 return (0); 450 if (lfdir == 0) { 451 dp = ginode(ROOTINO); 452 idesc.id_name = lfname; 453 idesc.id_type = DATA; 454 idesc.id_func = findino; 455 idesc.id_number = ROOTINO; 456 if ((ckinode(dp, &idesc) & FOUND) != 0) { 457 lfdir = idesc.id_parent; 458 } else { 459 pwarn("NO lost+found DIRECTORY"); 460 if (preen || reply("CREATE")) { 461 lfdir = allocdir(ROOTINO, (ino_t)0, lfmode); 462 if (lfdir != 0) { 463 if (makeentry(ROOTINO, lfdir, lfname) != 0) { 464 numdirs++; 465 if (preen) 466 printf(" (CREATED)\n"); 467 } else { 468 freedir(lfdir, ROOTINO); 469 lfdir = 0; 470 if (preen) 471 printf("\n"); 472 } 473 } 474 } 475 } 476 if (lfdir == 0) { 477 pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY"); 478 printf("\n\n"); 479 return (0); 480 } 481 } 482 dp = ginode(lfdir); 483 if ((dp->di_mode & IFMT) != IFDIR) { 484 pfatal("lost+found IS NOT A DIRECTORY"); 485 if (reply("REALLOCATE") == 0) 486 return (0); 487 oldlfdir = lfdir; 488 if ((lfdir = allocdir(ROOTINO, (ino_t)0, lfmode)) == 0) { 489 pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n"); 490 return (0); 491 } 492 if ((changeino(ROOTINO, lfname, lfdir) & ALTERED) == 0) { 493 pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n"); 494 return (0); 495 } 496 inodirty(); 497 idesc.id_type = ADDR; 498 idesc.id_func = pass4check; 499 idesc.id_number = oldlfdir; 500 adjust(&idesc, inoinfo(oldlfdir)->ino_linkcnt + 1); 501 inoinfo(oldlfdir)->ino_linkcnt = 0; 502 dp = ginode(lfdir); 503 } 504 if (inoinfo(lfdir)->ino_state != DFOUND) { 505 pfatal("SORRY. NO lost+found DIRECTORY\n\n"); 506 return (0); 507 } 508 (void)lftempname(tempname, orphan); 509 if (makeentry(lfdir, orphan, (name ? name : tempname)) == 0) { 510 pfatal("SORRY. NO SPACE IN lost+found DIRECTORY"); 511 printf("\n\n"); 512 return (0); 513 } 514 inoinfo(orphan)->ino_linkcnt--; 515 if (lostdir) { 516 if ((changeino(orphan, "..", lfdir) & ALTERED) == 0 && 517 parentdir != (ino_t)-1) 518 (void)makeentry(orphan, lfdir, ".."); 519 dp = ginode(lfdir); 520 dp->di_nlink++; 521 inodirty(); 522 inoinfo(lfdir)->ino_linkcnt++; 523 pwarn("DIR I=%lu CONNECTED. ", orphan); 524 if (parentdir != (ino_t)-1) { 525 printf("PARENT WAS I=%lu\n", (u_long)parentdir); 526 /* 527 * The parent directory, because of the ordering 528 * guarantees, has had the link count incremented 529 * for the child, but no entry was made. This 530 * fixes the parent link count so that fsck does 531 * not need to be rerun. 532 */ 533 inoinfo(parentdir)->ino_linkcnt++; 534 } 535 if (preen == 0) 536 printf("\n"); 537 } 538 return (1); 539 } 540 541 /* 542 * fix an entry in a directory. 543 */ 544 int 545 changeino(dir, name, newnum) 546 ino_t dir; 547 char *name; 548 ino_t newnum; 549 { 550 struct inodesc idesc; 551 552 memset(&idesc, 0, sizeof(struct inodesc)); 553 idesc.id_type = DATA; 554 idesc.id_func = chgino; 555 idesc.id_number = dir; 556 idesc.id_fix = DONTKNOW; 557 idesc.id_name = name; 558 idesc.id_parent = newnum; /* new value for name */ 559 return (ckinode(ginode(dir), &idesc)); 560 } 561 562 /* 563 * make an entry in a directory 564 */ 565 int 566 makeentry(parent, ino, name) 567 ino_t parent, ino; 568 char *name; 569 { 570 struct dinode *dp; 571 struct inodesc idesc; 572 char pathbuf[MAXPATHLEN + 1]; 573 574 if (parent < ROOTINO || parent >= maxino || 575 ino < ROOTINO || ino >= maxino) 576 return (0); 577 memset(&idesc, 0, sizeof(struct inodesc)); 578 idesc.id_type = DATA; 579 idesc.id_func = mkentry; 580 idesc.id_number = parent; 581 idesc.id_parent = ino; /* this is the inode to enter */ 582 idesc.id_fix = DONTKNOW; 583 idesc.id_name = name; 584 dp = ginode(parent); 585 if (dp->di_size % DIRBLKSIZ) { 586 dp->di_size = roundup(dp->di_size, DIRBLKSIZ); 587 inodirty(); 588 } 589 if ((ckinode(dp, &idesc) & ALTERED) != 0) 590 return (1); 591 getpathname(pathbuf, parent, parent); 592 dp = ginode(parent); 593 if (expanddir(dp, pathbuf) == 0) 594 return (0); 595 return (ckinode(dp, &idesc) & ALTERED); 596 } 597 598 /* 599 * Attempt to expand the size of a directory 600 */ 601 static int 602 expanddir(dp, name) 603 register struct dinode *dp; 604 char *name; 605 { 606 ufs_daddr_t lastbn, newblk; 607 register struct bufarea *bp; 608 char *cp, firstblk[DIRBLKSIZ]; 609 610 lastbn = lblkno(&sblock, dp->di_size); 611 if (lastbn >= NDADDR - 1 || dp->di_db[lastbn] == 0 || dp->di_size == 0) 612 return (0); 613 if ((newblk = allocblk(sblock.fs_frag)) == 0) 614 return (0); 615 dp->di_db[lastbn + 1] = dp->di_db[lastbn]; 616 dp->di_db[lastbn] = newblk; 617 dp->di_size += sblock.fs_bsize; 618 dp->di_blocks += btodb(sblock.fs_bsize); 619 bp = getdirblk(dp->di_db[lastbn + 1], 620 (long)dblksize(&sblock, dp, lastbn + 1)); 621 if (bp->b_errs) 622 goto bad; 623 memmove(firstblk, bp->b_un.b_buf, DIRBLKSIZ); 624 bp = getdirblk(newblk, sblock.fs_bsize); 625 if (bp->b_errs) 626 goto bad; 627 memmove(bp->b_un.b_buf, firstblk, DIRBLKSIZ); 628 for (cp = &bp->b_un.b_buf[DIRBLKSIZ]; 629 cp < &bp->b_un.b_buf[sblock.fs_bsize]; 630 cp += DIRBLKSIZ) 631 memmove(cp, &emptydir, sizeof emptydir); 632 dirty(bp); 633 bp = getdirblk(dp->di_db[lastbn + 1], 634 (long)dblksize(&sblock, dp, lastbn + 1)); 635 if (bp->b_errs) 636 goto bad; 637 memmove(bp->b_un.b_buf, &emptydir, sizeof emptydir); 638 pwarn("NO SPACE LEFT IN %s", name); 639 if (preen) 640 printf(" (EXPANDED)\n"); 641 else if (reply("EXPAND") == 0) 642 goto bad; 643 dirty(bp); 644 inodirty(); 645 return (1); 646 bad: 647 dp->di_db[lastbn] = dp->di_db[lastbn + 1]; 648 dp->di_db[lastbn + 1] = 0; 649 dp->di_size -= sblock.fs_bsize; 650 dp->di_blocks -= btodb(sblock.fs_bsize); 651 freeblk(newblk, sblock.fs_frag); 652 return (0); 653 } 654 655 /* 656 * allocate a new directory 657 */ 658 ino_t 659 allocdir(parent, request, mode) 660 ino_t parent, request; 661 int mode; 662 { 663 ino_t ino; 664 char *cp; 665 struct dinode *dp; 666 register struct bufarea *bp; 667 struct dirtemplate *dirp; 668 669 ino = allocino(request, IFDIR|mode); 670 if (newinofmt) 671 dirp = &dirhead; 672 else 673 dirp = (struct dirtemplate *)&odirhead; 674 dirp->dot_ino = ino; 675 dirp->dotdot_ino = parent; 676 dp = ginode(ino); 677 bp = getdirblk(dp->di_db[0], sblock.fs_fsize); 678 if (bp->b_errs) { 679 freeino(ino); 680 return (0); 681 } 682 memmove(bp->b_un.b_buf, dirp, sizeof(struct dirtemplate)); 683 for (cp = &bp->b_un.b_buf[DIRBLKSIZ]; 684 cp < &bp->b_un.b_buf[sblock.fs_fsize]; 685 cp += DIRBLKSIZ) 686 memmove(cp, &emptydir, sizeof emptydir); 687 dirty(bp); 688 dp->di_nlink = 2; 689 inodirty(); 690 if (ino == ROOTINO) { 691 inoinfo(ino)->ino_linkcnt = dp->di_nlink; 692 cacheino(dp, ino); 693 return(ino); 694 } 695 if (inoinfo(parent)->ino_state != DSTATE && 696 inoinfo(parent)->ino_state != DFOUND) { 697 freeino(ino); 698 return (0); 699 } 700 cacheino(dp, ino); 701 inoinfo(ino)->ino_state = inoinfo(parent)->ino_state; 702 if (inoinfo(ino)->ino_state == DSTATE) { 703 inoinfo(ino)->ino_linkcnt = dp->di_nlink; 704 inoinfo(parent)->ino_linkcnt++; 705 } 706 dp = ginode(parent); 707 dp->di_nlink++; 708 inodirty(); 709 return (ino); 710 } 711 712 /* 713 * free a directory inode 714 */ 715 static void 716 freedir(ino, parent) 717 ino_t ino, parent; 718 { 719 struct dinode *dp; 720 721 if (ino != parent) { 722 dp = ginode(parent); 723 dp->di_nlink--; 724 inodirty(); 725 } 726 freeino(ino); 727 } 728 729 /* 730 * generate a temporary name for the lost+found directory. 731 */ 732 static int 733 lftempname(bufp, ino) 734 char *bufp; 735 ino_t ino; 736 { 737 register ino_t in; 738 register char *cp; 739 int namlen; 740 741 cp = bufp + 2; 742 for (in = maxino; in > 0; in /= 10) 743 cp++; 744 *--cp = 0; 745 namlen = cp - bufp; 746 in = ino; 747 while (cp > bufp) { 748 *--cp = (in % 10) + '0'; 749 in /= 10; 750 } 751 *cp = '#'; 752 return (namlen); 753 } 754 755 /* 756 * Get a directory block. 757 * Insure that it is held until another is requested. 758 */ 759 static struct bufarea * 760 getdirblk(blkno, size) 761 ufs_daddr_t blkno; 762 long size; 763 { 764 765 if (pdirbp != 0) 766 pdirbp->b_flags &= ~B_INUSE; 767 pdirbp = getdatablk(blkno, size); 768 return (pdirbp); 769 } 770