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