src/vfsck/pass1.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
  26 #ifdef AFS_VFSINCL_ENV
  27 #include <sys/vnode.h>
  28 #ifdef    AFS_SUN5_ENV
  29 #include <sys/fs/ufs_inode.h>
  30 #include <sys/fs/ufs_fs.h>
  31 #define _KERNEL
  32 #include <sys/fs/ufs_fsdir.h>
  33 #undef _KERNEL
  34 #include <sys/fs/ufs_mount.h>
  35 #else
  36 #include <ufs/inode.h>
  37 #include <ufs/fs.h>
  38 #endif
  39 #else /* AFS_VFSINCL_ENV */
  40 #include <sys/inode.h>
  41 #ifdef  AFS_HPUX_ENV
  42 extern int ge_danger;
  43 #define DUX
  44 #define LONGFILENAMES   1
  45 #include <sys/sysmacros.h>
  46 #include <sys/ino.h>
  47 #endif
  48 #include <sys/fs.h>
  49 #endif /* AFS_VFSINCL_ENV */
  50
  51 #include <afs/osi_inode.h>
  52 #include "fsck.h"
  53
  54 static daddr_t badblk;
  55 static daddr_t dupblk;
  56 int pass1check();
  57 static int oldreported;
  58
  59 pass1()
  60 {
  61     int c, i, j;
  62     struct dinode *dp;
  63     struct zlncnt *zlnp;
  64     int ndb, cgd;
  65     struct inodesc idesc;
  66     ino_t inumber;
  67
  68     /*
  69      * Set file system reserved blocks in used block map.
  70      */
  71     for (c = 0; c < sblock.fs_ncg; c++) {
  72         cgd = cgdmin(&sblock, c);
  73         if (c == 0) {
  74             i = cgbase(&sblock, c);
  75             cgd += howmany(sblock.fs_cssize, sblock.fs_fsize);
  76         } else
  77             i = cgsblock(&sblock, c);
  78         for (; i < cgd; i++)
  79             setbmap(i);
  80     }
  81     /*
  82      * Find all allocated blocks.
  83      */
  84     memset(&idesc, 0, sizeof(struct inodesc));
  85     idesc.id_type = ADDR;
  86     idesc.id_func = pass1check;
  87     inumber = 0;
  88     n_files = n_blks = 0;
  89 #ifdef VICE
  90     nViceFiles = 0;
  91 #endif /* VICE */
  92     for (c = 0; c < sblock.fs_ncg; c++) {
  93         for (i = 0; i < sblock.fs_ipg; i++, inumber++) {
  94             if (inumber < ROOTINO)
  95                 continue;
  96             dp = ginode(inumber);
  97             if ((dp->di_mode & IFMT) == 0) {
  98                 if (memcmp
  99                     ((char *)dp->di_db, (char *)zino.di_db,
 100                      NDADDR * sizeof(daddr_t))
 101                     || memcmp((char *)dp->di_ib, (char *)zino.di_ib,
 102                               NIADDR * sizeof(daddr_t)) ||
 103 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 104                     dp->di_mode || dp->di_size || dp->di_contin) {
 105                     if (dp->di_contin != 0)
 106                         pwarn("UNALLOCATED INODE HAS BAD ic_contin VALUE %d",
 107                               dp->di_contin);
 108                     else
 109 #else
 110                     dp->di_mode || dp->di_size) {
 111 #endif
 112
 113                     pfatal("PARTIALLY ALLOCATED INODE I=%u", inumber);
 114                     if (reply("CLEAR") == 1) {
 115 #ifdef VICE
 116                         zapino(dp);
 117 #else /* VICE */
 118                         clearinode(dp);
 119 #endif /* VICE */
 120                         inodirty();
 121                     }
 122                 }
 123                 statemap[inumber] = USTATE;
 124                 continue;
 125             }
 126             lastino = inumber;
 127 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 128             /*
 129              * Don't check blocks and sizes of
 130              * continuation inodes
 131              */
 132             if (CONT) {
 133                 statemap[inumber] = CSTATE;
 134                 lncntp[inumber] = dp->di_nlink;
 135                 n_cont++;
 136                 continue;
 137             }
 138 #endif /* ACLS */
 139 #if     defined(AFS_SUN5_ENV)
 140             if (dp->di_size < 0 || dp->di_size > (UOFF_T) UFS_MAXOFFSET_T) {
 141                 if (debug)
 142                     printf("bad size %llu:", dp->di_size);
 143                 goto unknown;
 144             }
 145 #else
 146             if (dp->di_size < 0 || dp->di_size + sblock.fs_bsize - 1 < 0) {
 147                 if (debug)
 148                     printf("bad size %d:", dp->di_size);
 149                 goto unknown;
 150             }
 151 #endif
 152 #if defined(AFS_HPUX_ENV)
 153             /* initialize all R/W activities of FIFO file */
 154             /* make sure FIFO is empty (everything is 0) */
 155             if ((dp->di_mode & IFMT) == IFIFO
 156                 && (dp->di_frcnt != 0 || dp->di_fwcnt != 0)) {
 157                 if (!qflag)
 158                     pwarn("NON-ZERO READER/WRITER COUNT(S) ON PIPE I=%u",
 159                           inumber);
 160                 if (preen && !qflag)
 161                     printf(" (CORRECTED)\n");
 162                 else if (!qflag) {
 163                     if (reply("CORRECT") == 0)
 164                         goto no_reset;
 165                 }
 166                 dp->di_size = 0;
 167                 dp->di_frptr = 0;
 168                 dp->di_fwptr = 0;
 169                 dp->di_frcnt = 0;
 170                 dp->di_fwcnt = 0;
 171                 dp->di_fflag = 0;
 172                 dp->di_fifosize = 0;
 173                 inodirty();
 174                 ndb = 0;
 175                 for (j = ndb; j < NDADDR; j++)
 176                     dp->di_db[j] = 0;
 177             }
 178 #ifdef IC_FASTLINK
 179             else if (FASTLNK) {
 180                 /*
 181                  * Fast symlink -- verify that the size is valid and that the length
 182                  * of the path is correct.
 183                  */
 184
 185                 if (dp->di_size >= MAX_FASTLINK_SIZE) {
 186                     if (debug)
 187                         printf("bad fastlink size %d:", dp->di_size);
 188                     goto unknown;
 189                 }
 190                 dp->di_symlink[MAX_FASTLINK_SIZE - 1] = '\0';
 191                 if (strlen(dp->di_symlink) != dp->di_size) {
 192                     int len = strlen(dp->di_symlink);
 193                     pwarn("BAD SYMLINK SIZE, SHOULD BE %d: size = %d", len,
 194                           dp->di_size);
 195                     if (preen)
 196                         printf(" (CORRECTED)\n");
 197                     else {
 198                         printf("\n");
 199                         pinode(inumber);
 200                         if (reply("CORRECT") == 0)
 201                             continue;
 202                     }
 203                     dp->di_size = len;
 204                     inodirty();
 205                 }
 206                 goto ignore_direct_block_check;
 207             }
 208 #endif /* IC_FASTLINK */
 209 #endif
 210           no_reset:
 211             if (!preen && (dp->di_mode & IFMT) == IFMT
 212                 && reply("HOLD BAD BLOCK") == 1) {
 213                 dp->di_size = sblock.fs_fsize;
 214                 dp->di_mode = IFREG | 0600;
 215                 inodirty();
 216             }
 217             ndb = howmany(dp->di_size, (UOFF_T) sblock.fs_bsize);
 218 #ifdef  AFS_SUN5_ENV
 219             if (dp->di_oeftflag == oEFT_MAGIC) {
 220                 dp->di_oeftflag = 0;    /* XXX migration aid */
 221                 inodirty();
 222             }
 223 #endif
 224
 225             if (ndb < 0) {
 226                 if (debug)
 227 #if     defined(AFS_SUN5_ENV)
 228                     printf("bad size %" AFS_INT64_FMT " ndb %d:",
 229 #else
 230                     printf("bad size %d ndb %d:",
 231 #endif
 232                            dp->di_size, ndb);
 233                 goto unknown;
 234             }
 235             if ((dp->di_mode & IFMT) == IFBLK
 236                 || (dp->di_mode & IFMT) == IFCHR)
 237                 ndb++;
 238                 for (j = ndb; j < NDADDR; j++) {
 239 #if defined(AFS_HPUX_ENV) && (defined(DUX) || defined(CNODE_DEV))
 240                     /*
 241                      * DUX uses db[2] on cnode-specific
 242                      * device files, so skip 'em
 243                      */
 244                     if (j == 2 && SPECIAL)
 245                         continue;
 246 #endif
 247                     if (dp->di_db[j] != 0) {
 248                         if (debug)
 249                             printf("bad direct addr: %d\n", dp->di_db[j]);
 250                         goto unknown;
 251                     }
 252                 }
 253                 for (j = 0, ndb -= NDADDR; ndb > 0; j++)
 254                     ndb /= NINDIR(&sblock);
 255                 for (; j < NIADDR; j++)
 256                     if (dp->di_ib[j] != 0) {
 257 #ifdef  AFS_HPUX_ENV
 258                         if ((dp->di_mode & IFMT) != IFIFO) {
 259 #endif
 260                             if (debug)
 261                                 printf("bad indirect addr: %d\n",
 262                                        dp->di_ib[j]);
 263                             goto unknown;
 264 #ifdef  AFS_HPUX_ENV
 265                         }
 266 #endif
 267
 268                     }
 269 #if     defined(AFS_HPUX_ENV)
 270               ignore_direct_block_check:
 271 #endif
 272             if (ftypeok(dp) == 0)
 273                 goto unknown;
 274             n_files++;
 275             lncntp[inumber] = dp->di_nlink;
 276             if (dp->di_nlink <= 0) {
 277                 zlnp = malloc(sizeof *zlnp);
 278                 if (zlnp == NULL) {
 279                     pfatal("LINK COUNT TABLE OVERFLOW");
 280                     if (reply("CONTINUE") == 0)
 281                         errexit("");
 282                 } else {
 283                     zlnp->zlncnt = inumber;
 284                     zlnp->next = zlnhead;
 285                     zlnhead = zlnp;
 286                 }
 287             }
 288 #if     defined(AFS_SUN5_ENV)
 289             if (OLDVICEINODE) {
 290                 if (yflag) {
 291                     if (!oldreported) {
 292                         printf
 293                             ("This vicep partition seems to contain pre Sol2.6 AFS inodes\n");
 294                         printf
 295                             ("You should run the AFS file conversion utility before installing Sol 2.6\n");
 296                         printf("Continuing anyway.\n");
 297                         oldreported++;
 298                     }
 299                 } else {
 300                     /* This looks like a sol 2.5 AFS inode */
 301                     printf
 302                         ("This vicep partition seems to contain pre Sol2.6 AFS inodes\n");
 303                     printf
 304                         ("You should run the AFS file conversion utility before installing Sol 2.6\n");
 305                     exit(100);  /* unique return code? */
 306                 }
 307             }
 308 #endif
 309             statemap[inumber] =
 310 #ifdef VICE
 311                 (dp->di_mode & IFMT) ==
 312                 IFDIR ? DSTATE : (VICEINODE ? VSTATE : FSTATE);
 313 #else /* VICE */
 314                 (dp->di_mode & IFMT) == IFDIR ? DSTATE : FSTATE;
 315 #endif /* VICE */
 316 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 317             /*
 318              * keep track of associated contin inodes
 319              */
 320             if (dp->di_contin != 0)
 321                 statemap[inumber] |= HASCINODE;
 322 #endif /* ACLS */
 323             badblk = dupblk = 0;
 324             idesc.id_number = inumber;
 325             idesc.id_entryno = 0;
 326 #ifdef  AFS_SUN5_ENV
 327             idesc.id_fix = DONTKNOW;
 328 #endif
 329             (void)ckinode(dp, &idesc);
 330
 331             idesc.id_entryno *= btodb(sblock.fs_fsize);
 332
 333             if (dp->di_blocks != idesc.id_entryno) {
 334                 pwarn("INCORRECT BLOCK COUNT I=%u (%ld should be %ld)",
 335                       inumber, dp->di_blocks, idesc.id_entryno);
 336                 if (preen)
 337                     printf(" (CORRECTED)\n");
 338                 else if (reply("CORRECT") == 0)
 339                     continue;
 340 #ifdef  AFS_SUN5_ENV
 341                 dp = ginode(inumber);
 342 #endif
 343                 dp->di_blocks = idesc.id_entryno;
 344                 inodirty();
 345             }
 346 #ifdef  AFS_SUN5_ENV
 347             if ((dp->di_mode & IFMT) == IFDIR)
 348                 if (dp->di_blocks == 0)
 349                     statemap[inumber] = DCLEAR;
 350 #endif
 351             continue;
 352           unknown:
 353             pfatal("UNKNOWN FILE TYPE I=%u", inumber);
 354 #ifdef  AFS_SUN5_ENV
 355             if ((dp->di_mode & IFMT) == IFDIR) {
 356                 statemap[inumber] = DCLEAR;
 357 #ifdef  notdef
 358                 cacheino(dp, inumber);
 359 #endif
 360             } else
 361 #endif
 362                 statemap[inumber] = FCLEAR;
 363             if (reply("CLEAR") == 1) {
 364                 statemap[inumber] = USTATE;
 365 #ifdef VICE
 366                 zapino(dp);
 367 #else /* VICE */
 368                 clearinode(dp);
 369 #endif /* VICE */
 370                 inodirty();
 371             }
 372         }
 373     }
 374 }
 375
 376 pass1check(idesc)
 377      struct inodesc *idesc;
 378 {
 379     int res = KEEPON;
 380     int anyout, nfrags;
 381     daddr_t blkno = idesc->id_blkno;
 382     struct dups *dlp;
 383     struct dups *new;
 384
 385     if ((anyout = chkrange(blkno, idesc->id_numfrags)) != 0) {
 386         blkerror(idesc->id_number, "BAD", blkno);
 387         if (++badblk >= MAXBAD) {
 388             pwarn("EXCESSIVE BAD BLKS I=%u", idesc->id_number);
 389             if (preen)
 390                 printf(" (SKIPPING)\n");
 391             else if (reply("CONTINUE") == 0)
 392                 errexit("");
 393 #ifdef  AFS_HPUX_ENV
 394             ge_danger = 1;
 395 #endif
 396             return (STOP);
 397         }
 398     }
 399     for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
 400         if (anyout && chkrange(blkno, 1)) {
 401             res = SKIP;
 402         } else if (!testbmap(blkno)) {
 403             n_blks++;
 404             setbmap(blkno);
 405         } else {
 406             blkerror(idesc->id_number, "DUP", blkno);
 407             if (++dupblk >= MAXDUP) {
 408                 pwarn("EXCESSIVE DUP BLKS I=%u", idesc->id_number);
 409                 if (preen)
 410                     printf(" (SKIPPING)\n");
 411                 else if (reply("CONTINUE") == 0)
 412                     errexit("");
 413 #ifdef  AFS_HPUX_ENV
 414                 ge_danger = 1;
 415 #endif
 416                 return (STOP);
 417             }
 418             new = malloc(sizeof(struct dups));
 419             if (new == NULL) {
 420                 pfatal("DUP TABLE OVERFLOW.");
 421                 if (reply("CONTINUE") == 0)
 422                     errexit("");
 423                 return (STOP);
 424             }
 425             new->dup = blkno;
 426             if (muldup == 0) {
 427                 duplist = muldup = new;
 428                 new->next = 0;
 429             } else {
 430                 new->next = muldup->next;
 431                 muldup->next = new;
 432             }
 433             for (dlp = duplist; dlp != muldup; dlp = dlp->next)
 434                 if (dlp->dup == blkno)
 435                     break;
 436             if (dlp == muldup && dlp->dup != blkno)
 437                 muldup = new;
 438         }
 439         /*
 440          * count the number of blocks found in id_entryno
 441          */
 442         idesc->id_entryno++;
 443     }
 444     return (res);
 445 }