src/vfsck/pass2.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
  42 #ifdef AFS_VFSINCL_ENV
  43 #include <sys/vnode.h>
  44 #ifdef    AFS_SUN5_ENV
  45 #include <sys/fs/ufs_inode.h>
  46 #include <sys/fs/ufs_fs.h>
  47 #define _KERNEL
  48 #include <sys/fs/ufs_fsdir.h>
  49 #undef _KERNEL
  50 #include <sys/fs/ufs_mount.h>
  51 #else
  52 #include <ufs/inode.h>
  53 #include <ufs/fs.h>
  54 #include <ufs/fsdir.h>
  55 #endif
  56 #else /* AFS_VFSINCL_ENV */
  57 #include <sys/inode.h>
  58 #ifndef AFS_HPUX_ENV
  59 #include <sys/dir.h>
  60 #endif
  61 #include <sys/fs.h>
  62
  63 #endif /* AFS_VFSINCL_ENV */
  64 #include <afs/osi_inode.h>
  65
  66 #include "fsck.h"
  67
  68 int pass2check();
  69
  70 pass2()
  71 {
  72     struct dinode *dp;
  73     struct inodesc rootdesc;
  74
  75     memset(&rootdesc, 0, sizeof(struct inodesc));
  76     rootdesc.id_type = ADDR;
  77     rootdesc.id_func = pass2check;
  78     rootdesc.id_number = ROOTINO;
  79     pathp = pathname;
  80 #if defined(ACLS) && defined(AFS_HPUX_ENV)
  81     switch (statemap[ROOTINO] & STATE) {
  82 #else /* no ACLS */
  83     switch (statemap[ROOTINO]) {
  84 #endif /* ACLS */
  85
  86     case USTATE:
  87         pfatal("ROOT INODE UNALLOCATED");
  88         if (reply("ALLOCATE") == 0)
  89             errexit("");
  90         if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
  91             errexit("CANNOT ALLOCATE ROOT INODE\n");
  92         descend(&rootdesc, ROOTINO);
  93         break;
  94
  95     case DCLEAR:
  96         pfatal("DUPS/BAD IN ROOT INODE");
  97         if (reply("REALLOCATE")) {
  98             freeino(ROOTINO);
  99             if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
 100                 errexit("CANNOT ALLOCATE ROOT INODE\n");
 101             descend(&rootdesc, ROOTINO);
 102             break;
 103         }
 104         if (reply("CONTINUE") == 0)
 105             errexit("");
 106         statemap[ROOTINO] = DSTATE;
 107         descend(&rootdesc, ROOTINO);
 108         break;
 109
 110 #ifdef VICE
 111     case VSTATE:
 112 #endif /* VICE */
 113     case FSTATE:
 114     case FCLEAR:
 115         pfatal("ROOT INODE NOT DIRECTORY");
 116         if (reply("REALLOCATE")) {
 117             freeino(ROOTINO);
 118             if (allocdir(ROOTINO, ROOTINO, 0755) != ROOTINO)
 119                 errexit("CANNOT ALLOCATE ROOT INODE\n");
 120             descend(&rootdesc, ROOTINO);
 121             break;
 122         }
 123         if (reply("FIX") == 0)
 124             errexit("");
 125         dp = ginode(ROOTINO);
 126         dp->di_mode &= ~IFMT;
 127         dp->di_mode |= IFDIR;
 128 #ifdef  AFS_SUN5_ENV
 129         dp->di_smode = dp->di_mode;
 130 #endif
 131         inodirty();
 132 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 133         /*
 134          * Keep any info on associated continuation inode
 135          */
 136         if (statemap[ROOTINO] & HASCINODE)
 137             statemap[ROOTINO] = DSTATE | HASCINODE;
 138         else
 139             statemap[ROOTINO] = DSTATE;
 140 #else /* no ACLS */
 141         statemap[ROOTINO] = DSTATE;
 142 #endif /* ACLS */
 143         AFS_FALLTHROUGH;
 144
 145     case DSTATE:
 146         descend(&rootdesc, ROOTINO);
 147         break;
 148
 149     default:
 150         errexit("BAD STATE %d FOR ROOT INODE", statemap[ROOTINO]);
 151     }
 152 }
 153
 154 pass2check(idesc)
 155      struct inodesc *idesc;
 156 {
 157     struct direct *dirp = idesc->id_dirp;
 158     char *curpathloc;
 159     int n, entrysize, ret = 0;
 160     struct dinode *dp;
 161     struct direct proto;
 162     char namebuf[BUFSIZ];
 163 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 164     int holdstate;
 165 #endif /* ACLS */
 166
 167     /*
 168      * check for "."
 169      */
 170     if (idesc->id_entryno != 0)
 171         goto chk1;
 172     if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") == 0) {
 173         if (dirp->d_ino != idesc->id_number) {
 174             direrror(idesc->id_number, "BAD INODE NUMBER FOR '.'");
 175             dirp->d_ino = idesc->id_number;
 176             if (reply("FIX") == 1)
 177                 ret |= ALTERED;
 178         }
 179         goto chk1;
 180     }
 181     direrror(idesc->id_number, "MISSING '.'");
 182     proto.d_ino = idesc->id_number;
 183     proto.d_namlen = 1;
 184     (void)strcpy(proto.d_name, ".");
 185     entrysize = DIRSIZ(&proto);
 186     if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") != 0) {
 187         pfatal("CANNOT FIX, FIRST ENTRY IN DIRECTORY CONTAINS %s\n",
 188                dirp->d_name);
 189 #if     defined(AFS_SUN_ENV)
 190         iscorrupt = 1;
 191 #endif
 192     } else if (dirp->d_reclen < entrysize) {
 193         pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '.'\n");
 194 #if     defined(AFS_SUN_ENV)
 195         iscorrupt = 1;
 196 #endif
 197     } else if (dirp->d_reclen < 2 * entrysize) {
 198         proto.d_reclen = dirp->d_reclen;
 199         memcpy((char *)dirp, (char *)&proto, entrysize);
 200         if (reply("FIX") == 1)
 201             ret |= ALTERED;
 202     } else {
 203         n = dirp->d_reclen - entrysize;
 204         proto.d_reclen = entrysize;
 205         memcpy((char *)dirp, (char *)&proto, entrysize);
 206         idesc->id_entryno++;
 207         lncntp[dirp->d_ino]--;
 208         dirp = (struct direct *)((char *)(dirp) + entrysize);
 209         memset(dirp, 0, n);
 210         dirp->d_reclen = n;
 211         if (reply("FIX") == 1)
 212             ret |= ALTERED;
 213     }
 214   chk1:
 215     if (idesc->id_entryno > 1)
 216         goto chk2;
 217     proto.d_ino = idesc->id_parent;
 218     proto.d_namlen = 2;
 219     (void)strcpy(proto.d_name, "..");
 220     entrysize = DIRSIZ(&proto);
 221     if (idesc->id_entryno == 0) {
 222         n = DIRSIZ(dirp);
 223         if (dirp->d_reclen < n + entrysize)
 224             goto chk2;
 225         proto.d_reclen = dirp->d_reclen - n;
 226         dirp->d_reclen = n;
 227         idesc->id_entryno++;
 228         lncntp[dirp->d_ino]--;
 229         dirp = (struct direct *)((char *)(dirp) + n);
 230         memset(dirp, 0, n);
 231         dirp->d_reclen = n;
 232     }
 233     if (dirp->d_ino != 0 && strcmp(dirp->d_name, "..") == 0) {
 234         if (dirp->d_ino != idesc->id_parent) {
 235             direrror(idesc->id_number, "BAD INODE NUMBER FOR '..'");
 236             dirp->d_ino = idesc->id_parent;
 237             if (reply("FIX") == 1)
 238                 ret |= ALTERED;
 239         }
 240         goto chk2;
 241     }
 242     direrror(idesc->id_number, "MISSING '..'");
 243     if (dirp->d_ino != 0 && strcmp(dirp->d_name, ".") != 0) {
 244         pfatal("CANNOT FIX, SECOND ENTRY IN DIRECTORY CONTAINS %s\n",
 245                dirp->d_name);
 246 #if     defined(AFS_SUN_ENV)
 247         iscorrupt = 1;
 248 #endif
 249     } else if (dirp->d_reclen < entrysize) {
 250         pfatal("CANNOT FIX, INSUFFICIENT SPACE TO ADD '..'\n");
 251 #if     defined(AFS_SUN_ENV)
 252         iscorrupt = 1;
 253 #endif
 254     } else {
 255         proto.d_reclen = dirp->d_reclen;
 256         memcpy((char *)dirp, (char *)&proto, entrysize);
 257         if (reply("FIX") == 1)
 258             ret |= ALTERED;
 259     }
 260   chk2:
 261     if (dirp->d_ino == 0)
 262         return (ret | KEEPON);
 263     if (dirp->d_namlen <= 2 && dirp->d_name[0] == '.'
 264         && idesc->id_entryno >= 2) {
 265         if (dirp->d_namlen == 1) {
 266             direrror(idesc->id_number, "EXTRA '.' ENTRY");
 267             dirp->d_ino = 0;
 268             if (reply("FIX") == 1)
 269                 ret |= ALTERED;
 270             return (KEEPON | ret);
 271         }
 272         if (dirp->d_name[1] == '.') {
 273             direrror(idesc->id_number, "EXTRA '..' ENTRY");
 274             dirp->d_ino = 0;
 275             if (reply("FIX") == 1)
 276                 ret |= ALTERED;
 277             return (KEEPON | ret);
 278         }
 279     }
 280     curpathloc = pathp;
 281     *pathp++ = '/';
 282     if (pathp + dirp->d_namlen >= endpathname) {
 283         *pathp = '\0';
 284         errexit("NAME TOO LONG %s%s\n", pathname, dirp->d_name);
 285     }
 286     memcpy(pathp, dirp->d_name, (int)dirp->d_namlen + 1);
 287     pathp += dirp->d_namlen;
 288     idesc->id_entryno++;
 289     n = 0;
 290     if (dirp->d_ino > maxino || dirp->d_ino <= 0) {
 291         direrror(dirp->d_ino, "I OUT OF RANGE");
 292         n = reply("REMOVE");
 293     } else {
 294       again:
 295 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 296         switch (statemap[dirp->d_ino] & STATE) {
 297 #else /* no ACLS */
 298         switch (statemap[dirp->d_ino]) {
 299 #endif /* ACLS */
 300         case USTATE:
 301             direrror(dirp->d_ino, "UNALLOCATED");
 302             n = reply("REMOVE");
 303             break;
 304
 305         case DCLEAR:
 306         case FCLEAR:
 307             direrror(dirp->d_ino, "DUP/BAD");
 308             if ((n = reply("REMOVE")) == 1)
 309                 break;
 310             dp = ginode(dirp->d_ino);
 311 #ifdef VICE
 312 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 313             holdstate =
 314                 (dp->di_mode & IFMT) ==
 315                 IFDIR ? DSTATE : (VICEINODE ? VSTATE : FSTATE);
 316             if (statemap[dirp->d_ino] & HASCINODE)
 317                 statemap[dirp->d_ino] = holdstate | HASCINODE;
 318             else
 319                 statemap[dirp->d_ino] = holdstate;
 320 #else
 321             statemap[dirp->d_ino] =
 322                 (dp->di_mode & IFMT) ==
 323                 IFDIR ? DSTATE : (VICEINODE ? VSTATE : FSTATE);
 324 #endif
 325 #else /* VICE */
 326 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 327             holdstate = (dp->di_mode & IFMT) == IFDIR ? DSTATE : FSTATE;
 328             if (statemap[dirp->d_ino] & HASCINODE)
 329                 statemap[dirp->d_ino] = holdstate | HASCINODE;
 330             else
 331                 statemap[dirp->d_ino] = holdstate;
 332 #else
 333             statemap[dirp->d_ino] =
 334                 (dp->di_mode & IFMT) == IFDIR ? DSTATE : FSTATE;
 335 #endif
 336 #endif /* VICE */
 337             lncntp[dirp->d_ino] = dp->di_nlink;
 338             goto again;
 339
 340         case DFOUND:
 341             if (idesc->id_entryno > 2) {
 342                 getpathname(namebuf, dirp->d_ino, dirp->d_ino);
 343                 pwarn("%s %s %s\n", pathname,
 344                       "IS AN EXTRANEOUS HARD LINK TO DIRECTORY", namebuf);
 345                 if (preen)
 346                     printf(" (IGNORED)\n");
 347                 else if ((n = reply("REMOVE")) == 1)
 348                     break;
 349             }
 350             AFS_FALLTHROUGH;
 351
 352         case FSTATE:
 353 #ifdef VICE
 354           filecase:
 355 #endif /* VICE */
 356             lncntp[dirp->d_ino]--;
 357             break;
 358
 359 #ifdef VICE
 360         case VSTATE:
 361             direrror(dirp->d_ino, "VICE INODE REFERENCED BY DIRECTORY");
 362             if (reply("CONVERT TO REGULAR FILE") != 1)
 363                 break;
 364             if ((dp = ginode(dirp->d_ino)) == NULL)
 365                 break;
 366             CLEAR_DVICEMAGIC(dp);
 367             inodirty();
 368             statemap[dirp->d_ino] = FSTATE;
 369             ret |= ALTERED;
 370             goto filecase;
 371 #endif /* VICE */
 372
 373
 374         case DSTATE:
 375             descend(idesc, dirp->d_ino);
 376             if (statemap[dirp->d_ino] == DFOUND) {
 377                 lncntp[dirp->d_ino]--;
 378             } else if (statemap[dirp->d_ino] == DCLEAR) {
 379                 dirp->d_ino = 0;
 380                 ret |= ALTERED;
 381             } else
 382                 errexit("BAD RETURN STATE %d FROM DESCEND",
 383                         statemap[dirp->d_ino]);
 384             break;
 385
 386 #if defined(ACLS) && defined(AFS_HPUX_ENV)
 387             /* hpux has more dynamic states (CSTATE, CRSTATE) */
 388         case CSTATE:
 389             break;
 390         case CRSTATE:
 391             break;
 392 #endif
 393         default:
 394             errexit("BAD STATE %d FOR INODE I=%d", statemap[dirp->d_ino],
 395                     dirp->d_ino);
 396         }
 397     }
 398     pathp = curpathloc;
 399     *pathp = '\0';
 400     if (n == 0)
 401         return (ret | KEEPON);
 402     dirp->d_ino = 0;
 403     return (ret | KEEPON | ALTERED);
 404 }