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 * @(#)inode.c 8.8 (Berkeley) 4/28/95 34 * $FreeBSD: src/sbin/fsck/inode.c,v 1.20 2000/02/28 20:02:41 mckusick Exp $ 35 * $DragonFly: src/sbin/fsck/inode.c,v 1.3 2003/08/08 04:18:37 dillon Exp $ 36 */ 37 38 #include <sys/param.h> 39 #include <sys/time.h> 40 41 #include <vfs/ufs/dinode.h> 42 #include <vfs/ufs/dir.h> 43 #include <vfs/ufs/fs.h> 44 45 #include <err.h> 46 #include <pwd.h> 47 #include <string.h> 48 49 #include "fsck.h" 50 51 static ino_t startinum; 52 53 static int iblock __P((struct inodesc *, long ilevel, quad_t isize)); 54 55 int 56 ckinode(dp, idesc) 57 struct dinode *dp; 58 register struct inodesc *idesc; 59 { 60 ufs_daddr_t *ap; 61 int ret; 62 long n, ndb, offset; 63 struct dinode dino; 64 quad_t remsize, sizepb; 65 mode_t mode; 66 char pathbuf[MAXPATHLEN + 1]; 67 68 if (idesc->id_fix != IGNORE) 69 idesc->id_fix = DONTKNOW; 70 idesc->id_entryno = 0; 71 idesc->id_filesize = dp->di_size; 72 mode = dp->di_mode & IFMT; 73 if (mode == IFBLK || mode == IFCHR || (mode == IFLNK && 74 dp->di_size < (unsigned)sblock.fs_maxsymlinklen)) 75 return (KEEPON); 76 dino = *dp; 77 ndb = howmany(dino.di_size, sblock.fs_bsize); 78 for (ap = &dino.di_db[0]; ap < &dino.di_db[NDADDR]; ap++) { 79 if (--ndb == 0 && (offset = blkoff(&sblock, dino.di_size)) != 0) 80 idesc->id_numfrags = 81 numfrags(&sblock, fragroundup(&sblock, offset)); 82 else 83 idesc->id_numfrags = sblock.fs_frag; 84 if (*ap == 0) { 85 if (idesc->id_type == DATA && ndb >= 0) { 86 /* An empty block in a directory XXX */ 87 getpathname(pathbuf, idesc->id_number, 88 idesc->id_number); 89 pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS", 90 pathbuf); 91 if (reply("ADJUST LENGTH") == 1) { 92 dp = ginode(idesc->id_number); 93 dp->di_size = (ap - &dino.di_db[0]) * 94 sblock.fs_bsize; 95 printf( 96 "YOU MUST RERUN FSCK AFTERWARDS\n"); 97 rerun = 1; 98 inodirty(); 99 100 } 101 } 102 continue; 103 } 104 idesc->id_blkno = *ap; 105 if (idesc->id_type == ADDR) 106 ret = (*idesc->id_func)(idesc); 107 else 108 ret = dirscan(idesc); 109 if (ret & STOP) 110 return (ret); 111 } 112 idesc->id_numfrags = sblock.fs_frag; 113 remsize = dino.di_size - sblock.fs_bsize * NDADDR; 114 sizepb = sblock.fs_bsize; 115 for (ap = &dino.di_ib[0], n = 1; n <= NIADDR; ap++, n++) { 116 if (*ap) { 117 idesc->id_blkno = *ap; 118 ret = iblock(idesc, n, remsize); 119 if (ret & STOP) 120 return (ret); 121 } else { 122 if (idesc->id_type == DATA && remsize > 0) { 123 /* An empty block in a directory XXX */ 124 getpathname(pathbuf, idesc->id_number, 125 idesc->id_number); 126 pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS", 127 pathbuf); 128 if (reply("ADJUST LENGTH") == 1) { 129 dp = ginode(idesc->id_number); 130 dp->di_size -= remsize; 131 remsize = 0; 132 printf( 133 "YOU MUST RERUN FSCK AFTERWARDS\n"); 134 rerun = 1; 135 inodirty(); 136 break; 137 } 138 } 139 } 140 sizepb *= NINDIR(&sblock); 141 remsize -= sizepb; 142 } 143 return (KEEPON); 144 } 145 146 static int 147 iblock(idesc, ilevel, isize) 148 struct inodesc *idesc; 149 long ilevel; 150 quad_t isize; 151 { 152 ufs_daddr_t *ap; 153 ufs_daddr_t *aplim; 154 struct bufarea *bp; 155 int i, n, (*func)(), nif; 156 quad_t sizepb; 157 char buf[BUFSIZ]; 158 char pathbuf[MAXPATHLEN + 1]; 159 struct dinode *dp; 160 161 if (idesc->id_type == ADDR) { 162 func = idesc->id_func; 163 if (((n = (*func)(idesc)) & KEEPON) == 0) 164 return (n); 165 } else 166 func = dirscan; 167 if (chkrange(idesc->id_blkno, idesc->id_numfrags)) 168 return (SKIP); 169 bp = getdatablk(idesc->id_blkno, sblock.fs_bsize); 170 ilevel--; 171 for (sizepb = sblock.fs_bsize, i = 0; i < ilevel; i++) 172 sizepb *= NINDIR(&sblock); 173 nif = howmany(isize , sizepb); 174 if (nif > NINDIR(&sblock)) 175 nif = NINDIR(&sblock); 176 if (idesc->id_func == pass1check && nif < NINDIR(&sblock)) { 177 aplim = &bp->b_un.b_indir[NINDIR(&sblock)]; 178 for (ap = &bp->b_un.b_indir[nif]; ap < aplim; ap++) { 179 if (*ap == 0) 180 continue; 181 (void)sprintf(buf, "PARTIALLY TRUNCATED INODE I=%lu", 182 (u_long)idesc->id_number); 183 if (dofix(idesc, buf)) { 184 *ap = 0; 185 dirty(bp); 186 } 187 } 188 flush(fswritefd, bp); 189 } 190 aplim = &bp->b_un.b_indir[nif]; 191 for (ap = bp->b_un.b_indir; ap < aplim; ap++) { 192 if (*ap) { 193 idesc->id_blkno = *ap; 194 if (ilevel == 0) 195 n = (*func)(idesc); 196 else 197 n = iblock(idesc, ilevel, isize); 198 if (n & STOP) { 199 bp->b_flags &= ~B_INUSE; 200 return (n); 201 } 202 } else { 203 if (idesc->id_type == DATA && isize > 0) { 204 /* An empty block in a directory XXX */ 205 getpathname(pathbuf, idesc->id_number, 206 idesc->id_number); 207 pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS", 208 pathbuf); 209 if (reply("ADJUST LENGTH") == 1) { 210 dp = ginode(idesc->id_number); 211 dp->di_size -= isize; 212 isize = 0; 213 printf( 214 "YOU MUST RERUN FSCK AFTERWARDS\n"); 215 rerun = 1; 216 inodirty(); 217 bp->b_flags &= ~B_INUSE; 218 return(STOP); 219 } 220 } 221 } 222 isize -= sizepb; 223 } 224 bp->b_flags &= ~B_INUSE; 225 return (KEEPON); 226 } 227 228 /* 229 * Check that a block in a legal block number. 230 * Return 0 if in range, 1 if out of range. 231 */ 232 int 233 chkrange(blk, cnt) 234 ufs_daddr_t blk; 235 int cnt; 236 { 237 register int c; 238 239 if (cnt <= 0 || blk <= 0 || blk > maxfsblock || 240 cnt - 1 > maxfsblock - blk) 241 return (1); 242 if (cnt > sblock.fs_frag || 243 fragnum(&sblock, blk) + cnt > sblock.fs_frag) { 244 if (debug) 245 printf("bad size: blk %ld, offset %ld, size %ld\n", 246 blk, fragnum(&sblock, blk), cnt); 247 return (1); 248 } 249 c = dtog(&sblock, blk); 250 if (blk < cgdmin(&sblock, c)) { 251 if ((blk + cnt) > cgsblock(&sblock, c)) { 252 if (debug) { 253 printf("blk %ld < cgdmin %ld;", 254 (long)blk, (long)cgdmin(&sblock, c)); 255 printf(" blk + cnt %ld > cgsbase %ld\n", 256 (long)(blk + cnt), 257 (long)cgsblock(&sblock, c)); 258 } 259 return (1); 260 } 261 } else { 262 if ((blk + cnt) > cgbase(&sblock, c+1)) { 263 if (debug) { 264 printf("blk %ld >= cgdmin %ld;", 265 (long)blk, (long)cgdmin(&sblock, c)); 266 printf(" blk + cnt %ld > sblock.fs_fpg %ld\n", 267 (long)(blk + cnt), (long)sblock.fs_fpg); 268 } 269 return (1); 270 } 271 } 272 return (0); 273 } 274 275 /* 276 * General purpose interface for reading inodes. 277 */ 278 struct dinode * 279 ginode(inumber) 280 ino_t inumber; 281 { 282 ufs_daddr_t iblk; 283 284 if (inumber < ROOTINO || inumber > maxino) 285 errx(EEXIT, "bad inode number %d to ginode", inumber); 286 if (startinum == 0 || 287 inumber < startinum || inumber >= startinum + INOPB(&sblock)) { 288 iblk = ino_to_fsba(&sblock, inumber); 289 if (pbp != 0) 290 pbp->b_flags &= ~B_INUSE; 291 pbp = getdatablk(iblk, sblock.fs_bsize); 292 startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock); 293 } 294 return (&pbp->b_un.b_dinode[inumber % INOPB(&sblock)]); 295 } 296 297 /* 298 * Special purpose version of ginode used to optimize first pass 299 * over all the inodes in numerical order. 300 */ 301 ino_t nextino, lastinum; 302 long readcnt, readpercg, fullcnt, inobufsize, partialcnt, partialsize; 303 struct dinode *inodebuf; 304 305 struct dinode * 306 getnextinode(inumber) 307 ino_t inumber; 308 { 309 long size; 310 ufs_daddr_t dblk; 311 static struct dinode *dp; 312 313 if (inumber != nextino++ || inumber > maxino) 314 errx(EEXIT, "bad inode number %d to nextinode", inumber); 315 if (inumber >= lastinum) { 316 readcnt++; 317 dblk = fsbtodb(&sblock, ino_to_fsba(&sblock, lastinum)); 318 if (readcnt % readpercg == 0) { 319 size = partialsize; 320 lastinum += partialcnt; 321 } else { 322 size = inobufsize; 323 lastinum += fullcnt; 324 } 325 /* 326 * If bread returns an error, it will already have zeroed 327 * out the buffer, so we do not need to do so here. 328 */ 329 (void)bread(fsreadfd, (char *)inodebuf, dblk, size); 330 dp = inodebuf; 331 } 332 return (dp++); 333 } 334 335 void 336 setinodebuf(inum) 337 ino_t inum; 338 { 339 340 if (inum % sblock.fs_ipg != 0) 341 errx(EEXIT, "bad inode number %d to setinodebuf", inum); 342 startinum = 0; 343 nextino = inum; 344 lastinum = inum; 345 readcnt = 0; 346 if (inodebuf != NULL) 347 return; 348 inobufsize = blkroundup(&sblock, INOBUFSIZE); 349 fullcnt = inobufsize / sizeof(struct dinode); 350 readpercg = sblock.fs_ipg / fullcnt; 351 partialcnt = sblock.fs_ipg % fullcnt; 352 partialsize = partialcnt * sizeof(struct dinode); 353 if (partialcnt != 0) { 354 readpercg++; 355 } else { 356 partialcnt = fullcnt; 357 partialsize = inobufsize; 358 } 359 if ((inodebuf = (struct dinode *)malloc((unsigned)inobufsize)) == NULL) 360 errx(EEXIT, "cannot allocate space for inode buffer"); 361 } 362 363 void 364 freeinodebuf() 365 { 366 367 if (inodebuf != NULL) 368 free((char *)inodebuf); 369 inodebuf = NULL; 370 } 371 372 /* 373 * Routines to maintain information about directory inodes. 374 * This is built during the first pass and used during the 375 * second and third passes. 376 * 377 * Enter inodes into the cache. 378 */ 379 void 380 cacheino(dp, inumber) 381 register struct dinode *dp; 382 ino_t inumber; 383 { 384 register struct inoinfo *inp; 385 struct inoinfo **inpp; 386 int blks; 387 388 blks = howmany(dp->di_size, sblock.fs_bsize); 389 if (blks > NDADDR) 390 blks = NDADDR + NIADDR; 391 inp = (struct inoinfo *) 392 malloc(sizeof(*inp) + (blks - 1) * sizeof(ufs_daddr_t)); 393 if (inp == NULL) 394 errx(EEXIT, "cannot increase directory list"); 395 inpp = &inphead[inumber % dirhash]; 396 inp->i_nexthash = *inpp; 397 *inpp = inp; 398 inp->i_parent = inumber == ROOTINO ? ROOTINO : (ino_t)0; 399 inp->i_dotdot = (ino_t)0; 400 inp->i_number = inumber; 401 inp->i_isize = dp->di_size; 402 inp->i_numblks = blks * sizeof(ufs_daddr_t); 403 memmove(&inp->i_blks[0], &dp->di_db[0], (size_t)inp->i_numblks); 404 if (inplast == listmax) { 405 listmax += 100; 406 inpsort = (struct inoinfo **)realloc((char *)inpsort, 407 (unsigned)listmax * sizeof(struct inoinfo *)); 408 if (inpsort == NULL) 409 errx(EEXIT, "cannot increase directory list"); 410 } 411 inpsort[inplast++] = inp; 412 } 413 414 /* 415 * Look up an inode cache structure. 416 */ 417 struct inoinfo * 418 getinoinfo(inumber) 419 ino_t inumber; 420 { 421 register struct inoinfo *inp; 422 423 for (inp = inphead[inumber % dirhash]; inp; inp = inp->i_nexthash) { 424 if (inp->i_number != inumber) 425 continue; 426 return (inp); 427 } 428 errx(EEXIT, "cannot find inode %d", inumber); 429 return ((struct inoinfo *)0); 430 } 431 432 /* 433 * Clean up all the inode cache structure. 434 */ 435 void 436 inocleanup() 437 { 438 register struct inoinfo **inpp; 439 440 if (inphead == NULL) 441 return; 442 for (inpp = &inpsort[inplast - 1]; inpp >= inpsort; inpp--) 443 free((char *)(*inpp)); 444 free((char *)inphead); 445 free((char *)inpsort); 446 inphead = inpsort = NULL; 447 } 448 449 void 450 inodirty() 451 { 452 453 dirty(pbp); 454 } 455 456 void 457 clri(idesc, type, flag) 458 register struct inodesc *idesc; 459 char *type; 460 int flag; 461 { 462 register struct dinode *dp; 463 464 dp = ginode(idesc->id_number); 465 if (flag == 1) { 466 pwarn("%s %s", type, 467 (dp->di_mode & IFMT) == IFDIR ? "DIR" : "FILE"); 468 pinode(idesc->id_number); 469 } 470 if (preen || reply("CLEAR") == 1) { 471 if (preen) 472 printf(" (CLEARED)\n"); 473 n_files--; 474 (void)ckinode(dp, idesc); 475 clearinode(dp); 476 inoinfo(idesc->id_number)->ino_state = USTATE; 477 inodirty(); 478 } 479 } 480 481 int 482 findname(idesc) 483 struct inodesc *idesc; 484 { 485 register struct direct *dirp = idesc->id_dirp; 486 487 if (dirp->d_ino != idesc->id_parent || idesc->id_entryno < 2) { 488 idesc->id_entryno++; 489 return (KEEPON); 490 } 491 memmove(idesc->id_name, dirp->d_name, (size_t)dirp->d_namlen + 1); 492 return (STOP|FOUND); 493 } 494 495 int 496 findino(idesc) 497 struct inodesc *idesc; 498 { 499 register struct direct *dirp = idesc->id_dirp; 500 501 if (dirp->d_ino == 0) 502 return (KEEPON); 503 if (strcmp(dirp->d_name, idesc->id_name) == 0 && 504 dirp->d_ino >= ROOTINO && dirp->d_ino <= maxino) { 505 idesc->id_parent = dirp->d_ino; 506 return (STOP|FOUND); 507 } 508 return (KEEPON); 509 } 510 511 int 512 clearentry(idesc) 513 struct inodesc *idesc; 514 { 515 register struct direct *dirp = idesc->id_dirp; 516 517 if (dirp->d_ino != idesc->id_parent || idesc->id_entryno < 2) { 518 idesc->id_entryno++; 519 return (KEEPON); 520 } 521 dirp->d_ino = 0; 522 return (STOP|FOUND|ALTERED); 523 } 524 525 void 526 pinode(ino) 527 ino_t ino; 528 { 529 register struct dinode *dp; 530 register char *p; 531 struct passwd *pw; 532 time_t t; 533 534 printf(" I=%lu ", (u_long)ino); 535 if (ino < ROOTINO || ino > maxino) 536 return; 537 dp = ginode(ino); 538 printf(" OWNER="); 539 if ((pw = getpwuid((int)dp->di_uid)) != 0) 540 printf("%s ", pw->pw_name); 541 else 542 printf("%u ", (unsigned)dp->di_uid); 543 printf("MODE=%o\n", dp->di_mode); 544 if (preen) 545 printf("%s: ", cdevname); 546 printf("SIZE=%qu ", dp->di_size); 547 t = dp->di_mtime; 548 p = ctime(&t); 549 printf("MTIME=%12.12s %4.4s ", &p[4], &p[20]); 550 } 551 552 void 553 blkerror(ino, type, blk) 554 ino_t ino; 555 char *type; 556 ufs_daddr_t blk; 557 { 558 559 pfatal("%ld %s I=%lu", blk, type, ino); 560 printf("\n"); 561 switch (inoinfo(ino)->ino_state) { 562 563 case FSTATE: 564 inoinfo(ino)->ino_state = FCLEAR; 565 return; 566 567 case DSTATE: 568 inoinfo(ino)->ino_state = DCLEAR; 569 return; 570 571 case FCLEAR: 572 case DCLEAR: 573 return; 574 575 default: 576 errx(EEXIT, "BAD STATE %d TO BLKERR", inoinfo(ino)->ino_state); 577 /* NOTREACHED */ 578 } 579 } 580 581 /* 582 * allocate an unused inode 583 */ 584 ino_t 585 allocino(request, type) 586 ino_t request; 587 int type; 588 { 589 register ino_t ino; 590 register struct dinode *dp; 591 struct cg *cgp = &cgrp; 592 int cg; 593 594 if (request == 0) 595 request = ROOTINO; 596 else if (inoinfo(request)->ino_state != USTATE) 597 return (0); 598 for (ino = request; ino < maxino; ino++) 599 if (inoinfo(ino)->ino_state == USTATE) 600 break; 601 if (ino == maxino) 602 return (0); 603 cg = ino_to_cg(&sblock, ino); 604 getblk(&cgblk, cgtod(&sblock, cg), sblock.fs_cgsize); 605 if (!cg_chkmagic(cgp)) 606 pfatal("CG %d: BAD MAGIC NUMBER\n", cg); 607 setbit(cg_inosused(cgp), ino % sblock.fs_ipg); 608 cgp->cg_cs.cs_nifree--; 609 switch (type & IFMT) { 610 case IFDIR: 611 inoinfo(ino)->ino_state = DSTATE; 612 cgp->cg_cs.cs_ndir++; 613 break; 614 case IFREG: 615 case IFLNK: 616 inoinfo(ino)->ino_state = FSTATE; 617 break; 618 default: 619 return (0); 620 } 621 cgdirty(); 622 dp = ginode(ino); 623 dp->di_db[0] = allocblk((long)1); 624 if (dp->di_db[0] == 0) { 625 inoinfo(ino)->ino_state = USTATE; 626 return (0); 627 } 628 dp->di_mode = type; 629 dp->di_flags = 0; 630 dp->di_atime = time(NULL); 631 dp->di_mtime = dp->di_ctime = dp->di_atime; 632 dp->di_mtimensec = dp->di_ctimensec = dp->di_atimensec = 0; 633 dp->di_size = sblock.fs_fsize; 634 dp->di_blocks = btodb(sblock.fs_fsize); 635 n_files++; 636 inodirty(); 637 if (newinofmt) 638 inoinfo(ino)->ino_type = IFTODT(type); 639 return (ino); 640 } 641 642 /* 643 * deallocate an inode 644 */ 645 void 646 freeino(ino) 647 ino_t ino; 648 { 649 struct inodesc idesc; 650 struct dinode *dp; 651 652 memset(&idesc, 0, sizeof(struct inodesc)); 653 idesc.id_type = ADDR; 654 idesc.id_func = pass4check; 655 idesc.id_number = ino; 656 dp = ginode(ino); 657 (void)ckinode(dp, &idesc); 658 clearinode(dp); 659 inodirty(); 660 inoinfo(ino)->ino_state = USTATE; 661 n_files--; 662 } 663