sbin/fsck_ffs/inode.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1980, 1986, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #if 0
  33 #ifndef lint
  34 static const char sccsid[] = "@(#)inode.c       8.8 (Berkeley) 4/28/95";
  35 #endif /* not lint */
  36 #endif
  37 #include <sys/cdefs.h>
  38 __FBSDID("$FreeBSD$");
  39
  40 #include <sys/param.h>
  41 #include <sys/stat.h>
  42 #include <sys/stdint.h>
  43 #include <sys/sysctl.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 <pwd.h>
  51 #include <string.h>
  52 #include <time.h>
  53 #include <libufs.h>
  54
  55 #include "fsck.h"
  56
  57 struct bufarea *icachebp;       /* inode cache buffer */
  58
  59 static int iblock(struct inodesc *, off_t isize, int type);
  60 static ufs2_daddr_t indir_blkatoff(ufs2_daddr_t, ino_t, ufs_lbn_t, ufs_lbn_t,
  61     struct bufarea **);
  62 static int snapclean(struct inodesc *idesc);
  63 static void chkcopyonwrite(struct fs *, ufs2_daddr_t,
  64     ufs2_daddr_t (*checkblkavail)(ufs2_daddr_t, long));
  65
  66 int
  67 ckinode(union dinode *dp, struct inodesc *idesc)
  68 {
  69         off_t remsize, sizepb;
  70         int i, offset, ret;
  71         struct inode ip;
  72         union dinode dino;
  73         ufs2_daddr_t ndb;
  74         mode_t mode;
  75         char pathbuf[MAXPATHLEN + 1];
  76
  77         if (idesc->id_fix != IGNORE)
  78                 idesc->id_fix = DONTKNOW;
  79         idesc->id_dp = dp;
  80         idesc->id_lbn = -1;
  81         idesc->id_lballoc = -1;
  82         idesc->id_level = 0;
  83         idesc->id_entryno = 0;
  84         idesc->id_filesize = DIP(dp, di_size);
  85         mode = DIP(dp, di_mode) & IFMT;
  86         if (mode == IFBLK || mode == IFCHR || (mode == IFLNK &&
  87             DIP(dp, di_size) < (unsigned)sblock.fs_maxsymlinklen))
  88                 return (KEEPON);
  89         if (sblock.fs_magic == FS_UFS1_MAGIC)
  90                 dino.dp1 = dp->dp1;
  91         else
  92                 dino.dp2 = dp->dp2;
  93         ndb = howmany(DIP(&dino, di_size), sblock.fs_bsize);
  94         for (i = 0; i < UFS_NDADDR; i++) {
  95                 idesc->id_lbn++;
  96                 if (--ndb == 0 &&
  97                     (offset = blkoff(&sblock, DIP(&dino, di_size))) != 0)
  98                         idesc->id_numfrags =
  99                                 numfrags(&sblock, fragroundup(&sblock, offset));
 100                 else
 101                         idesc->id_numfrags = sblock.fs_frag;
 102                 if (DIP(&dino, di_db[i]) == 0) {
 103                         if (idesc->id_type == DATA && ndb >= 0) {
 104                                 /* An empty block in a directory XXX */
 105                                 getpathname(pathbuf, idesc->id_number,
 106                                                 idesc->id_number);
 107                                 pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
 108                                         pathbuf);
 109                                 if (reply("ADJUST LENGTH") == 1) {
 110                                         ginode(idesc->id_number, &ip);
 111                                         DIP_SET(ip.i_dp, di_size,
 112                                             i * sblock.fs_bsize);
 113                                         printf(
 114                                             "YOU MUST RERUN FSCK AFTERWARDS\n");
 115                                         rerun = 1;
 116                                         inodirty(&ip);
 117                                         irelse(&ip);
 118                                 }
 119                         }
 120                         continue;
 121                 }
 122                 idesc->id_blkno = DIP(&dino, di_db[i]);
 123                 if (idesc->id_type != DATA)
 124                         ret = (*idesc->id_func)(idesc);
 125                 else
 126                         ret = dirscan(idesc);
 127                 if (ret & STOP)
 128                         return (ret);
 129         }
 130         idesc->id_numfrags = sblock.fs_frag;
 131         remsize = DIP(&dino, di_size) - sblock.fs_bsize * UFS_NDADDR;
 132         sizepb = sblock.fs_bsize;
 133         for (i = 0; i < UFS_NIADDR; i++) {
 134                 sizepb *= NINDIR(&sblock);
 135                 idesc->id_level = i + 1;
 136                 if (DIP(&dino, di_ib[i])) {
 137                         idesc->id_blkno = DIP(&dino, di_ib[i]);
 138                         ret = iblock(idesc, remsize, BT_LEVEL1 + i);
 139                         if (ret & STOP)
 140                                 return (ret);
 141                 } else if (remsize > 0) {
 142                         idesc->id_lbn += sizepb / sblock.fs_bsize;
 143                         if (idesc->id_type == DATA) {
 144                                 /* An empty block in a directory XXX */
 145                                 getpathname(pathbuf, idesc->id_number,
 146                                                 idesc->id_number);
 147                                 pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
 148                                         pathbuf);
 149                                 if (reply("ADJUST LENGTH") == 1) {
 150                                         ginode(idesc->id_number, &ip);
 151                                         DIP_SET(ip.i_dp, di_size,
 152                                             DIP(ip.i_dp, di_size) - remsize);
 153                                         remsize = 0;
 154                                         printf(
 155                                             "YOU MUST RERUN FSCK AFTERWARDS\n");
 156                                         rerun = 1;
 157                                         inodirty(&ip);
 158                                         irelse(&ip);
 159                                         break;
 160                                 }
 161                         }
 162                 }
 163                 remsize -= sizepb;
 164         }
 165         return (KEEPON);
 166 }
 167
 168 static int
 169 iblock(struct inodesc *idesc, off_t isize, int type)
 170 {
 171         struct inode ip;
 172         struct bufarea *bp;
 173         int i, n, (*func)(struct inodesc *), nif;
 174         off_t sizepb;
 175         char buf[BUFSIZ];
 176         char pathbuf[MAXPATHLEN + 1];
 177
 178         if (idesc->id_type != DATA) {
 179                 func = idesc->id_func;
 180                 if (((n = (*func)(idesc)) & KEEPON) == 0)
 181                         return (n);
 182         } else
 183                 func = dirscan;
 184         bp = getdatablk(idesc->id_blkno, sblock.fs_bsize, type);
 185         if (bp->b_errs != 0) {
 186                 brelse(bp);
 187                 return (SKIP);
 188         }
 189         idesc->id_bp = bp;
 190         idesc->id_level--;
 191         for (sizepb = sblock.fs_bsize, i = 0; i < idesc->id_level; i++)
 192                 sizepb *= NINDIR(&sblock);
 193         if (howmany(isize, sizepb) > NINDIR(&sblock))
 194                 nif = NINDIR(&sblock);
 195         else
 196                 nif = howmany(isize, sizepb);
 197         if (idesc->id_func == pass1check && nif < NINDIR(&sblock)) {
 198                 for (i = nif; i < NINDIR(&sblock); i++) {
 199                         if (IBLK(bp, i) == 0)
 200                                 continue;
 201                         (void)sprintf(buf, "PARTIALLY TRUNCATED INODE I=%lu",
 202                             (u_long)idesc->id_number);
 203                         if (preen) {
 204                                 pfatal("%s", buf);
 205                         } else if (dofix(idesc, buf)) {
 206                                 IBLK_SET(bp, i, 0);
 207                                 dirty(bp);
 208                         }
 209                 }
 210                 flush(fswritefd, bp);
 211         }
 212         for (i = 0; i < nif; i++) {
 213                 if (IBLK(bp, i)) {
 214                         idesc->id_blkno = IBLK(bp, i);
 215                         bp->b_index = i;
 216                         if (idesc->id_level == 0) {
 217                                 idesc->id_lbn++;
 218                                 n = (*func)(idesc);
 219                         } else {
 220                                 n = iblock(idesc, isize, type - 1);
 221                                 idesc->id_level++;
 222                         }
 223                         if (n & STOP) {
 224                                 brelse(bp);
 225                                 return (n);
 226                         }
 227                 } else {
 228                         idesc->id_lbn += sizepb / sblock.fs_bsize;
 229                         if (idesc->id_type == DATA && isize > 0) {
 230                                 /* An empty block in a directory XXX */
 231                                 getpathname(pathbuf, idesc->id_number,
 232                                                 idesc->id_number);
 233                                 pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
 234                                         pathbuf);
 235                                 if (reply("ADJUST LENGTH") == 1) {
 236                                         ginode(idesc->id_number, &ip);
 237                                         DIP_SET(ip.i_dp, di_size,
 238                                             DIP(ip.i_dp, di_size) - isize);
 239                                         isize = 0;
 240                                         printf(
 241                                             "YOU MUST RERUN FSCK AFTERWARDS\n");
 242                                         rerun = 1;
 243                                         inodirty(&ip);
 244                                         brelse(bp);
 245                                         return(STOP);
 246                                 }
 247                         }
 248                 }
 249                 isize -= sizepb;
 250         }
 251         brelse(bp);
 252         return (KEEPON);
 253 }
 254
 255 /*
 256  * Finds the disk block address at the specified lbn within the inode
 257  * specified by dp.  This follows the whole tree and honors di_size and
 258  * di_extsize so it is a true test of reachability.  The lbn may be
 259  * negative if an extattr or indirect block is requested.
 260  */
 261 ufs2_daddr_t
 262 ino_blkatoff(union dinode *dp, ino_t ino, ufs_lbn_t lbn, int *frags,
 263     struct bufarea **bpp)
 264 {
 265         ufs_lbn_t tmpval;
 266         ufs_lbn_t cur;
 267         ufs_lbn_t next;
 268         int i;
 269
 270         *frags = 0;
 271         if (bpp != NULL)
 272                 *bpp = NULL;
 273         /*
 274          * Handle extattr blocks first.
 275          */
 276         if (lbn < 0 && lbn >= -UFS_NXADDR) {
 277                 lbn = -1 - lbn;
 278                 if (lbn > lblkno(&sblock, dp->dp2.di_extsize - 1))
 279                         return (0);
 280                 *frags = numfrags(&sblock,
 281                     sblksize(&sblock, dp->dp2.di_extsize, lbn));
 282                 return (dp->dp2.di_extb[lbn]);
 283         }
 284         /*
 285          * Now direct and indirect.
 286          */
 287         if (DIP(dp, di_mode) == IFLNK &&
 288             DIP(dp, di_size) < sblock.fs_maxsymlinklen)
 289                 return (0);
 290         if (lbn >= 0 && lbn < UFS_NDADDR) {
 291                 *frags = numfrags(&sblock,
 292                     sblksize(&sblock, DIP(dp, di_size), lbn));
 293                 return (DIP(dp, di_db[lbn]));
 294         }
 295         *frags = sblock.fs_frag;
 296
 297         for (i = 0, tmpval = NINDIR(&sblock), cur = UFS_NDADDR; i < UFS_NIADDR;
 298             i++, tmpval *= NINDIR(&sblock), cur = next) {
 299                 next = cur + tmpval;
 300                 if (lbn == -cur - i)
 301                         return (DIP(dp, di_ib[i]));
 302                 /*
 303                  * Determine whether the lbn in question is within this tree.
 304                  */
 305                 if (lbn < 0 && -lbn >= next)
 306                         continue;
 307                 if (lbn > 0 && lbn >= next)
 308                         continue;
 309                 if (DIP(dp, di_ib[i]) == 0)
 310                         return (0);
 311                 return (indir_blkatoff(DIP(dp, di_ib[i]), ino, -cur - i, lbn,
 312                     bpp));
 313         }
 314         pfatal("lbn %jd not in ino %ju\n", lbn, (uintmax_t)ino);
 315         return (0);
 316 }
 317
 318 /*
 319  * Fetch an indirect block to find the block at a given lbn.  The lbn
 320  * may be negative to fetch a specific indirect block pointer or positive
 321  * to fetch a specific block.
 322  */
 323 static ufs2_daddr_t
 324 indir_blkatoff(ufs2_daddr_t blk, ino_t ino, ufs_lbn_t cur, ufs_lbn_t lbn,
 325     struct bufarea **bpp)
 326 {
 327         struct bufarea *bp;
 328         ufs_lbn_t lbnadd;
 329         ufs_lbn_t base;
 330         int i, level;
 331
 332         level = lbn_level(cur);
 333         if (level == -1)
 334                 pfatal("Invalid indir lbn %jd in ino %ju\n",
 335                     lbn, (uintmax_t)ino);
 336         if (level == 0 && lbn < 0)
 337                 pfatal("Invalid lbn %jd in ino %ju\n",
 338                     lbn, (uintmax_t)ino);
 339         lbnadd = 1;
 340         base = -(cur + level);
 341         for (i = level; i > 0; i--)
 342                 lbnadd *= NINDIR(&sblock);
 343         if (lbn > 0)
 344                 i = (lbn - base) / lbnadd;
 345         else
 346                 i = (-lbn - base) / lbnadd;
 347         if (i < 0 || i >= NINDIR(&sblock)) {
 348                 pfatal("Invalid indirect index %d produced by lbn %jd "
 349                     "in ino %ju\n", i, lbn, (uintmax_t)ino);
 350                 return (0);
 351         }
 352         if (level == 0)
 353                 cur = base + (i * lbnadd);
 354         else
 355                 cur = -(base + (i * lbnadd)) - (level - 1);
 356         bp = getdatablk(blk, sblock.fs_bsize, BT_LEVEL1 + level);
 357         if (bp->b_errs != 0)
 358                 return (0);
 359         blk = IBLK(bp, i);
 360         bp->b_index = i;
 361         if (cur == lbn || blk == 0) {
 362                 if (bpp != NULL)
 363                         *bpp = bp;
 364                 else
 365                         brelse(bp);
 366                 return (blk);
 367         }
 368         brelse(bp);
 369         if (level == 0)
 370                 pfatal("Invalid lbn %jd at level 0 for ino %ju\n", lbn,
 371                     (uintmax_t)ino);
 372         return (indir_blkatoff(blk, ino, cur, lbn, bpp));
 373 }
 374
 375 /*
 376  * Check that a block in a legal block number.
 377  * Return 0 if in range, 1 if out of range.
 378  */
 379 int
 380 chkrange(ufs2_daddr_t blk, int cnt)
 381 {
 382         int c;
 383
 384         if (cnt <= 0 || blk <= 0 || blk > maxfsblock ||
 385             cnt - 1 > maxfsblock - blk) {
 386                 if (debug)
 387                         printf("out of range: blk %ld, offset %i, size %d\n",
 388                             (long)blk, (int)fragnum(&sblock, blk), cnt);
 389                 return (1);
 390         }
 391         if (cnt > sblock.fs_frag ||
 392             fragnum(&sblock, blk) + cnt > sblock.fs_frag) {
 393                 if (debug)
 394                         printf("bad size: blk %ld, offset %i, size %d\n",
 395                             (long)blk, (int)fragnum(&sblock, blk), cnt);
 396                 return (1);
 397         }
 398         c = dtog(&sblock, blk);
 399         if (blk < cgdmin(&sblock, c)) {
 400                 if ((blk + cnt) > cgsblock(&sblock, c)) {
 401                         if (debug) {
 402                                 printf("blk %ld < cgdmin %ld;",
 403                                     (long)blk, (long)cgdmin(&sblock, c));
 404                                 printf(" blk + cnt %ld > cgsbase %ld\n",
 405                                     (long)(blk + cnt),
 406                                     (long)cgsblock(&sblock, c));
 407                         }
 408                         return (1);
 409                 }
 410         } else {
 411                 if ((blk + cnt) > cgbase(&sblock, c+1)) {
 412                         if (debug)  {
 413                                 printf("blk %ld >= cgdmin %ld;",
 414                                     (long)blk, (long)cgdmin(&sblock, c));
 415                                 printf(" blk + cnt %ld > sblock.fs_fpg %ld\n",
 416                                     (long)(blk + cnt), (long)sblock.fs_fpg);
 417                         }
 418                         return (1);
 419                 }
 420         }
 421         return (0);
 422 }
 423
 424 /*
 425  * General purpose interface for reading inodes.
 426  *
 427  * firstinum and lastinum track contents of getnextino() cache (below).
 428  */
 429 static ino_t firstinum, lastinum;
 430 static struct bufarea inobuf;
 431
 432 void
 433 ginode(ino_t inumber, struct inode *ip)
 434 {
 435         ufs2_daddr_t iblk;
 436
 437         if (inumber < UFS_ROOTINO || inumber > maxino)
 438                 errx(EEXIT, "bad inode number %ju to ginode",
 439                     (uintmax_t)inumber);
 440         ip->i_number = inumber;
 441         if (inumber >= firstinum && inumber < lastinum) {
 442                 /* contents in getnextino() cache */
 443                 ip->i_bp = &inobuf;
 444                 inobuf.b_refcnt++;
 445                 inobuf.b_index = firstinum;
 446         } else if (icachebp != NULL &&
 447             inumber >= icachebp->b_index &&
 448             inumber < icachebp->b_index + INOPB(&sblock)) {
 449                 /* take an additional reference for the returned inode */
 450                 icachebp->b_refcnt++;
 451                 ip->i_bp = icachebp;
 452         } else {
 453                 iblk = ino_to_fsba(&sblock, inumber);
 454                 /* release our cache-hold reference on old icachebp */
 455                 if (icachebp != NULL)
 456                         brelse(icachebp);
 457                 icachebp = getdatablk(iblk, sblock.fs_bsize, BT_INODES);
 458                 if (icachebp->b_errs != 0) {
 459                         icachebp = NULL;
 460                         ip->i_bp = NULL;
 461                         ip->i_dp = &zino;
 462                         return;
 463                 }
 464                 /* take a cache-hold reference on new icachebp */
 465                 icachebp->b_refcnt++;
 466                 icachebp->b_index = rounddown(inumber, INOPB(&sblock));
 467                 ip->i_bp = icachebp;
 468         }
 469         if (sblock.fs_magic == FS_UFS1_MAGIC) {
 470                 ip->i_dp = (union dinode *)
 471                     &ip->i_bp->b_un.b_dinode1[inumber - ip->i_bp->b_index];
 472                 return;
 473         }
 474         ip->i_dp = (union dinode *)
 475             &ip->i_bp->b_un.b_dinode2[inumber - ip->i_bp->b_index];
 476         if (ffs_verify_dinode_ckhash(&sblock, (struct ufs2_dinode *)ip->i_dp)) {
 477                 pwarn("INODE CHECK-HASH FAILED");
 478                 prtinode(ip);
 479                 if (preen || reply("FIX") != 0) {
 480                         if (preen)
 481                                 printf(" (FIXED)\n");
 482                         ffs_update_dinode_ckhash(&sblock,
 483                             (struct ufs2_dinode *)ip->i_dp);
 484                         inodirty(ip);
 485                 }
 486         }
 487 }
 488
 489 /*
 490  * Release a held inode.
 491  */
 492 void
 493 irelse(struct inode *ip)
 494 {
 495
 496         /* Check for failed inode read */
 497         if (ip->i_bp == NULL)
 498                 return;
 499         if (ip->i_bp->b_refcnt <= 0)
 500                 pfatal("irelse: releasing unreferenced ino %ju\n",
 501                     (uintmax_t) ip->i_number);
 502         brelse(ip->i_bp);
 503 }
 504
 505 /*
 506  * Special purpose version of ginode used to optimize first pass
 507  * over all the inodes in numerical order.
 508  */
 509 static ino_t nextinum, lastvalidinum;
 510 static long readcount, readpercg, fullcnt, inobufsize, partialcnt, partialsize;
 511
 512 union dinode *
 513 getnextinode(ino_t inumber, int rebuildcg)
 514 {
 515         int j;
 516         long size;
 517         mode_t mode;
 518         ufs2_daddr_t ndb, blk;
 519         union dinode *dp;
 520         struct inode ip;
 521         static caddr_t nextinop;
 522
 523         if (inumber != nextinum++ || inumber > lastvalidinum)
 524                 errx(EEXIT, "bad inode number %ju to nextinode",
 525                     (uintmax_t)inumber);
 526         if (inumber >= lastinum) {
 527                 readcount++;
 528                 firstinum = lastinum;
 529                 blk = ino_to_fsba(&sblock, lastinum);
 530                 if (readcount % readpercg == 0) {
 531                         size = partialsize;
 532                         lastinum += partialcnt;
 533                 } else {
 534                         size = inobufsize;
 535                         lastinum += fullcnt;
 536                 }
 537                 /*
 538                  * Flush old contents in case they have been updated.
 539                  * If getblk encounters an error, it will already have zeroed
 540                  * out the buffer, so we do not need to do so here.
 541                  */
 542                 if (inobuf.b_refcnt != 0)
 543                         pfatal("Non-zero getnextinode() ref count %d\n",
 544                             inobuf.b_refcnt);
 545                 flush(fswritefd, &inobuf);
 546                 getblk(&inobuf, blk, size);
 547                 nextinop = inobuf.b_un.b_buf;
 548         }
 549         dp = (union dinode *)nextinop;
 550         if (sblock.fs_magic == FS_UFS1_MAGIC)
 551                 nextinop += sizeof(struct ufs1_dinode);
 552         else
 553                 nextinop += sizeof(struct ufs2_dinode);
 554         if ((ckhashadd & CK_INODE) != 0) {
 555                 ffs_update_dinode_ckhash(&sblock, (struct ufs2_dinode *)dp);
 556                 dirty(&inobuf);
 557         }
 558         if (ffs_verify_dinode_ckhash(&sblock, (struct ufs2_dinode *)dp) != 0) {
 559                 pwarn("INODE CHECK-HASH FAILED");
 560                 ip.i_bp = NULL;
 561                 ip.i_dp = dp;
 562                 ip.i_number = inumber;
 563                 prtinode(&ip);
 564                 if (preen || reply("FIX") != 0) {
 565                         if (preen)
 566                                 printf(" (FIXED)\n");
 567                         ffs_update_dinode_ckhash(&sblock,
 568                             (struct ufs2_dinode *)dp);
 569                         dirty(&inobuf);
 570                 }
 571         }
 572         if (rebuildcg && (char *)dp == inobuf.b_un.b_buf) {
 573                 /*
 574                  * Try to determine if we have reached the end of the
 575                  * allocated inodes.
 576                  */
 577                 mode = DIP(dp, di_mode) & IFMT;
 578                 if (mode == 0) {
 579                         if (memcmp(dp->dp2.di_db, zino.dp2.di_db,
 580                                 UFS_NDADDR * sizeof(ufs2_daddr_t)) ||
 581                               memcmp(dp->dp2.di_ib, zino.dp2.di_ib,
 582                                 UFS_NIADDR * sizeof(ufs2_daddr_t)) ||
 583                               dp->dp2.di_mode || dp->dp2.di_size)
 584                                 return (NULL);
 585                         return (dp);
 586                 }
 587                 if (!ftypeok(dp))
 588                         return (NULL);
 589                 ndb = howmany(DIP(dp, di_size), sblock.fs_bsize);
 590                 if (ndb < 0)
 591                         return (NULL);
 592                 if (mode == IFBLK || mode == IFCHR)
 593                         ndb++;
 594                 if (mode == IFLNK) {
 595                         /*
 596                          * Fake ndb value so direct/indirect block checks below
 597                          * will detect any garbage after symlink string.
 598                          */
 599                         if (DIP(dp, di_size) < (off_t)sblock.fs_maxsymlinklen) {
 600                                 ndb = howmany(DIP(dp, di_size),
 601                                     sizeof(ufs2_daddr_t));
 602                                 if (ndb > UFS_NDADDR) {
 603                                         j = ndb - UFS_NDADDR;
 604                                         for (ndb = 1; j > 1; j--)
 605                                                 ndb *= NINDIR(&sblock);
 606                                         ndb += UFS_NDADDR;
 607                                 }
 608                         }
 609                 }
 610                 for (j = ndb; ndb < UFS_NDADDR && j < UFS_NDADDR; j++)
 611                         if (DIP(dp, di_db[j]) != 0)
 612                                 return (NULL);
 613                 for (j = 0, ndb -= UFS_NDADDR; ndb > 0; j++)
 614                         ndb /= NINDIR(&sblock);
 615                 for (; j < UFS_NIADDR; j++)
 616                         if (DIP(dp, di_ib[j]) != 0)
 617                                 return (NULL);
 618         }
 619         return (dp);
 620 }
 621
 622 void
 623 setinodebuf(int cg, ino_t inosused)
 624 {
 625         ino_t inum;
 626
 627         inum = cg * sblock.fs_ipg;
 628         lastvalidinum = inum + inosused - 1;
 629         nextinum = inum;
 630         lastinum = inum;
 631         readcount = 0;
 632         /* Flush old contents in case they have been updated */
 633         flush(fswritefd, &inobuf);
 634         inobuf.b_bno = 0;
 635         if (inobuf.b_un.b_buf == NULL) {
 636                 inobufsize = blkroundup(&sblock,
 637                     MAX(INOBUFSIZE, sblock.fs_bsize));
 638                 initbarea(&inobuf, BT_INODES);
 639                 if ((inobuf.b_un.b_buf = Malloc((unsigned)inobufsize)) == NULL)
 640                         errx(EEXIT, "cannot allocate space for inode buffer");
 641         }
 642         fullcnt = inobufsize / ((sblock.fs_magic == FS_UFS1_MAGIC) ?
 643             sizeof(struct ufs1_dinode) : sizeof(struct ufs2_dinode));
 644         readpercg = inosused / fullcnt;
 645         partialcnt = inosused % fullcnt;
 646         partialsize = fragroundup(&sblock,
 647             partialcnt * ((sblock.fs_magic == FS_UFS1_MAGIC) ?
 648             sizeof(struct ufs1_dinode) : sizeof(struct ufs2_dinode)));
 649         if (partialcnt != 0) {
 650                 readpercg++;
 651         } else {
 652                 partialcnt = fullcnt;
 653                 partialsize = inobufsize;
 654         }
 655 }
 656
 657 int
 658 freeblock(struct inodesc *idesc)
 659 {
 660         struct dups *dlp;
 661         struct bufarea *cgbp;
 662         struct cg *cgp;
 663         ufs2_daddr_t blkno;
 664         long size, nfrags;
 665
 666         blkno = idesc->id_blkno;
 667         if (idesc->id_type == SNAP) {
 668                 pfatal("clearing a snapshot dinode\n");
 669                 return (STOP);
 670         }
 671         size = lfragtosize(&sblock, idesc->id_numfrags);
 672         if (snapblkfree(&sblock, blkno, size, idesc->id_number,
 673             std_checkblkavail))
 674                 return (KEEPON);
 675         for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
 676                 if (chkrange(blkno, 1)) {
 677                         return (SKIP);
 678                 } else if (testbmap(blkno)) {
 679                         for (dlp = duplist; dlp; dlp = dlp->next) {
 680                                 if (dlp->dup != blkno)
 681                                         continue;
 682                                 dlp->dup = duplist->dup;
 683                                 dlp = duplist;
 684                                 duplist = duplist->next;
 685                                 free((char *)dlp);
 686                                 break;
 687                         }
 688                         if (dlp == NULL) {
 689                                 clrbmap(blkno);
 690                                 n_blks--;
 691                         }
 692                 }
 693         }
 694         /*
 695          * If all successfully returned, account for them.
 696          */
 697         if (nfrags == 0) {
 698                 cgbp = cglookup(dtog(&sblock, idesc->id_blkno));
 699                 cgp = cgbp->b_un.b_cg;
 700                 if (idesc->id_numfrags == sblock.fs_frag)
 701                         cgp->cg_cs.cs_nbfree++;
 702                 else
 703                         cgp->cg_cs.cs_nffree += idesc->id_numfrags;
 704                 cgdirty(cgbp);
 705         }
 706         return (KEEPON);
 707 }
 708
 709 /*
 710  * Prepare a snapshot file for being removed.
 711  */
 712 void
 713 snapremove(ino_t inum)
 714 {
 715         struct inodesc idesc;
 716         struct inode ip;
 717         int i;
 718
 719         for (i = 0; i < snapcnt; i++)
 720                 if (snaplist[i].i_number == inum)
 721                         break;
 722         if (i == snapcnt)
 723                 ginode(inum, &ip);
 724         else
 725                 ip = snaplist[i];
 726         if ((DIP(ip.i_dp, di_flags) & SF_SNAPSHOT) == 0) {
 727                 printf("snapremove: inode %jd is not a snapshot\n",
 728                     (intmax_t)inum);
 729                 if (i == snapcnt)
 730                         irelse(&ip);
 731                 return;
 732         }
 733         if (debug)
 734                 printf("snapremove: remove %sactive snapshot %jd\n",
 735                     i == snapcnt ? "in" : "", (intmax_t)inum);
 736         /*
 737          * If on active snapshot list, remove it.
 738          */
 739         if (i < snapcnt) {
 740                 for (i++; i < FSMAXSNAP; i++) {
 741                         if (sblock.fs_snapinum[i] == 0)
 742                                 break;
 743                         snaplist[i - 1] = snaplist[i];
 744                         sblock.fs_snapinum[i - 1] = sblock.fs_snapinum[i];
 745                 }
 746                 sblock.fs_snapinum[i - 1] = 0;
 747                 bzero(&snaplist[i - 1], sizeof(struct inode));
 748                 snapcnt--;
 749         }
 750         idesc.id_type = SNAP;
 751         idesc.id_func = snapclean;
 752         idesc.id_number = inum;
 753         (void)ckinode(ip.i_dp, &idesc);
 754         DIP_SET(ip.i_dp, di_flags, DIP(ip.i_dp, di_flags) & ~SF_SNAPSHOT);
 755         inodirty(&ip);
 756         irelse(&ip);
 757 }
 758
 759 static int
 760 snapclean(struct inodesc *idesc)
 761 {
 762         ufs2_daddr_t blkno;
 763         struct bufarea *bp;
 764         union dinode *dp;
 765
 766         blkno = idesc->id_blkno;
 767         if (blkno == 0)
 768                 return (KEEPON);
 769
 770         bp = idesc->id_bp;
 771         dp = idesc->id_dp;
 772         if (blkno == BLK_NOCOPY || blkno == BLK_SNAP) {
 773                 if (idesc->id_lbn < UFS_NDADDR)
 774                         DIP_SET(dp, di_db[idesc->id_lbn], 0);
 775                 else
 776                         IBLK_SET(bp, bp->b_index, 0);
 777                 dirty(bp);
 778         }
 779         return (KEEPON);
 780 }
 781
 782 /*
 783  * Notification that a block is being freed. Return zero if the free
 784  * should be allowed to proceed. Return non-zero if the snapshot file
 785  * wants to claim the block. The block will be claimed if it is an
 786  * uncopied part of one of the snapshots. It will be freed if it is
 787  * either a BLK_NOCOPY or has already been copied in all of the snapshots.
 788  * If a fragment is being freed, then all snapshots that care about
 789  * it must make a copy since a snapshot file can only claim full sized
 790  * blocks. Note that if more than one snapshot file maps the block,
 791  * we can pick one at random to claim it. Since none of the snapshots
 792  * can change, we are assurred that they will all see the same unmodified
 793  * image. When deleting a snapshot file (see ino_trunc above), we
 794  * must push any of these claimed blocks to one of the other snapshots
 795  * that maps it. These claimed blocks are easily identified as they will
 796  * have a block number equal to their logical block number within the
 797  * snapshot. A copied block can never have this property because they
 798  * must always have been allocated from a BLK_NOCOPY location.
 799  */
 800 int
 801 snapblkfree(struct fs *fs, ufs2_daddr_t bno, long size, ino_t inum,
 802         ufs2_daddr_t (*checkblkavail)(ufs2_daddr_t blkno, long frags))
 803 {
 804         union dinode *dp;
 805         struct inode ip;
 806         struct bufarea *snapbp;
 807         ufs_lbn_t lbn;
 808         ufs2_daddr_t blkno, relblkno;
 809         int i, frags, claimedblk, copydone;
 810
 811         /* If no snapshots, nothing to do */
 812         if (snapcnt == 0)
 813                 return (0);
 814         if (debug)
 815                 printf("snapblkfree: in ino %jd free blkno %jd, size %jd\n",
 816                     (intmax_t)inum, (intmax_t)bno, (intmax_t)size);
 817         relblkno = blknum(fs, bno);
 818         lbn = fragstoblks(fs, relblkno);
 819         /* Direct blocks are always pre-copied */
 820         if (lbn < UFS_NDADDR)
 821                 return (0);
 822         copydone = 0;
 823         claimedblk = 0;
 824         for (i = 0; i < snapcnt; i++) {
 825                 /*
 826                  * Lookup block being freed.
 827                  */
 828                 ip = snaplist[i];
 829                 dp = ip.i_dp;
 830                 blkno = ino_blkatoff(dp, inum != 0 ? inum : ip.i_number,
 831                     lbn, &frags, &snapbp);
 832                 /*
 833                  * Check to see if block needs to be copied.
 834                  */
 835                 if (blkno == 0) {
 836                         /*
 837                          * A block that we map is being freed. If it has not
 838                          * been claimed yet, we will claim or copy it (below).
 839                          */
 840                         claimedblk = 1;
 841                 } else if (blkno == BLK_SNAP) {
 842                         /*
 843                          * No previous snapshot claimed the block,
 844                          * so it will be freed and become a BLK_NOCOPY
 845                          * (don't care) for us.
 846                          */
 847                         if (claimedblk)
 848                                 pfatal("snapblkfree: inconsistent block type");
 849                         IBLK_SET(snapbp, snapbp->b_index, BLK_NOCOPY);
 850                         dirty(snapbp);
 851                         brelse(snapbp);
 852                         continue;
 853                 } else /* BLK_NOCOPY or default */ {
 854                         /*
 855                          * If the snapshot has already copied the block
 856                          * (default), or does not care about the block,
 857                          * it is not needed.
 858                          */
 859                         brelse(snapbp);
 860                         continue;
 861                 }
 862                 /*
 863                  * If this is a full size block, we will just grab it
 864                  * and assign it to the snapshot inode. Otherwise we
 865                  * will proceed to copy it. See explanation for this
 866                  * routine as to why only a single snapshot needs to
 867                  * claim this block.
 868                  */
 869                 if (size == fs->fs_bsize) {
 870                         if (debug)
 871                                 printf("Grabonremove snapshot %ju lbn %jd "
 872                                     "from inum %ju\n", (intmax_t)ip.i_number,
 873                                     (intmax_t)lbn, (uintmax_t)inum);
 874                         IBLK_SET(snapbp, snapbp->b_index, relblkno);
 875                         dirty(snapbp);
 876                         brelse(snapbp);
 877                         DIP_SET(dp, di_blocks,
 878                             DIP(dp, di_blocks) + btodb(size));
 879                         inodirty(&ip);
 880                         return (1);
 881                 }
 882
 883                 /* First time through, read the contents of the old block. */
 884                 if (copydone == 0) {
 885                         copydone = 1;
 886                         if (blread(fsreadfd, copybuf, fsbtodb(fs, relblkno),
 887                             fs->fs_bsize) != 0) {
 888                                 pfatal("Could not read snapshot %ju block "
 889                                     "%jd\n", (intmax_t)ip.i_number,
 890                                     (intmax_t)relblkno);
 891                                 continue;
 892                         }
 893                 }
 894                 /*
 895                  * This allocation will never require any additional
 896                  * allocations for the snapshot inode.
 897                  */
 898                 blkno = allocblk(dtog(fs, relblkno), fs->fs_frag,
 899                     checkblkavail);
 900                 if (blkno == 0) {
 901                         pfatal("Could not allocate block for snapshot %ju\n",
 902                             (intmax_t)ip.i_number);
 903                         continue;
 904                 }
 905                 if (debug)
 906                         printf("Copyonremove: snapino %jd lbn %jd for inum %ju "
 907                             "size %ld new blkno %jd\n", (intmax_t)ip.i_number,
 908                             (intmax_t)lbn, (uintmax_t)inum, size,
 909                             (intmax_t)blkno);
 910                 blwrite(fswritefd, copybuf, fsbtodb(fs, blkno), fs->fs_bsize);
 911                 IBLK_SET(snapbp, snapbp->b_index, blkno);
 912                 dirty(snapbp);
 913                 brelse(snapbp);
 914                 DIP_SET(dp, di_blocks,
 915                     DIP(dp, di_blocks) + btodb(fs->fs_bsize));
 916                 inodirty(&ip);
 917         }
 918         return (0);
 919 }
 920
 921 /*
 922  * Notification that a block is being written. Return if the block
 923  * is part of a snapshot as snapshots never track other snapshots.
 924  * The block will be copied in all of the snapshots that are tracking
 925  * it and have not yet copied it. Some buffers may hold more than one
 926  * block. Here we need to check each block in the buffer.
 927  */
 928 void
 929 copyonwrite(struct fs *fs, struct bufarea *bp,
 930         ufs2_daddr_t (*checkblkavail)(ufs2_daddr_t blkno, long frags))
 931 {
 932         ufs2_daddr_t copyblkno;
 933         long i, numblks;
 934
 935         /* If no snapshots, nothing to do. */
 936         if (snapcnt == 0)
 937                 return;
 938         numblks = blkroundup(fs, bp->b_size) / fs->fs_bsize;
 939         if (debug)
 940                 prtbuf(bp, "copyonwrite: checking %jd block%s in buffer",
 941                     (intmax_t)numblks, numblks > 1 ? "s" : "");
 942         copyblkno = blknum(fs, dbtofsb(fs, bp->b_bno));
 943         for (i = 0; i < numblks; i++) {
 944                 chkcopyonwrite(fs, copyblkno, checkblkavail);
 945                 copyblkno += fs->fs_frag;
 946         }
 947 }
 948
 949 static void
 950 chkcopyonwrite(struct fs *fs, ufs2_daddr_t copyblkno,
 951         ufs2_daddr_t (*checkblkavail)(ufs2_daddr_t blkno, long frags))
 952 {
 953         struct inode ip;
 954         union dinode *dp;
 955         struct bufarea *snapbp;
 956         ufs2_daddr_t blkno;
 957         int i, frags, copydone;
 958         ufs_lbn_t lbn;
 959
 960         lbn = fragstoblks(fs, copyblkno);
 961         /* Direct blocks are always pre-copied */
 962         if (lbn < UFS_NDADDR)
 963                 return;
 964         copydone = 0;
 965         for (i = 0; i < snapcnt; i++) {
 966                 /*
 967                  * Lookup block being freed.
 968                  */
 969                 ip = snaplist[i];
 970                 dp = ip.i_dp;
 971                 blkno = ino_blkatoff(dp, ip.i_number, lbn, &frags, &snapbp);
 972                 /*
 973                  * Check to see if block needs to be copied.
 974                  */
 975                 if (blkno != 0) {
 976                         /*
 977                          * A block that we have already copied or don't track.
 978                          */
 979                         brelse(snapbp);
 980                         continue;
 981                 }
 982                 /* First time through, read the contents of the old block. */
 983                 if (copydone == 0) {
 984                         copydone = 1;
 985                         if (blread(fsreadfd, copybuf, fsbtodb(fs, copyblkno),
 986                             fs->fs_bsize) != 0) {
 987                                 pfatal("Could not read snapshot %ju block "
 988                                     "%jd\n", (intmax_t)ip.i_number,
 989                                     (intmax_t)copyblkno);
 990                                 continue;
 991                         }
 992                 }
 993                 /*
 994                  * This allocation will never require any additional
 995                  * allocations for the snapshot inode.
 996                  */
 997                 if ((blkno = allocblk(dtog(fs, copyblkno), fs->fs_frag,
 998                     checkblkavail)) == 0) {
 999                         pfatal("Could not allocate block for snapshot %ju\n",
1000                             (intmax_t)ip.i_number);
1001                         continue;
1002                 }
1003                 if (debug)
1004                         prtbuf(snapbp, "Copyonwrite: snapino %jd lbn %jd using "
1005                             "blkno %ju setting in buffer",
1006                             (intmax_t)ip.i_number, (intmax_t)lbn,
1007                             (intmax_t)blkno);
1008                 blwrite(fswritefd, copybuf, fsbtodb(fs, blkno), fs->fs_bsize);
1009                 IBLK_SET(snapbp, snapbp->b_index, blkno);
1010                 dirty(snapbp);
1011                 brelse(snapbp);
1012                 DIP_SET(dp, di_blocks,
1013                     DIP(dp, di_blocks) + btodb(fs->fs_bsize));
1014                 inodirty(&ip);
1015         }
1016         return;
1017 }
1018
1019 /*
1020  * Traverse an inode and check that its block count is correct
1021  * fixing it if necessary.
1022  */
1023 void
1024 check_blkcnt(struct inode *ip)
1025 {
1026         struct inodesc idesc;
1027         union dinode *dp;
1028         ufs2_daddr_t ndb;
1029         int j, ret, offset;
1030
1031         dp = ip->i_dp;
1032         memset(&idesc, 0, sizeof(struct inodesc));
1033         idesc.id_func = pass1check;
1034         idesc.id_number = ip->i_number;
1035         idesc.id_type = (DIP(dp, di_flags) & SF_SNAPSHOT) == 0 ? ADDR : SNAP;
1036         (void)ckinode(dp, &idesc);
1037         if (sblock.fs_magic == FS_UFS2_MAGIC && dp->dp2.di_extsize > 0) {
1038                 ndb = howmany(dp->dp2.di_extsize, sblock.fs_bsize);
1039                 for (j = 0; j < UFS_NXADDR; j++) {
1040                         if (--ndb == 0 &&
1041                             (offset = blkoff(&sblock, dp->dp2.di_extsize)) != 0)
1042                                 idesc.id_numfrags = numfrags(&sblock,
1043                                     fragroundup(&sblock, offset));
1044                         else
1045                                 idesc.id_numfrags = sblock.fs_frag;
1046                         if (dp->dp2.di_extb[j] == 0)
1047                                 continue;
1048                         idesc.id_blkno = dp->dp2.di_extb[j];
1049                         ret = (*idesc.id_func)(&idesc);
1050                         if (ret & STOP)
1051                                 break;
1052                 }
1053         }
1054         idesc.id_entryno *= btodb(sblock.fs_fsize);
1055         if (DIP(dp, di_blocks) != idesc.id_entryno) {
1056                 if (!(sujrecovery && preen)) {
1057                         pwarn("INCORRECT BLOCK COUNT I=%lu (%ju should be %ju)",
1058                             (u_long)idesc.id_number,
1059                             (uintmax_t)DIP(dp, di_blocks),
1060                             (uintmax_t)idesc.id_entryno);
1061                         if (preen)
1062                                 printf(" (CORRECTED)\n");
1063                         else if (reply("CORRECT") == 0)
1064                                 return;
1065                 }
1066                 if (bkgrdflag == 0) {
1067                         DIP_SET(dp, di_blocks, idesc.id_entryno);
1068                         inodirty(ip);
1069                 } else {
1070                         cmd.value = idesc.id_number;
1071                         cmd.size = idesc.id_entryno - DIP(dp, di_blocks);
1072                         if (debug)
1073                                 printf("adjblkcnt ino %ju amount %lld\n",
1074                                     (uintmax_t)cmd.value, (long long)cmd.size);
1075                         if (sysctl(adjblkcnt, MIBSIZE, 0, 0,
1076                             &cmd, sizeof cmd) == -1)
1077                                 rwerror("ADJUST INODE BLOCK COUNT", cmd.value);
1078                 }
1079         }
1080 }
1081
1082 void
1083 freeinodebuf(void)
1084 {
1085         struct bufarea *bp;
1086         int i;
1087
1088         /*
1089          * Flush old contents in case they have been updated.
1090          */
1091         flush(fswritefd, &inobuf);
1092         if (inobuf.b_un.b_buf != NULL)
1093                 free((char *)inobuf.b_un.b_buf);
1094         inobuf.b_un.b_buf = NULL;
1095         firstinum = lastinum = 0;
1096         /*
1097          * Reload the snapshot inodes in case any of them changed.
1098          */
1099         for (i = 0; i < snapcnt; i++) {
1100                 bp = snaplist[i].i_bp;
1101                 bp->b_errs = blread(fsreadfd, bp->b_un.b_buf, bp->b_bno,
1102                     bp->b_size);
1103         }
1104 }
1105
1106 /*
1107  * Routines to maintain information about directory inodes.
1108  * This is built during the first pass and used during the
1109  * second and third passes.
1110  *
1111  * Enter inodes into the cache.
1112  */
1113 struct inoinfo *
1114 cacheino(union dinode *dp, ino_t inumber)
1115 {
1116         struct inoinfo *inp;
1117         int i, blks;
1118
1119         if (getinoinfo(inumber) != NULL)
1120                 pfatal("cacheino: duplicate entry for ino %jd\n",
1121                     (intmax_t)inumber);
1122         if (howmany(DIP(dp, di_size), sblock.fs_bsize) > UFS_NDADDR)
1123                 blks = UFS_NDADDR + UFS_NIADDR;
1124         else if (DIP(dp, di_size) > 0)
1125                 blks = howmany(DIP(dp, di_size), sblock.fs_bsize);
1126         else
1127                 blks = 1;
1128         inp = (struct inoinfo *)
1129                 Malloc(sizeof(*inp) + (blks - 1) * sizeof(ufs2_daddr_t));
1130         if (inp == NULL)
1131                 errx(EEXIT, "cannot increase directory list");
1132         SLIST_INSERT_HEAD(&inphash[inumber % dirhash], inp, i_hash);
1133         inp->i_flags = 0;
1134         inp->i_parent = inumber == UFS_ROOTINO ? UFS_ROOTINO : (ino_t)0;
1135         inp->i_dotdot = (ino_t)0;
1136         inp->i_number = inumber;
1137         inp->i_isize = DIP(dp, di_size);
1138         inp->i_numblks = blks;
1139         for (i = 0; i < MIN(blks, UFS_NDADDR); i++)
1140                 inp->i_blks[i] = DIP(dp, di_db[i]);
1141         if (blks > UFS_NDADDR)
1142                 for (i = 0; i < UFS_NIADDR; i++)
1143                         inp->i_blks[UFS_NDADDR + i] = DIP(dp, di_ib[i]);
1144         if (inplast == listmax) {
1145                 listmax += 100;
1146                 inpsort = (struct inoinfo **)reallocarray((char *)inpsort,
1147                     listmax, sizeof(struct inoinfo *));
1148                 if (inpsort == NULL)
1149                         errx(EEXIT, "cannot increase directory list");
1150         }
1151         inpsort[inplast++] = inp;
1152         return (inp);
1153 }
1154
1155 /*
1156  * Look up an inode cache structure.
1157  */
1158 struct inoinfo *
1159 getinoinfo(ino_t inumber)
1160 {
1161         struct inoinfo *inp;
1162
1163         SLIST_FOREACH(inp, &inphash[inumber % dirhash], i_hash) {
1164                 if (inp->i_number != inumber)
1165                         continue;
1166                 return (inp);
1167         }
1168         return (NULL);
1169 }
1170
1171 /*
1172  * Remove an entry from the inode cache and disk-order sorted list.
1173  * Return 0 on success and 1 on failure.
1174  */
1175 int
1176 removecachedino(ino_t inumber)
1177 {
1178         struct inoinfo *inp, **inpp;
1179         char *listtype;
1180
1181         listtype = "hash";
1182         SLIST_FOREACH(inp, &inphash[inumber % dirhash], i_hash) {
1183                 if (inp->i_number != inumber)
1184                         continue;
1185                 SLIST_REMOVE(&inphash[inumber % dirhash], inp, inoinfo, i_hash);
1186                 for (inpp = &inpsort[inplast - 1]; inpp >= inpsort; inpp--) {
1187                         if (*inpp != inp)
1188                                 continue;
1189                         *inpp = inpsort[inplast - 1];
1190                         inplast--;
1191                         free(inp);
1192                         return (0);
1193                 }
1194                 listtype = "sort";
1195                 break;
1196         }
1197         pfatal("removecachedino: entry for ino %jd not found on %s list\n",
1198             (intmax_t)inumber, listtype);
1199         return (1);
1200 }
1201
1202 /*
1203  * Clean up all the inode cache structure.
1204  */
1205 void
1206 inocleanup(void)
1207 {
1208         struct inoinfo **inpp;
1209
1210         if (inphash == NULL)
1211                 return;
1212         for (inpp = &inpsort[inplast - 1]; inpp >= inpsort; inpp--)
1213                 free((char *)(*inpp));
1214         free((char *)inphash);
1215         inphash = NULL;
1216         free((char *)inpsort);
1217         inpsort = NULL;
1218 }
1219
1220 void
1221 inodirty(struct inode *ip)
1222 {
1223
1224         if (sblock.fs_magic == FS_UFS2_MAGIC)
1225                 ffs_update_dinode_ckhash(&sblock,
1226                     (struct ufs2_dinode *)ip->i_dp);
1227         dirty(ip->i_bp);
1228 }
1229
1230 void
1231 clri(struct inodesc *idesc, const char *type, int flag)
1232 {
1233         union dinode *dp;
1234         struct inode ip;
1235
1236         ginode(idesc->id_number, &ip);
1237         dp = ip.i_dp;
1238         if (flag == 1) {
1239                 pwarn("%s %s", type,
1240                     (DIP(dp, di_mode) & IFMT) == IFDIR ? "DIR" : "FILE");
1241                 prtinode(&ip);
1242                 printf("\n");
1243         }
1244         if (preen || reply("CLEAR") == 1) {
1245                 if (preen)
1246                         printf(" (CLEARED)\n");
1247                 n_files--;
1248                 if (bkgrdflag == 0) {
1249                         if (idesc->id_type == SNAP) {
1250                                 snapremove(idesc->id_number);
1251                                 idesc->id_type = ADDR;
1252                         }
1253                         (void)ckinode(dp, idesc);
1254                         inoinfo(idesc->id_number)->ino_state = USTATE;
1255                         clearinode(dp);
1256                         inodirty(&ip);
1257                 } else {
1258                         cmd.value = idesc->id_number;
1259                         cmd.size = -DIP(dp, di_nlink);
1260                         if (debug)
1261                                 printf("adjrefcnt ino %ld amt %lld\n",
1262                                     (long)cmd.value, (long long)cmd.size);
1263                         if (sysctl(adjrefcnt, MIBSIZE, 0, 0,
1264                             &cmd, sizeof cmd) == -1)
1265                                 rwerror("ADJUST INODE", cmd.value);
1266                 }
1267         }
1268         irelse(&ip);
1269 }
1270
1271 int
1272 findname(struct inodesc *idesc)
1273 {
1274         struct direct *dirp = idesc->id_dirp;
1275
1276         if (dirp->d_ino != idesc->id_parent || idesc->id_entryno < 2) {
1277                 idesc->id_entryno++;
1278                 return (KEEPON);
1279         }
1280         memmove(idesc->id_name, dirp->d_name, (size_t)dirp->d_namlen + 1);
1281         return (STOP|FOUND);
1282 }
1283
1284 int
1285 findino(struct inodesc *idesc)
1286 {
1287         struct direct *dirp = idesc->id_dirp;
1288
1289         if (dirp->d_ino == 0)
1290                 return (KEEPON);
1291         if (strcmp(dirp->d_name, idesc->id_name) == 0 &&
1292             dirp->d_ino >= UFS_ROOTINO && dirp->d_ino <= maxino) {
1293                 idesc->id_parent = dirp->d_ino;
1294                 return (STOP|FOUND);
1295         }
1296         return (KEEPON);
1297 }
1298
1299 int
1300 clearentry(struct inodesc *idesc)
1301 {
1302         struct direct *dirp = idesc->id_dirp;
1303
1304         if (dirp->d_ino != idesc->id_parent || idesc->id_entryno < 2) {
1305                 idesc->id_entryno++;
1306                 return (KEEPON);
1307         }
1308         dirp->d_ino = 0;
1309         return (STOP|FOUND|ALTERED);
1310 }
1311
1312 void
1313 prtinode(struct inode *ip)
1314 {
1315         char *p;
1316         union dinode *dp;
1317         struct passwd *pw;
1318         time_t t;
1319
1320         dp = ip->i_dp;
1321         printf(" I=%lu ", (u_long)ip->i_number);
1322         if (ip->i_number < UFS_ROOTINO || ip->i_number > maxino)
1323                 return;
1324         printf(" OWNER=");
1325         if ((pw = getpwuid((int)DIP(dp, di_uid))) != NULL)
1326                 printf("%s ", pw->pw_name);
1327         else
1328                 printf("%u ", (unsigned)DIP(dp, di_uid));
1329         printf("MODE=%o\n", DIP(dp, di_mode));
1330         if (preen)
1331                 printf("%s: ", cdevname);
1332         printf("SIZE=%ju ", (uintmax_t)DIP(dp, di_size));
1333         t = DIP(dp, di_mtime);
1334         if ((p = ctime(&t)) != NULL)
1335                 printf("MTIME=%12.12s %4.4s ", &p[4], &p[20]);
1336 }
1337
1338 void
1339 blkerror(ino_t ino, const char *type, ufs2_daddr_t blk)
1340 {
1341
1342         pfatal("%jd %s I=%ju", (intmax_t)blk, type, (uintmax_t)ino);
1343         printf("\n");
1344         switch (inoinfo(ino)->ino_state) {
1345
1346         case FSTATE:
1347         case FZLINK:
1348                 inoinfo(ino)->ino_state = FCLEAR;
1349                 return;
1350
1351         case DSTATE:
1352         case DZLINK:
1353                 inoinfo(ino)->ino_state = DCLEAR;
1354                 return;
1355
1356         case FCLEAR:
1357         case DCLEAR:
1358                 return;
1359
1360         default:
1361                 errx(EEXIT, "BAD STATE %d TO BLKERR", inoinfo(ino)->ino_state);
1362                 /* NOTREACHED */
1363         }
1364 }
1365
1366 /*
1367  * allocate an unused inode
1368  */
1369 ino_t
1370 allocino(ino_t request, int type)
1371 {
1372         ino_t ino;
1373         struct inode ip;
1374         union dinode *dp;
1375         struct bufarea *cgbp;
1376         struct cg *cgp;
1377         int cg, anyino;
1378
1379         anyino = 0;
1380         if (request == 0) {
1381                 request = UFS_ROOTINO;
1382                 anyino = 1;
1383         } else if (inoinfo(request)->ino_state != USTATE)
1384                 return (0);
1385 retry:
1386         for (ino = request; ino < maxino; ino++)
1387                 if (inoinfo(ino)->ino_state == USTATE)
1388                         break;
1389         if (ino >= maxino)
1390                 return (0);
1391         cg = ino_to_cg(&sblock, ino);
1392         cgbp = cglookup(cg);
1393         cgp = cgbp->b_un.b_cg;
1394         if (!check_cgmagic(cg, cgbp, 0)) {
1395                 if (anyino == 0)
1396                         return (0);
1397                 request = (cg + 1) * sblock.fs_ipg;
1398                 goto retry;
1399         }
1400         setbit(cg_inosused(cgp), ino % sblock.fs_ipg);
1401         cgp->cg_cs.cs_nifree--;
1402         switch (type & IFMT) {
1403         case IFDIR:
1404                 inoinfo(ino)->ino_state = DSTATE;
1405                 cgp->cg_cs.cs_ndir++;
1406                 break;
1407         case IFREG:
1408         case IFLNK:
1409                 inoinfo(ino)->ino_state = FSTATE;
1410                 break;
1411         default:
1412                 return (0);
1413         }
1414         cgdirty(cgbp);
1415         ginode(ino, &ip);
1416         dp = ip.i_dp;
1417         DIP_SET(dp, di_db[0], allocblk(ino_to_cg(&sblock, ino), (long)1,
1418             std_checkblkavail));
1419         if (DIP(dp, di_db[0]) == 0) {
1420                 inoinfo(ino)->ino_state = USTATE;
1421                 irelse(&ip);
1422                 return (0);
1423         }
1424         DIP_SET(dp, di_mode, type);
1425         DIP_SET(dp, di_flags, 0);
1426         DIP_SET(dp, di_atime, time(NULL));
1427         DIP_SET(dp, di_ctime, DIP(dp, di_atime));
1428         DIP_SET(dp, di_mtime, DIP(dp, di_ctime));
1429         DIP_SET(dp, di_mtimensec, 0);
1430         DIP_SET(dp, di_ctimensec, 0);
1431         DIP_SET(dp, di_atimensec, 0);
1432         DIP_SET(dp, di_size, sblock.fs_fsize);
1433         DIP_SET(dp, di_blocks, btodb(sblock.fs_fsize));
1434         n_files++;
1435         inodirty(&ip);
1436         irelse(&ip);
1437         inoinfo(ino)->ino_type = IFTODT(type);
1438         return (ino);
1439 }
1440
1441 /*
1442  * deallocate an inode
1443  */
1444 void
1445 freeino(ino_t ino)
1446 {
1447         struct inodesc idesc;
1448         union dinode *dp;
1449         struct inode ip;
1450
1451         memset(&idesc, 0, sizeof(struct inodesc));
1452         idesc.id_type = ADDR;
1453         idesc.id_func = freeblock;
1454         idesc.id_number = ino;
1455         ginode(ino, &ip);
1456         dp = ip.i_dp;
1457         (void)ckinode(dp, &idesc);
1458         clearinode(dp);
1459         inodirty(&ip);
1460         irelse(&ip);
1461         inoinfo(ino)->ino_state = USTATE;
1462         n_files--;
1463 }