sbin/fsck_ffs/inode.c

   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  * 4. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #if 0
  31 #ifndef lint
  32 static const char sccsid[] = "@(#)inode.c       8.8 (Berkeley) 4/28/95";
  33 #endif /* not lint */
  34 #endif
  35 #include <sys/cdefs.h>
  36 __FBSDID("$FreeBSD$");
  37
  38 #include <sys/param.h>
  39 #include <sys/stdint.h>
  40 #include <sys/sysctl.h>
  41
  42 #include <ufs/ufs/dinode.h>
  43 #include <ufs/ufs/dir.h>
  44 #include <ufs/ffs/fs.h>
  45
  46 #include <err.h>
  47 #include <pwd.h>
  48 #include <string.h>
  49 #include <time.h>
  50
  51 #include "fsck.h"
  52
  53 static ino_t startinum;
  54
  55 static int iblock(struct inodesc *, long ilevel, off_t isize, int type);
  56
  57 int
  58 ckinode(union dinode *dp, struct inodesc *idesc)
  59 {
  60         off_t remsize, sizepb;
  61         int i, offset, ret;
  62         union dinode dino;
  63         ufs2_daddr_t ndb;
  64         mode_t mode;
  65         char pathbuf[MAXPATHLEN + 1];
  66
  67         if (idesc->id_fix != IGNORE)
  68                 idesc->id_fix = DONTKNOW;
  69         idesc->id_lbn = -1;
  70         idesc->id_entryno = 0;
  71         idesc->id_filesize = DIP(dp, di_size);
  72         mode = DIP(dp, di_mode) & IFMT;
  73         if (mode == IFBLK || mode == IFCHR || (mode == IFLNK &&
  74             DIP(dp, di_size) < (unsigned)sblock.fs_maxsymlinklen))
  75                 return (KEEPON);
  76         if (sblock.fs_magic == FS_UFS1_MAGIC)
  77                 dino.dp1 = dp->dp1;
  78         else
  79                 dino.dp2 = dp->dp2;
  80         ndb = howmany(DIP(&dino, di_size), sblock.fs_bsize);
  81         for (i = 0; i < NDADDR; i++) {
  82                 idesc->id_lbn++;
  83                 if (--ndb == 0 &&
  84                     (offset = blkoff(&sblock, DIP(&dino, di_size))) != 0)
  85                         idesc->id_numfrags =
  86                                 numfrags(&sblock, fragroundup(&sblock, offset));
  87                 else
  88                         idesc->id_numfrags = sblock.fs_frag;
  89                 if (DIP(&dino, di_db[i]) == 0) {
  90                         if (idesc->id_type == DATA && ndb >= 0) {
  91                                 /* An empty block in a directory XXX */
  92                                 getpathname(pathbuf, idesc->id_number,
  93                                                 idesc->id_number);
  94                                 pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
  95                                         pathbuf);
  96                                 if (reply("ADJUST LENGTH") == 1) {
  97                                         dp = ginode(idesc->id_number);
  98                                         DIP_SET(dp, di_size,
  99                                             i * sblock.fs_bsize);
 100                                         printf(
 101                                             "YOU MUST RERUN FSCK AFTERWARDS\n");
 102                                         rerun = 1;
 103                                         inodirty();
 104
 105                                 }
 106                         }
 107                         continue;
 108                 }
 109                 idesc->id_blkno = DIP(&dino, di_db[i]);
 110                 if (idesc->id_type != DATA)
 111                         ret = (*idesc->id_func)(idesc);
 112                 else
 113                         ret = dirscan(idesc);
 114                 if (ret & STOP)
 115                         return (ret);
 116         }
 117         idesc->id_numfrags = sblock.fs_frag;
 118         remsize = DIP(&dino, di_size) - sblock.fs_bsize * NDADDR;
 119         sizepb = sblock.fs_bsize;
 120         for (i = 0; i < NIADDR; i++) {
 121                 sizepb *= NINDIR(&sblock);
 122                 if (DIP(&dino, di_ib[i])) {
 123                         idesc->id_blkno = DIP(&dino, di_ib[i]);
 124                         ret = iblock(idesc, i + 1, remsize, BT_LEVEL1 + i);
 125                         if (ret & STOP)
 126                                 return (ret);
 127                 } else {
 128                         idesc->id_lbn += sizepb / sblock.fs_bsize;
 129                         if (idesc->id_type == DATA && remsize > 0) {
 130                                 /* An empty block in a directory XXX */
 131                                 getpathname(pathbuf, idesc->id_number,
 132                                                 idesc->id_number);
 133                                 pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
 134                                         pathbuf);
 135                                 if (reply("ADJUST LENGTH") == 1) {
 136                                         dp = ginode(idesc->id_number);
 137                                         DIP_SET(dp, di_size,
 138                                             DIP(dp, di_size) - remsize);
 139                                         remsize = 0;
 140                                         printf(
 141                                             "YOU MUST RERUN FSCK AFTERWARDS\n");
 142                                         rerun = 1;
 143                                         inodirty();
 144                                         break;
 145                                 }
 146                         }
 147                 }
 148                 remsize -= sizepb;
 149         }
 150         return (KEEPON);
 151 }
 152
 153 static int
 154 iblock(struct inodesc *idesc, long ilevel, off_t isize, int type)
 155 {
 156         struct bufarea *bp;
 157         int i, n, (*func)(struct inodesc *), nif;
 158         off_t sizepb;
 159         char buf[BUFSIZ];
 160         char pathbuf[MAXPATHLEN + 1];
 161         union dinode *dp;
 162
 163         if (idesc->id_type != DATA) {
 164                 func = idesc->id_func;
 165                 if (((n = (*func)(idesc)) & KEEPON) == 0)
 166                         return (n);
 167         } else
 168                 func = dirscan;
 169         if (chkrange(idesc->id_blkno, idesc->id_numfrags))
 170                 return (SKIP);
 171         bp = getdatablk(idesc->id_blkno, sblock.fs_bsize, type);
 172         ilevel--;
 173         for (sizepb = sblock.fs_bsize, i = 0; i < ilevel; i++)
 174                 sizepb *= NINDIR(&sblock);
 175         if (howmany(isize, sizepb) > NINDIR(&sblock))
 176                 nif = NINDIR(&sblock);
 177         else
 178                 nif = howmany(isize, sizepb);
 179         if (idesc->id_func == pass1check && nif < NINDIR(&sblock)) {
 180                 for (i = nif; i < NINDIR(&sblock); i++) {
 181                         if (IBLK(bp, i) == 0)
 182                                 continue;
 183                         (void)sprintf(buf, "PARTIALLY TRUNCATED INODE I=%lu",
 184                             (u_long)idesc->id_number);
 185                         if (preen) {
 186                                 pfatal("%s", buf);
 187                         } else if (dofix(idesc, buf)) {
 188                                 IBLK_SET(bp, i, 0);
 189                                 dirty(bp);
 190                         }
 191                 }
 192                 flush(fswritefd, bp);
 193         }
 194         for (i = 0; i < nif; i++) {
 195                 if (ilevel == 0)
 196                         idesc->id_lbn++;
 197                 if (IBLK(bp, i)) {
 198                         idesc->id_blkno = IBLK(bp, i);
 199                         if (ilevel == 0)
 200                                 n = (*func)(idesc);
 201                         else
 202                                 n = iblock(idesc, ilevel, isize, type);
 203                         if (n & STOP) {
 204                                 bp->b_flags &= ~B_INUSE;
 205                                 return (n);
 206                         }
 207                 } else {
 208                         if (idesc->id_type == DATA && isize > 0) {
 209                                 /* An empty block in a directory XXX */
 210                                 getpathname(pathbuf, idesc->id_number,
 211                                                 idesc->id_number);
 212                                 pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
 213                                         pathbuf);
 214                                 if (reply("ADJUST LENGTH") == 1) {
 215                                         dp = ginode(idesc->id_number);
 216                                         DIP_SET(dp, di_size,
 217                                             DIP(dp, di_size) - isize);
 218                                         isize = 0;
 219                                         printf(
 220                                             "YOU MUST RERUN FSCK AFTERWARDS\n");
 221                                         rerun = 1;
 222                                         inodirty();
 223                                         bp->b_flags &= ~B_INUSE;
 224                                         return(STOP);
 225                                 }
 226                         }
 227                 }
 228                 isize -= sizepb;
 229         }
 230         bp->b_flags &= ~B_INUSE;
 231         return (KEEPON);
 232 }
 233
 234 /*
 235  * Check that a block in a legal block number.
 236  * Return 0 if in range, 1 if out of range.
 237  */
 238 int
 239 chkrange(ufs2_daddr_t blk, int cnt)
 240 {
 241         int c;
 242
 243         if (cnt <= 0 || blk <= 0 || blk > maxfsblock ||
 244             cnt - 1 > maxfsblock - blk)
 245                 return (1);
 246         if (cnt > sblock.fs_frag ||
 247             fragnum(&sblock, blk) + cnt > sblock.fs_frag) {
 248                 if (debug)
 249                         printf("bad size: blk %ld, offset %i, size %d\n",
 250                             (long)blk, (int)fragnum(&sblock, blk), cnt);
 251                 return (1);
 252         }
 253         c = dtog(&sblock, blk);
 254         if (blk < cgdmin(&sblock, c)) {
 255                 if ((blk + cnt) > cgsblock(&sblock, c)) {
 256                         if (debug) {
 257                                 printf("blk %ld < cgdmin %ld;",
 258                                     (long)blk, (long)cgdmin(&sblock, c));
 259                                 printf(" blk + cnt %ld > cgsbase %ld\n",
 260                                     (long)(blk + cnt),
 261                                     (long)cgsblock(&sblock, c));
 262                         }
 263                         return (1);
 264                 }
 265         } else {
 266                 if ((blk + cnt) > cgbase(&sblock, c+1)) {
 267                         if (debug)  {
 268                                 printf("blk %ld >= cgdmin %ld;",
 269                                     (long)blk, (long)cgdmin(&sblock, c));
 270                                 printf(" blk + cnt %ld > sblock.fs_fpg %ld\n",
 271                                     (long)(blk + cnt), (long)sblock.fs_fpg);
 272                         }
 273                         return (1);
 274                 }
 275         }
 276         return (0);
 277 }
 278
 279 /*
 280  * General purpose interface for reading inodes.
 281  */
 282 union dinode *
 283 ginode(ino_t inumber)
 284 {
 285         ufs2_daddr_t iblk;
 286
 287         if (inumber < ROOTINO || inumber > maxino)
 288                 errx(EEXIT, "bad inode number %ju to ginode",
 289                     (uintmax_t)inumber);
 290         if (startinum == 0 ||
 291             inumber < startinum || inumber >= startinum + INOPB(&sblock)) {
 292                 iblk = ino_to_fsba(&sblock, inumber);
 293                 if (pbp != 0)
 294                         pbp->b_flags &= ~B_INUSE;
 295                 pbp = getdatablk(iblk, sblock.fs_bsize, BT_INODES);
 296                 startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
 297         }
 298         if (sblock.fs_magic == FS_UFS1_MAGIC)
 299                 return ((union dinode *)
 300                     &pbp->b_un.b_dinode1[inumber % INOPB(&sblock)]);
 301         return ((union dinode *)&pbp->b_un.b_dinode2[inumber % INOPB(&sblock)]);
 302 }
 303
 304 /*
 305  * Special purpose version of ginode used to optimize first pass
 306  * over all the inodes in numerical order.
 307  */
 308 static ino_t nextino, lastinum, lastvalidinum;
 309 static long readcount, readpercg, fullcnt, inobufsize, partialcnt, partialsize;
 310 static struct bufarea inobuf;
 311
 312 union dinode *
 313 getnextinode(ino_t inumber, int rebuildcg)
 314 {
 315         int j;
 316         long size;
 317         mode_t mode;
 318         ufs2_daddr_t ndb, blk;
 319         union dinode *dp;
 320         static caddr_t nextinop;
 321
 322         if (inumber != nextino++ || inumber > lastvalidinum)
 323                 errx(EEXIT, "bad inode number %ju to nextinode",
 324                     (uintmax_t)inumber);
 325         if (inumber >= lastinum) {
 326                 readcount++;
 327                 blk = ino_to_fsba(&sblock, lastinum);
 328                 if (readcount % readpercg == 0) {
 329                         size = partialsize;
 330                         lastinum += partialcnt;
 331                 } else {
 332                         size = inobufsize;
 333                         lastinum += fullcnt;
 334                 }
 335                 /*
 336                  * If getblk encounters an error, it will already have zeroed
 337                  * out the buffer, so we do not need to do so here.
 338                  */
 339                 getblk(&inobuf, blk, size);
 340                 nextinop = inobuf.b_un.b_buf;
 341         }
 342         dp = (union dinode *)nextinop;
 343         if (rebuildcg && nextinop == inobuf.b_un.b_buf) {
 344                 /*
 345                  * Try to determine if we have reached the end of the
 346                  * allocated inodes.
 347                  */
 348                 mode = DIP(dp, di_mode) & IFMT;
 349                 if (mode == 0) {
 350                         if (memcmp(dp->dp2.di_db, ufs2_zino.di_db,
 351                                 NDADDR * sizeof(ufs2_daddr_t)) ||
 352                               memcmp(dp->dp2.di_ib, ufs2_zino.di_ib,
 353                                 NIADDR * sizeof(ufs2_daddr_t)) ||
 354                               dp->dp2.di_mode || dp->dp2.di_size)
 355                                 return (NULL);
 356                         goto inodegood;
 357                 }
 358                 if (!ftypeok(dp))
 359                         return (NULL);
 360                 ndb = howmany(DIP(dp, di_size), sblock.fs_bsize);
 361                 if (ndb < 0)
 362                         return (NULL);
 363                 if (mode == IFBLK || mode == IFCHR)
 364                         ndb++;
 365                 if (mode == IFLNK) {
 366                         /*
 367                          * Fake ndb value so direct/indirect block checks below
 368                          * will detect any garbage after symlink string.
 369                          */
 370                         if (DIP(dp, di_size) < (off_t)sblock.fs_maxsymlinklen) {
 371                                 ndb = howmany(DIP(dp, di_size),
 372                                     sizeof(ufs2_daddr_t));
 373                                 if (ndb > NDADDR) {
 374                                         j = ndb - NDADDR;
 375                                         for (ndb = 1; j > 1; j--)
 376                                                 ndb *= NINDIR(&sblock);
 377                                         ndb += NDADDR;
 378                                 }
 379                         }
 380                 }
 381                 for (j = ndb; ndb < NDADDR && j < NDADDR; j++)
 382                         if (DIP(dp, di_db[j]) != 0)
 383                                 return (NULL);
 384                 for (j = 0, ndb -= NDADDR; ndb > 0; j++)
 385                         ndb /= NINDIR(&sblock);
 386                 for (; j < NIADDR; j++)
 387                         if (DIP(dp, di_ib[j]) != 0)
 388                                 return (NULL);
 389         }
 390 inodegood:
 391         if (sblock.fs_magic == FS_UFS1_MAGIC)
 392                 nextinop += sizeof(struct ufs1_dinode);
 393         else
 394                 nextinop += sizeof(struct ufs2_dinode);
 395         return (dp);
 396 }
 397
 398 void
 399 setinodebuf(ino_t inum)
 400 {
 401
 402         if (inum % sblock.fs_ipg != 0)
 403                 errx(EEXIT, "bad inode number %ju to setinodebuf",
 404                     (uintmax_t)inum);
 405         lastvalidinum = inum + sblock.fs_ipg - 1;
 406         startinum = 0;
 407         nextino = inum;
 408         lastinum = inum;
 409         readcount = 0;
 410         if (inobuf.b_un.b_buf != NULL)
 411                 return;
 412         inobufsize = blkroundup(&sblock, INOBUFSIZE);
 413         fullcnt = inobufsize / ((sblock.fs_magic == FS_UFS1_MAGIC) ?
 414             sizeof(struct ufs1_dinode) : sizeof(struct ufs2_dinode));
 415         readpercg = sblock.fs_ipg / fullcnt;
 416         partialcnt = sblock.fs_ipg % fullcnt;
 417         partialsize = partialcnt * ((sblock.fs_magic == FS_UFS1_MAGIC) ?
 418             sizeof(struct ufs1_dinode) : sizeof(struct ufs2_dinode));
 419         if (partialcnt != 0) {
 420                 readpercg++;
 421         } else {
 422                 partialcnt = fullcnt;
 423                 partialsize = inobufsize;
 424         }
 425         initbarea(&inobuf, BT_INODES);
 426         if ((inobuf.b_un.b_buf = Malloc((unsigned)inobufsize)) == NULL)
 427                 errx(EEXIT, "cannot allocate space for inode buffer");
 428 }
 429
 430 void
 431 freeinodebuf(void)
 432 {
 433
 434         if (inobuf.b_un.b_buf != NULL)
 435                 free((char *)inobuf.b_un.b_buf);
 436         inobuf.b_un.b_buf = NULL;
 437 }
 438
 439 /*
 440  * Routines to maintain information about directory inodes.
 441  * This is built during the first pass and used during the
 442  * second and third passes.
 443  *
 444  * Enter inodes into the cache.
 445  */
 446 void
 447 cacheino(union dinode *dp, ino_t inumber)
 448 {
 449         struct inoinfo *inp, **inpp;
 450         int i, blks;
 451
 452         if (howmany(DIP(dp, di_size), sblock.fs_bsize) > NDADDR)
 453                 blks = NDADDR + NIADDR;
 454         else
 455                 blks = howmany(DIP(dp, di_size), sblock.fs_bsize);
 456         inp = (struct inoinfo *)
 457                 Malloc(sizeof(*inp) + (blks - 1) * sizeof(ufs2_daddr_t));
 458         if (inp == NULL)
 459                 errx(EEXIT, "cannot increase directory list");
 460         inpp = &inphead[inumber % dirhash];
 461         inp->i_nexthash = *inpp;
 462         *inpp = inp;
 463         inp->i_parent = inumber == ROOTINO ? ROOTINO : (ino_t)0;
 464         inp->i_dotdot = (ino_t)0;
 465         inp->i_number = inumber;
 466         inp->i_isize = DIP(dp, di_size);
 467         inp->i_numblks = blks;
 468         for (i = 0; i < (blks < NDADDR ? blks : NDADDR); i++)
 469                 inp->i_blks[i] = DIP(dp, di_db[i]);
 470         if (blks > NDADDR)
 471                 for (i = 0; i < NIADDR; i++)
 472                         inp->i_blks[NDADDR + i] = DIP(dp, di_ib[i]);
 473         if (inplast == listmax) {
 474                 listmax += 100;
 475                 inpsort = (struct inoinfo **)realloc((char *)inpsort,
 476                     (unsigned)listmax * sizeof(struct inoinfo *));
 477                 if (inpsort == NULL)
 478                         errx(EEXIT, "cannot increase directory list");
 479         }
 480         inpsort[inplast++] = inp;
 481 }
 482
 483 /*
 484  * Look up an inode cache structure.
 485  */
 486 struct inoinfo *
 487 getinoinfo(ino_t inumber)
 488 {
 489         struct inoinfo *inp;
 490
 491         for (inp = inphead[inumber % dirhash]; inp; inp = inp->i_nexthash) {
 492                 if (inp->i_number != inumber)
 493                         continue;
 494                 return (inp);
 495         }
 496         errx(EEXIT, "cannot find inode %ju", (uintmax_t)inumber);
 497         return ((struct inoinfo *)0);
 498 }
 499
 500 /*
 501  * Clean up all the inode cache structure.
 502  */
 503 void
 504 inocleanup(void)
 505 {
 506         struct inoinfo **inpp;
 507
 508         if (inphead == NULL)
 509                 return;
 510         for (inpp = &inpsort[inplast - 1]; inpp >= inpsort; inpp--)
 511                 free((char *)(*inpp));
 512         free((char *)inphead);
 513         free((char *)inpsort);
 514         inphead = inpsort = NULL;
 515 }
 516
 517 void
 518 inodirty(void)
 519 {
 520
 521         dirty(pbp);
 522 }
 523
 524 void
 525 clri(struct inodesc *idesc, const char *type, int flag)
 526 {
 527         union dinode *dp;
 528
 529         dp = ginode(idesc->id_number);
 530         if (flag == 1) {
 531                 pwarn("%s %s", type,
 532                     (DIP(dp, di_mode) & IFMT) == IFDIR ? "DIR" : "FILE");
 533                 pinode(idesc->id_number);
 534         }
 535         if (preen || reply("CLEAR") == 1) {
 536                 if (preen)
 537                         printf(" (CLEARED)\n");
 538                 n_files--;
 539                 if (bkgrdflag == 0) {
 540                         (void)ckinode(dp, idesc);
 541                         inoinfo(idesc->id_number)->ino_state = USTATE;
 542                         clearinode(dp);
 543                         inodirty();
 544                 } else {
 545                         cmd.value = idesc->id_number;
 546                         cmd.size = -DIP(dp, di_nlink);
 547                         if (debug)
 548                                 printf("adjrefcnt ino %ld amt %lld\n",
 549                                     (long)cmd.value, (long long)cmd.size);
 550                         if (sysctl(adjrefcnt, MIBSIZE, 0, 0,
 551                             &cmd, sizeof cmd) == -1)
 552                                 rwerror("ADJUST INODE", cmd.value);
 553                 }
 554         }
 555 }
 556
 557 int
 558 findname(struct inodesc *idesc)
 559 {
 560         struct direct *dirp = idesc->id_dirp;
 561
 562         if (dirp->d_ino != idesc->id_parent || idesc->id_entryno < 2) {
 563                 idesc->id_entryno++;
 564                 return (KEEPON);
 565         }
 566         memmove(idesc->id_name, dirp->d_name, (size_t)dirp->d_namlen + 1);
 567         return (STOP|FOUND);
 568 }
 569
 570 int
 571 findino(struct inodesc *idesc)
 572 {
 573         struct direct *dirp = idesc->id_dirp;
 574
 575         if (dirp->d_ino == 0)
 576                 return (KEEPON);
 577         if (strcmp(dirp->d_name, idesc->id_name) == 0 &&
 578             dirp->d_ino >= ROOTINO && dirp->d_ino <= maxino) {
 579                 idesc->id_parent = dirp->d_ino;
 580                 return (STOP|FOUND);
 581         }
 582         return (KEEPON);
 583 }
 584
 585 int
 586 clearentry(struct inodesc *idesc)
 587 {
 588         struct direct *dirp = idesc->id_dirp;
 589
 590         if (dirp->d_ino != idesc->id_parent || idesc->id_entryno < 2) {
 591                 idesc->id_entryno++;
 592                 return (KEEPON);
 593         }
 594         dirp->d_ino = 0;
 595         return (STOP|FOUND|ALTERED);
 596 }
 597
 598 void
 599 pinode(ino_t ino)
 600 {
 601         union dinode *dp;
 602         char *p;
 603         struct passwd *pw;
 604         time_t t;
 605
 606         printf(" I=%lu ", (u_long)ino);
 607         if (ino < ROOTINO || ino > maxino)
 608                 return;
 609         dp = ginode(ino);
 610         printf(" OWNER=");
 611         if ((pw = getpwuid((int)DIP(dp, di_uid))) != 0)
 612                 printf("%s ", pw->pw_name);
 613         else
 614                 printf("%u ", (unsigned)DIP(dp, di_uid));
 615         printf("MODE=%o\n", DIP(dp, di_mode));
 616         if (preen)
 617                 printf("%s: ", cdevname);
 618         printf("SIZE=%ju ", (uintmax_t)DIP(dp, di_size));
 619         t = DIP(dp, di_mtime);
 620         p = ctime(&t);
 621         printf("MTIME=%12.12s %4.4s ", &p[4], &p[20]);
 622 }
 623
 624 void
 625 blkerror(ino_t ino, const char *type, ufs2_daddr_t blk)
 626 {
 627
 628         pfatal("%jd %s I=%ju", (intmax_t)blk, type, (uintmax_t)ino);
 629         printf("\n");
 630         switch (inoinfo(ino)->ino_state) {
 631
 632         case FSTATE:
 633         case FZLINK:
 634                 inoinfo(ino)->ino_state = FCLEAR;
 635                 return;
 636
 637         case DSTATE:
 638         case DZLINK:
 639                 inoinfo(ino)->ino_state = DCLEAR;
 640                 return;
 641
 642         case FCLEAR:
 643         case DCLEAR:
 644                 return;
 645
 646         default:
 647                 errx(EEXIT, "BAD STATE %d TO BLKERR", inoinfo(ino)->ino_state);
 648                 /* NOTREACHED */
 649         }
 650 }
 651
 652 /*
 653  * allocate an unused inode
 654  */
 655 ino_t
 656 allocino(ino_t request, int type)
 657 {
 658         ino_t ino;
 659         union dinode *dp;
 660         struct bufarea *cgbp;
 661         struct cg *cgp;
 662         int cg;
 663
 664         if (request == 0)
 665                 request = ROOTINO;
 666         else if (inoinfo(request)->ino_state != USTATE)
 667                 return (0);
 668         for (ino = request; ino < maxino; ino++)
 669                 if (inoinfo(ino)->ino_state == USTATE)
 670                         break;
 671         if (ino == maxino)
 672                 return (0);
 673         cg = ino_to_cg(&sblock, ino);
 674         cgbp = cgget(cg);
 675         cgp = cgbp->b_un.b_cg;
 676         if (!check_cgmagic(cg, cgbp))
 677                 return (0);
 678         setbit(cg_inosused(cgp), ino % sblock.fs_ipg);
 679         cgp->cg_cs.cs_nifree--;
 680         switch (type & IFMT) {
 681         case IFDIR:
 682                 inoinfo(ino)->ino_state = DSTATE;
 683                 cgp->cg_cs.cs_ndir++;
 684                 break;
 685         case IFREG:
 686         case IFLNK:
 687                 inoinfo(ino)->ino_state = FSTATE;
 688                 break;
 689         default:
 690                 return (0);
 691         }
 692         dirty(cgbp);
 693         dp = ginode(ino);
 694         DIP_SET(dp, di_db[0], allocblk((long)1));
 695         if (DIP(dp, di_db[0]) == 0) {
 696                 inoinfo(ino)->ino_state = USTATE;
 697                 return (0);
 698         }
 699         DIP_SET(dp, di_mode, type);
 700         DIP_SET(dp, di_flags, 0);
 701         DIP_SET(dp, di_atime, time(NULL));
 702         DIP_SET(dp, di_ctime, DIP(dp, di_atime));
 703         DIP_SET(dp, di_mtime, DIP(dp, di_ctime));
 704         DIP_SET(dp, di_mtimensec, 0);
 705         DIP_SET(dp, di_ctimensec, 0);
 706         DIP_SET(dp, di_atimensec, 0);
 707         DIP_SET(dp, di_size, sblock.fs_fsize);
 708         DIP_SET(dp, di_blocks, btodb(sblock.fs_fsize));
 709         n_files++;
 710         inodirty();
 711         inoinfo(ino)->ino_type = IFTODT(type);
 712         return (ino);
 713 }
 714
 715 /*
 716  * deallocate an inode
 717  */
 718 void
 719 freeino(ino_t ino)
 720 {
 721         struct inodesc idesc;
 722         union dinode *dp;
 723
 724         memset(&idesc, 0, sizeof(struct inodesc));
 725         idesc.id_type = ADDR;
 726         idesc.id_func = pass4check;
 727         idesc.id_number = ino;
 728         dp = ginode(ino);
 729         (void)ckinode(dp, &idesc);
 730         clearinode(dp);
 731         inodirty();
 732         inoinfo(ino)->ino_state = USTATE;
 733         n_files--;
 734 }