src/vfsck/inode.c

   1 /*
   2  * Copyright (c) 1980, 1986 The Regents of the University of California.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms are permitted
   6  * provided that the above copyright notice and this paragraph are
   7  * duplicated in all such forms and that any documentation,
   8  * advertising materials, and other materials related to such
   9  * distribution and use acknowledge that the software was developed
  10  * by the University of California, Berkeley.  The name of the
  11  * University may not be used to endorse or promote products derived
  12  * from this software without specific prior written permission.
  13  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  16  */
  17
  18 #include <afsconfig.h>
  19 #include <afs/param.h>
  20
  21 #ifdef AFS_HPUX_ENV
  22 /* We need the old directory type headers (included below), so don't include
  23  * the normal dirent.h, or it will conflict. */
  24 # undef HAVE_DIRENT_H
  25 # include <sys/inode.h>
  26 # define        LONGFILENAMES   1
  27 # include <sys/sysmacros.h>
  28 # include <sys/ino.h>
  29 # define        DIRSIZ_MACRO
  30 # ifdef HAVE_USR_OLD_USR_INCLUDE_NDIR_H
  31 #  include </usr/old/usr/include/ndir.h>
  32 # else
  33 #  include <ndir.h>
  34 # endif
  35 #endif
  36
  37 #include <roken.h>
  38
  39 #include <ctype.h>
  40
  41 #define VICE                    /* control whether AFS changes are present */
  42
  43 #ifdef  AFS_OSF_ENV
  44 #include <sys/mount.h>
  45 #include <sys/vnode.h>
  46 #include <ufs/inode.h>
  47 #include <ufs/fs.h>
  48 #define _BSD
  49 #define _KERNEL
  50 #include <ufs/dir.h>
  51 #undef  _KERNEL
  52 #undef  _BSD
  53 #else /* AFS_OSF_ENV */
  54 #ifdef AFS_VFSINCL_ENV
  55 #define VFS
  56 #include <sys/vnode.h>
  57 #ifdef    AFS_SUN5_ENV
  58 #include <sys/fs/ufs_inode.h>
  59 #include <sys/fs/ufs_fs.h>
  60 #define _KERNEL
  61 #include <sys/fs/ufs_fsdir.h>
  62 #undef _KERNEL
  63 #else
  64 #include <ufs/inode.h>
  65 #define KERNEL
  66 #include <ufs/fsdir.h>
  67 #undef  KERNEL
  68 #include <ufs/fs.h>
  69 #endif
  70 #else /* AFS_VFSINCL_ENV */
  71 #include <sys/inode.h>
  72 #ifndef AFS_HPUX_ENV
  73 #include <sys/dir.h>
  74 #endif
  75 #include <sys/fs.h>
  76 #endif /* AFS_VFSINCL_ENV */
  77 #endif /* AFS_OSF_ENV */
  78
  79 #include <afs/osi_inode.h>
  80 #include "fsck.h"
  81
  82 #ifdef AFS_SUN_ENV
  83 #ifdef  AFS_SUN5_ENV
  84 #include <sys/mnttab.h>
  85 #include <sys/mntent.h>
  86 #else
  87 #include <mntent.h>
  88 #endif
  89 #endif /* AFS_SUN_ENV */
  90
  91 struct bufarea *pbp = 0;
  92
  93 ckinode(dp, idesc)
  94      struct dinode *dp;
  95      struct inodesc *idesc;
  96 {
  97     daddr_t *ap;
  98     long ret, n, ndb, offset;
  99     struct dinode dino;
 100     UOFF_T indir_data_blks;
 101     extern int pass1check();
 102
 103 #ifdef  AFS_HPUX_ENV
 104     if (FASTLNK)
 105         return (KEEPON);
 106 #endif
 107     idesc->id_fix = DONTKNOW;
 108     idesc->id_entryno = 0;
 109     idesc->id_filesize = dp->di_size;
 110     if ((dp->di_mode & IFMT) == IFBLK || (dp->di_mode & IFMT) == IFCHR)
 111         return (KEEPON);
 112 #ifdef  AFS_OSF_ENV
 113     if ((dp->di_flags & IC_FASTLINK) != 0) {
 114         return (KEEPON);
 115     }
 116 #endif /* AFS_OSF_ENV */
 117     dino = *dp;
 118     ndb = howmany(dino.di_size, (UOFF_T) sblock.fs_bsize);
 119     ap = &dino.di_db[0];
 120 #ifdef AFS_OSF_ENV
 121     /*
 122      * Check property lists on pass1
 123      */
 124     if (idesc->id_func == pass1check && dino.di_flags & IC_PROPLIST && *ap) {
 125         ret = proplist_scan(dp, idesc);
 126         if (ret & STOP)
 127             return (ret);
 128     }
 129 #endif /* AFS_OSF_ENV */
 130     for (; ap < &dino.di_db[NDADDR]; ap++) {
 131         if (--ndb == 0 && (offset = blkoff(&sblock, dino.di_size)) != 0)
 132             idesc->id_numfrags =
 133                 numfrags(&sblock, fragroundup(&sblock, offset));
 134         else
 135             idesc->id_numfrags = sblock.fs_frag;
 136         if (*ap == 0)
 137             continue;
 138         idesc->id_blkno = *ap;
 139         if (idesc->id_type == ADDR)
 140             ret = (*idesc->id_func) (idesc);
 141         else
 142             ret = dirscan(idesc);
 143         if (ret & STOP)
 144             return (ret);
 145     }
 146     idesc->id_numfrags = sblock.fs_frag;
 147 #if     defined(AFS_SUN5_ENV)
 148     /*
 149      * indir_data_blks determine the no. of data blocks
 150      * in the previous levels. ie., at level 3 it
 151      * is the number of data blocks at level 2, 1, and 0.
 152      */
 153     for (ap = &dino.di_ib[0], n = 1; n <= NIADDR; ap++, n++) {
 154         if (n == 1) {
 155             /* SINGLE */
 156             indir_data_blks = NDADDR;
 157         } else if (n == 2) {
 158             /* DOUBLE */
 159             indir_data_blks = NDADDR + NINDIR(&sblock);
 160         } else if (n == 3) {
 161             /* TRIPLE */
 162             indir_data_blks =
 163                 NDADDR + NINDIR(&sblock) +
 164                 (NINDIR(&sblock) * NINDIR(&sblock));
 165         }
 166         if (*ap) {
 167             idesc->id_blkno = *ap;
 168             ret =
 169                 iblock(idesc, n,
 170                        (u_offset_t) howmany(dino.di_size,
 171                                             (u_offset_t) sblock.fs_bsize) -
 172                        indir_data_blks);
 173             if (ret & STOP)
 174                 return (ret);
 175         }
 176     }
 177 #else
 178     for (ap = &dino.di_ib[0], n = 1; n <= NIADDR; ap++, n++) {
 179         if (*ap) {
 180             idesc->id_blkno = *ap;
 181             ret = iblock(idesc, n, dino.di_size - sblock.fs_bsize * NDADDR);
 182             if (ret & STOP)
 183                 return (ret);
 184         }
 185     }
 186 #endif
 187     return (KEEPON);
 188 }
 189
 190 iblock(idesc, ilevel, isize)
 191      struct inodesc *idesc;
 192      long ilevel;
 193      UOFF_T isize;
 194 {
 195     daddr_t *ap;
 196     daddr_t *aplim;
 197     int i, n, (*func) ();
 198     UOFF_T sizepb;
 199     OFF_T nif;
 200     struct bufarea *bp;
 201     char buf[BUFSIZ];
 202     extern int dirscan(), pass1check();
 203
 204     if (idesc->id_type == ADDR) {
 205         func = idesc->id_func;
 206         if (((n = (*func) (idesc)) & KEEPON) == 0)
 207             return (n);
 208     } else
 209         func = dirscan;
 210     if (chkrange(idesc->id_blkno, idesc->id_numfrags))
 211         return (SKIP);
 212     bp = getdatablk(idesc->id_blkno, sblock.fs_bsize);
 213     ilevel--;
 214 #if     defined(AFS_SUN5_ENV)
 215     for (sizepb = 1, i = 0; i < ilevel; i++) {
 216         sizepb *= (u_offset_t) NINDIR(&sblock);
 217     }
 218
 219     /*
 220      * nif indicates the next "free" pointer (as an array index) in this
 221      * indirect block, based on counting the blocks remaining in the
 222      * file after subtracting all previously processed blocks.
 223      * This figure is based on the size field of the inode.
 224      *
 225      * Note that in normal operation, nif may initially calculated to
 226      * be larger than the number of pointers in this block; if that is
 227      * the case, nif is limited to the max number of pointers per
 228      * indirect block.
 229      *
 230      * Also note that if an inode is inconsistant (has more blocks
 231      * allocated to it than the size field would indicate), the sweep
 232      * through any indirect blocks directly pointed at by the inode
 233      * continues. Since the block offset of any data blocks referenced
 234      * by these indirect blocks is greater than the size of the file,
 235      * the index nif may be computed as a negative value.
 236      * In this case, we reset nif to indicate that all pointers in
 237      * this retrieval block should be zeroed and the resulting
 238      * unreferenced data and/or retrieval blocks be recovered
 239      * through garbage collection later.
 240      */
 241     nif = (offset_t) howmany(isize, sizepb);
 242     if (nif > NINDIR(&sblock))
 243         nif = NINDIR(&sblock);
 244     else if (nif < 0)
 245         nif = 0;
 246 #else
 247     for (sizepb = sblock.fs_bsize, i = 0; i < ilevel; i++)
 248         sizepb *= (UOFF_T) NINDIR(&sblock);
 249     nif = isize / sizepb + 1;
 250     if (nif > NINDIR(&sblock))
 251         nif = NINDIR(&sblock);
 252 #endif
 253     if (idesc->id_func == pass1check && nif < NINDIR(&sblock)) {
 254         aplim = &bp->b_un.b_indir[NINDIR(&sblock)];
 255         for (ap = &bp->b_un.b_indir[nif]; ap < aplim; ap++) {
 256             if (*ap == 0)
 257                 continue;
 258             (void)sprintf(buf, "PARTIALLY TRUNCATED INODE I=%d",
 259                           idesc->id_number);
 260             if (dofix(idesc, buf)) {
 261                 *ap = 0;
 262                 dirty(bp);
 263             }
 264         }
 265         flush(fswritefd, bp);
 266     }
 267     aplim = &bp->b_un.b_indir[nif];
 268     for (ap = bp->b_un.b_indir, i = 1; ap < aplim; ap++, i++) {
 269         if (*ap) {
 270             idesc->id_blkno = *ap;
 271             if (ilevel > 0) {
 272 #if     defined(AFS_SUN5_ENV)
 273                 n = iblock(idesc, ilevel, isize);
 274                 /*
 275                  * each iteration decrease "remaining block
 276                  * count" by however many blocks were accessible
 277                  * by a pointer at this indirect block level.
 278                  */
 279                 isize -= sizepb;
 280 #else
 281                 n = iblock(idesc, ilevel, isize - i * sizepb);
 282 #endif
 283             } else
 284                 n = (*func) (idesc);
 285             if (n & STOP) {
 286                 bp->b_flags &= ~B_INUSE;
 287                 return (n);
 288             }
 289         }
 290     }
 291     bp->b_flags &= ~B_INUSE;
 292     return (KEEPON);
 293 }
 294
 295 /*
 296  * Check that a block in a legal block number.
 297  * Return 0 if in range, 1 if out of range.
 298  */
 299 chkrange(blk, cnt)
 300      daddr_t blk;
 301      int cnt;
 302 {
 303     int c;
 304
 305     if ((unsigned)(blk + cnt) > maxfsblock)
 306         return (1);
 307     c = dtog(&sblock, blk);
 308     if (blk < cgdmin(&sblock, c)) {
 309         if ((blk + cnt) > cgsblock(&sblock, c)) {
 310             if (debug) {
 311                 printf("blk %d < cgdmin %d;", blk, cgdmin(&sblock, c));
 312                 printf(" blk + cnt %d > cgsbase %d\n", blk + cnt,
 313                        cgsblock(&sblock, c));
 314             }
 315             return (1);
 316         }
 317     } else {
 318         if ((blk + cnt) > cgbase(&sblock, c + 1)) {
 319             if (debug) {
 320                 printf("blk %d >= cgdmin %d;", blk, cgdmin(&sblock, c));
 321                 printf(" blk + cnt %d > sblock.fs_fpg %d\n", blk + cnt,
 322                        sblock.fs_fpg);
 323             }
 324             return (1);
 325         }
 326     }
 327     return (0);
 328 }
 329
 330 struct dinode *
 331 ginode(inumber)
 332      ino_t inumber;
 333 {
 334     daddr_t iblk;
 335
 336     if (inumber < ROOTINO || inumber > maxino)
 337         errexit("bad inode number %d to ginode\n", inumber);
 338     if (mlk_startinum == 0 || inumber < mlk_startinum
 339         || inumber >= mlk_startinum + INOPB(&sblock)) {
 340         iblk = itod(&sblock, inumber);
 341         if (pbp != 0)
 342             pbp->b_flags &= ~B_INUSE;
 343         pbp = getdatablk(iblk, sblock.fs_bsize);
 344         mlk_startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
 345     }
 346     return (&pbp->b_un.b_dinode[inumber % INOPB(&sblock)]);
 347 }
 348
 349 #ifdef  AFS_SUN5_ENVX
 350 inocleanup()
 351 {
 352     struct inoinfo **inpp;
 353
 354     if (inphead == NULL)
 355         return;
 356     for (inpp = &inpsort[inplast - 1]; inpp >= inpsort; inpp--)
 357         free(*inpp);
 358     free(inphead);
 359     free(inpsort);
 360     inphead = inpsort = NULL;
 361 }
 362 #endif
 363
 364 inodirty()
 365 {
 366
 367     dirty(pbp);
 368 }
 369
 370 clri(idesc, type, flag)
 371      struct inodesc *idesc;
 372      char *type;
 373      int flag;
 374 {
 375     struct dinode *dp;
 376 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 377     struct inodesc cidesc;
 378 #endif /* ACLS */
 379
 380     dp = ginode(idesc->id_number);
 381     if (flag == 1) {
 382         pwarn("%s %s", type, (dp->di_mode & IFMT) == IFDIR ? "DIR" : "FILE");
 383         pinode(idesc->id_number);
 384 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 385     } else if (flag == 2) {
 386         pwarn("%s %s", type, "CONTINUATION INODE ");
 387         printf(" I=%u ", idesc->id_number);
 388 #endif /* ACLS */
 389     }
 390     if (preen || reply("CLEAR") == 1) {
 391         if (preen)
 392             printf(" (CLEARED)\n");
 393 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 394         if (CONT)
 395             n_cont--;
 396         else
 397             n_files--;
 398
 399         /*
 400          * If there is a CI associated with this inode, we must
 401          * clear it as well.
 402          */
 403         if (statemap[idesc->id_number] & HASCINODE) {
 404             if (!(dp->di_contin < ROOTINO || dp->di_contin > maxino))
 405                 cidesc.id_number = dp->di_contin;
 406             clri(&cidesc, "UNREF", 2);
 407         }
 408 #else /* no ACLS */
 409         n_files--;
 410 #endif /* ACLS */
 411         (void)ckinode(dp, idesc);
 412 #ifdef  VICE
 413         zapino(dp);
 414 #else /* VICE */
 415         clearinode(dp);
 416 #endif /* VICE */
 417         statemap[idesc->id_number] = USTATE;
 418         inodirty();
 419     }
 420 }
 421
 422 findname(idesc)
 423      struct inodesc *idesc;
 424 {
 425     struct direct *dirp = idesc->id_dirp;
 426
 427     if (dirp->d_ino != idesc->id_parent)
 428         return (KEEPON);
 429     memcpy(idesc->id_name, dirp->d_name, (int)dirp->d_namlen + 1);
 430     return (STOP | FOUND);
 431 }
 432
 433 findino(idesc)
 434      struct inodesc *idesc;
 435 {
 436     struct direct *dirp = idesc->id_dirp;
 437
 438     if (dirp->d_ino == 0)
 439         return (KEEPON);
 440     if (strcmp(dirp->d_name, idesc->id_name) == 0 && dirp->d_ino >= ROOTINO
 441         && dirp->d_ino <= maxino) {
 442         idesc->id_parent = dirp->d_ino;
 443         return (STOP | FOUND);
 444     }
 445     return (KEEPON);
 446 }
 447
 448 pinode(ino)
 449      ino_t ino;
 450 {
 451     struct dinode *dp;
 452     char *p;
 453     struct passwd *pw;
 454     char *ctime();
 455     time_t t;
 456
 457     printf(" I=%u ", ino);
 458     if (ino < ROOTINO || ino > maxino)
 459         return;
 460     dp = ginode(ino);
 461     printf(" OWNER=");
 462 #if     defined(AFS_HPUX110_ENV)
 463     {
 464         char uidbuf[BUFSIZ];
 465         char *p;
 466         uid_t uid;
 467         if (dp == NULL) {
 468             pwarn("Could not getinode(%d) in pinode.", ino);
 469             return;
 470         }
 471         uid = _GET_D_UID(dp);
 472         if (getpw(uid, uidbuf) == 0) {
 473             for (p = uidbuf; *p != ':'; p++);
 474             *p = 0;
 475             printf("%s ", uidbuf);
 476         } else {
 477             printf("%d ", uid);
 478         }
 479     }
 480 #else /* AFS_HPUX110_ENV */
 481 #if     defined(AFS_HPUX102_ENV)
 482     if ((pw = getpwuid(_GET_D_UID(dp))) != 0)
 483         printf("%s ", pw->pw_name);
 484     else
 485         printf("%d ", _GET_D_UID(dp));
 486 #else /* AFS_HPUX102_ENV */
 487     if ((pw = getpwuid((int)dp->di_uid)) != 0)
 488         printf("%s ", pw->pw_name);
 489     else
 490         printf("%d ", dp->di_uid);
 491 #endif /* else AFS_HPUX102_ENV */
 492 #endif /* else AFS_HPUX110_ENV */
 493     printf("MODE=%o\n", dp->di_mode);
 494     if (preen)
 495         printf("%s: ", devname);
 496 #if     defined(AFS_SUN5_ENV)
 497     printf("SIZE=%" AFS_INT64_FMT " ", dp->di_size);
 498 #else
 499     printf("SIZE=%ld ", dp->di_size);
 500 #endif
 501     t = dp->di_mtime;
 502     p = ctime(&t);
 503     printf("MTIME=%12.12s %4.4s ", p + 4, p + 20);
 504 }
 505
 506 blkerror(ino, type, blk)
 507      ino_t ino;
 508      char *type;
 509      daddr_t blk;
 510 {
 511
 512     pfatal("%ld %s I=%u", blk, type, ino);
 513     printf("\n");
 514     switch (statemap[ino]) {
 515
 516 #ifdef VICE
 517     case VSTATE:
 518 #endif /* VICE */
 519     case FSTATE:
 520 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 521         /*
 522          *  Keep the continuation inode info
 523          */
 524         if (statemap[ino] & HASCINODE)
 525             statemap[ino] = FCLEAR | HASCINODE;
 526         else
 527             statemap[ino] = FCLEAR;
 528 #else /* no ACLS */
 529         statemap[ino] = FCLEAR;
 530 #endif /* ACLS */
 531         return;
 532
 533     case DSTATE:
 534 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 535         /*
 536          *  Keep the continuation inode info
 537          */
 538         if (statemap[ino] & HASCINODE)
 539             statemap[ino] = DCLEAR | HASCINODE;
 540         else
 541             statemap[ino] = DCLEAR;
 542 #else /* no ACLS */
 543         statemap[ino] = DCLEAR;
 544 #endif /* ACLS */
 545         return;
 546
 547     case FCLEAR:
 548     case DCLEAR:
 549         return;
 550
 551     default:
 552         errexit("BAD STATE %d TO BLKERR", statemap[ino]);
 553         /* NOTREACHED */
 554     }
 555 }
 556
 557 /*
 558  * allocate an unused inode
 559  */
 560 ino_t
 561 allocino(request, type)
 562      ino_t request;
 563      int type;
 564 {
 565     ino_t ino;
 566     struct dinode *dp;
 567
 568     if (request == 0)
 569         request = ROOTINO;
 570     else if (statemap[request] != USTATE)
 571         return (0);
 572     for (ino = request; ino < maxino; ino++)
 573         if (statemap[ino] == USTATE)
 574             break;
 575     if (ino == maxino)
 576         return (0);
 577     switch (type & IFMT) {
 578     case IFDIR:
 579         statemap[ino] = DSTATE;
 580         break;
 581     case IFREG:
 582     case IFLNK:
 583         statemap[ino] = FSTATE;
 584         break;
 585     default:
 586         return (0);
 587     }
 588     dp = ginode(ino);
 589     dp->di_db[0] = allocblk((long)1);
 590     if (dp->di_db[0] == 0) {
 591         statemap[ino] = USTATE;
 592         return (0);
 593     }
 594     dp->di_mode = type;
 595     time(&dp->di_atime);
 596     dp->di_mtime = dp->di_ctime = dp->di_atime;
 597     dp->di_size = sblock.fs_fsize;
 598     dp->di_blocks = btodb(sblock.fs_fsize);
 599
 600     n_files++;
 601     inodirty();
 602     return (ino);
 603 }
 604
 605 /*
 606  * deallocate an inode
 607  */
 608 freeino(ino)
 609      ino_t ino;
 610 {
 611     struct inodesc idesc;
 612     extern int pass4check();
 613     struct dinode *dp;
 614
 615     memset(&idesc, 0, sizeof(struct inodesc));
 616     idesc.id_type = ADDR;
 617     idesc.id_func = pass4check;
 618     idesc.id_number = ino;
 619     dp = ginode(ino);
 620     (void)ckinode(dp, &idesc);
 621 #ifdef VICE
 622     zapino(dp);
 623 #else /* VICE */
 624     clearinode(dp);
 625 #endif /* VICE */
 626     inodirty();
 627     statemap[ino] = USTATE;
 628     n_files--;
 629 }