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