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