e07c90ce5ba15e8c1528455d67cd0f4195d9c32e
[openafs.git] / src / vol / vol-salvage.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  *      System:         VICE-TWO
12  *      Module:         vol-salvage.c
13  *      Institution:    The Information Technology Center, Carnegie-Mellon University
14  */
15
16 /*  1.2 features:
17         Correct handling of bad "." and ".." entries.
18         Message if volume has "destroyMe" flag set--but doesn't delete yet.
19         Link count bug fixed--bug was that vnodeEssence link count was unsigned
20         14 bits.  Needs to be signed.
21
22     1.3 features:
23         Change to DirHandle stuff to make sure that cache entries are reused at the
24         right time (this parallels the file server change, but is not identical).
25
26         Added calls to directory salvager routines; doesn't salvage dir unless debug=1.
27
28     1.4 features:
29         Fixed bug which was causing inode link counts to go bad (thus leaking
30         disk blocks).
31 Vnodes with 0 inode pointers in RW volumes are now deleted.
32         An inode with a matching inode number to the vnode is preferred to an
33         inode with a higer data version.
34         Bug is probably fixed that was causing data version to remain wrong,
35         despite assurances from the salvager to the contrary.
36
37     1.5 features:
38         Added limited salvaging:  unless ForceSalvage is on, then the volume will
39         not be salvaged if the dontSalvage flag is set in the Volume Header.
40         The ForceSalvage flag is turned on if an individual volume is salvaged or
41         if the file FORCESALVAGE exists in the partition header of the file system
42         being salvaged.  This isn't used for anything but could be set by vfsck.
43         A -f flag was also added to force salvage.
44
45     1.6 features:
46         It now deletes obsolete volume inodes without complaining
47
48     1.7 features:
49         Repairs rw volume headers (again).
50
51     1.8 features:
52         Correlates volume headers & inodes correctly, thus preventing occasional deletion
53         of read-only volumes...
54         No longer forces a directory salvage for volume 144 (which may be a good volume
55         at some other site!)
56         Some of the messages are cleaned up or made more explicit.  One or two added.
57         Logging cleaned up.
58         A bug was fixed which forced salvage of read-only volumes without a corresponding
59         read/write volume.
60
61     1.9 features:
62         When a volume header is recreated, the new name will be "bogus.volume#"
63
64     2.0 features:
65         Directory salvaging turned on!!!
66
67     2.1 features:
68         Prints warning messages for setuid programs.
69
70     2.2 features:
71         Logs missing inode numbers.
72
73     2.3 features:
74             Increments directory version number by 200 (rather than by 1) when it is salvaged, in order to prevent problems due to the fact that a version number can be promised to a workstation before it is written to disk.  If the server crashes, it may have an older version.  Salvaging it could bring the version number up to the same version the workstation believed it already had a call back on.
75
76     2.4 features:
77             Locks the file /vice/vol/salvage.lock before starting.  Aborts if it can't acquire the lock.
78             Time stamps on log entries.
79             Fcntl on stdout to cause all entries to be appended.
80             Problems writing to temporary files are now all detected.
81             Inode summary files are now dynamically named (so that multiple salvagers wouldn't conflict).
82             Some cleanup of error messages.
83 */
84
85
86 #include <afsconfig.h>
87 #include <afs/param.h>
88
89
90 #ifndef AFS_NT40_ENV
91 #include <sys/param.h>
92 #include <sys/file.h>
93 #ifndef ITIMER_REAL
94 #include <sys/time.h>
95 #endif /* ITIMER_REAL */
96 #endif
97 #include <stdlib.h>
98 #include <stdio.h>
99 #include <string.h>
100 #include <dirent.h>
101 #include <sys/stat.h>
102 #include <time.h>
103 #include <errno.h>
104 #ifdef AFS_NT40_ENV
105 #include <io.h>
106 #include <WINNT/afsevent.h>
107 #endif
108 #ifndef WCOREDUMP
109 #define WCOREDUMP(x)    ((x) & 0200)
110 #endif
111 #include <rx/xdr.h>
112 #include <afs/afsint.h>
113 #include <afs/assert.h>
114 #if !defined(AFS_SGI_ENV) && !defined(AFS_NT40_ENV)
115 #if defined(AFS_VFSINCL_ENV)
116 #include <sys/vnode.h>
117 #ifdef  AFS_SUN5_ENV
118 #include <sys/fs/ufs_inode.h>
119 #else
120 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
121 #include <ufs/ufs/dinode.h>
122 #include <ufs/ffs/fs.h>
123 #else
124 #include <ufs/inode.h>
125 #endif
126 #endif
127 #else /* AFS_VFSINCL_ENV */
128 #ifdef  AFS_OSF_ENV
129 #include <ufs/inode.h>
130 #else /* AFS_OSF_ENV */
131 #if !defined(AFS_LINUX20_ENV) && !defined(AFS_XBSD_ENV)
132 #include <sys/inode.h>
133 #endif
134 #endif
135 #endif /* AFS_VFSINCL_ENV */
136 #endif /* AFS_SGI_ENV */
137 #ifdef  AFS_AIX_ENV
138 #include <sys/vfs.h>
139 #include <sys/lockf.h>
140 #else
141 #ifdef  AFS_HPUX_ENV
142 #include <unistd.h>
143 #include <checklist.h>
144 #else
145 #if defined(AFS_SGI_ENV)
146 #include <unistd.h>
147 #include <fcntl.h>
148 #include <mntent.h>
149 #else
150 #if     defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV)
151 #ifdef    AFS_SUN5_ENV
152 #include <unistd.h>
153 #include <sys/mnttab.h>
154 #include <sys/mntent.h>
155 #else
156 #include <mntent.h>
157 #endif
158 #else
159 #endif /* AFS_SGI_ENV */
160 #endif /* AFS_HPUX_ENV */
161 #endif
162 #endif
163 #include <fcntl.h>
164 #ifndef AFS_NT40_ENV
165 #include <afs/osi_inode.h>
166 #endif
167 #include <afs/cmd.h>
168 #include <afs/dir.h>
169 #include <afs/afsutil.h>
170 #include <afs/fileutil.h>
171 #include <afs/procmgmt.h>       /* signal(), kill(), wait(), etc. */
172 #ifndef AFS_NT40_ENV
173 #include <syslog.h>
174 #endif
175
176 #include "nfs.h"
177 #include "lwp.h"
178 #include "lock.h"
179 #include <afs/afssyscalls.h>
180 #include "ihandle.h"
181 #include "vnode.h"
182 #include "volume.h"
183 #include "partition.h"
184 #include "daemon_com.h"
185 #include "fssync.h"
186 #include "volume_inline.h"
187 #include "salvsync.h"
188 #include "viceinode.h"
189 #include "salvage.h"
190 #include "volinodes.h"          /* header magic number, etc. stuff */
191 #include "vol-salvage.h"
192 #include "common.h"
193 #include "vol_internal.h"
194 #include <afs/acl.h>
195 #include <afs/prs_fs.h>
196
197 #ifdef FSSYNC_BUILD_CLIENT
198 #include "vg_cache.h"
199 #endif
200
201 #ifdef AFS_NT40_ENV
202 #include <pthread.h>
203 #endif
204
205 /*@+fcnmacros +macrofcndecl@*/
206 #ifdef O_LARGEFILE
207 #ifdef S_SPLINT_S
208 extern off64_t afs_lseek(int FD, off64_t O, int F);
209 #endif /*S_SPLINT_S */
210 #define afs_lseek(FD, O, F)     lseek64(FD, (off64_t) (O), F)
211 #define afs_stat        stat64
212 #define afs_fstat       fstat64
213 #define afs_open        open64
214 #define afs_fopen       fopen64
215 #else /* !O_LARGEFILE */
216 #ifdef S_SPLINT_S
217 extern off_t afs_lseek(int FD, off_t O, int F);
218 #endif /*S_SPLINT_S */
219 #define afs_lseek(FD, O, F)     lseek(FD, (off_t) (O), F)
220 #define afs_stat        stat
221 #define afs_fstat       fstat
222 #define afs_open        open
223 #define afs_fopen       fopen
224 #endif /* !O_LARGEFILE */
225 /*@=fcnmacros =macrofcndecl@*/
226
227 #ifdef  AFS_OSF_ENV
228 extern void *calloc();
229 #endif
230 static char *TimeStamp(time_t clock, int precision);
231
232
233 int debug;                      /* -d flag */
234 extern int Testing;             /* -n flag */
235 int ListInodeOption;            /* -i flag */
236 int ShowRootFiles;              /* -r flag */
237 int RebuildDirs;                /* -sal flag */
238 int Parallel = 4;               /* -para X flag */
239 int PartsPerDisk = 8;           /* Salvage up to 8 partitions on same disk sequentially */
240 int forceR = 0;                 /* -b flag */
241 int ShowLog = 0;                /* -showlog flag */
242 int ShowSuid = 0;               /* -showsuid flag */
243 int ShowMounts = 0;             /* -showmounts flag */
244 int orphans = ORPH_IGNORE;      /* -orphans option */
245 int Showmode = 0;
246
247
248 #ifndef AFS_NT40_ENV
249 int useSyslog = 0;              /* -syslog flag */
250 int useSyslogFacility = LOG_DAEMON;     /* -syslogfacility option */
251 #endif
252
253 #ifdef AFS_NT40_ENV
254 int canfork = 0;
255 #else
256 int canfork = 1;
257 #endif
258
259 #define MAXPARALLEL     32
260
261 int OKToZap;                    /* -o flag */
262 int ForceSalvage;               /* If salvage should occur despite the DONT_SALVAGE flag
263                                  * in the volume header */
264
265 FILE *logFile = 0;      /* one of {/usr/afs/logs,/vice/file}/SalvageLog */
266
267 #define ROOTINODE       2       /* Root inode of a 4.2 Unix file system
268                                  * partition */
269 /**
270  * information that is 'global' to a particular salvage job.
271  */
272 struct SalvInfo {
273     Device fileSysDevice;    /**< The device number of the current partition
274                               *   being salvaged */
275     char fileSysPath[8];     /**< The path of the mounted partition currently
276                               *   being salvaged, i.e. the directory containing
277                               *   the volume headers */
278     char *fileSysPathName;   /**< NT needs this to make name pretty log. */
279     IHandle_t *VGLinkH;      /**< Link handle for current volume group. */
280     int VGLinkH_cnt;         /**< # of references to lnk handle. */
281     struct DiskPartition64 *fileSysPartition; /**< Partition being salvaged */
282
283 #ifndef AFS_NT40_ENV
284     char *fileSysDeviceName; /**< The block device where the file system being
285                               *   salvaged was mounted */
286     char *filesysfulldev;
287 #endif
288     int VolumeChanged;       /**< Set by any routine which would change the
289                               *   volume in a way which would require callbacks
290                               *   to be broken if the volume was put back on
291                               *   on line by an active file server */
292
293     VolumeDiskData VolInfo;  /**< A copy of the last good or salvaged volume
294                               *   header dealt with */
295
296     int nVolumesInInodeFile; /**< Number of read-write volumes summarized */
297     int inodeFd;             /**< File descriptor for inode file */
298
299     struct VolumeSummary *volumeSummaryp; /**< Holds all the volumes in a part */
300     int nVolumes;            /**< Number of volumes (read-write and read-only)
301                               *   in volume summary */
302     struct InodeSummary *inodeSummary; /**< contains info on all the relevant
303                                         *   inodes */
304
305     struct VnodeInfo vnodeInfo[nVNODECLASSES]; /**< contains info on all of the
306                                                 *   vnodes in the volume that
307                                                 *   we are currently looking
308                                                 *   at */
309 };
310
311 char *tmpdir = NULL;
312
313
314
315 /* Forward declarations */
316 static int IsVnodeOrphaned(struct SalvInfo *salvinfo, VnodeId vnode);
317 static int AskVolumeSummary(struct SalvInfo *salvinfo,
318                             VolumeId singleVolumeNumber);
319
320 #ifdef AFS_DEMAND_ATTACH_FS
321 static int LockVolume(struct SalvInfo *salvinfo, VolumeId volumeId);
322 #endif /* AFS_DEMAND_ATTACH_FS */
323
324 /* Uniquifier stored in the Inode */
325 static Unique
326 IUnique(Unique u)
327 {
328 #ifdef  AFS_3DISPARES
329     return (u & 0x3fffff);
330 #else
331 #if defined(AFS_SGI_EXMAG)
332     return (u & SGI_UNIQMASK);
333 #else
334     return (u);
335 #endif /* AFS_SGI_EXMAG */
336 #endif
337 }
338
339 static int
340 BadError(int aerror)
341 {
342     if (aerror == EPERM || aerror == ENXIO || aerror == ENOENT)
343         return 1;
344     return 0;                   /* otherwise may be transient, e.g. EMFILE */
345 }
346
347 #define MAX_ARGS 128
348 #ifdef AFS_NT40_ENV
349 char *save_args[MAX_ARGS];
350 int n_save_args = 0;
351 extern pthread_t main_thread;
352 childJob_t myjob = { SALVAGER_MAGIC, NOT_CHILD, "" };
353 #endif
354
355 /**
356  * Get the salvage lock if not already held. Hold until process exits.
357  *
358  * @param[in] locktype READ_LOCK or WRITE_LOCK
359  */
360 static void
361 _ObtainSalvageLock(int locktype)
362 {
363     struct VLockFile salvageLock;
364     int offset = 0;
365     int nonblock = 1;
366     int code;
367
368     VLockFileInit(&salvageLock, AFSDIR_SERVER_SLVGLOCK_FILEPATH);
369
370     code = VLockFileLock(&salvageLock, offset, locktype, nonblock);
371     if (code == EBUSY) {
372         fprintf(stderr,
373                 "salvager:  There appears to be another salvager running!  "
374                 "Aborted.\n");
375         Exit(1);
376     } else if (code) {
377         fprintf(stderr,
378                 "salvager:  Error %d trying to acquire salvage lock!  "
379                 "Aborted.\n", code);
380         Exit(1);
381     }
382 }
383 void
384 ObtainSalvageLock(void)
385 {
386     _ObtainSalvageLock(WRITE_LOCK);
387 }
388 void
389 ObtainSharedSalvageLock(void)
390 {
391     _ObtainSalvageLock(READ_LOCK);
392 }
393
394
395 #ifdef AFS_SGI_XFS_IOPS_ENV
396 /* Check if the given partition is mounted. For XFS, the root inode is not a
397  * constant. So we check the hard way.
398  */
399 int
400 IsPartitionMounted(char *part)
401 {
402     FILE *mntfp;
403     struct mntent *mntent;
404
405     assert(mntfp = setmntent(MOUNTED, "r"));
406     while (mntent = getmntent(mntfp)) {
407         if (!strcmp(part, mntent->mnt_dir))
408             break;
409     }
410     endmntent(mntfp);
411
412     return mntent ? 1 : 1;
413 }
414 #endif
415 /* Check if the given inode is the root of the filesystem. */
416 #ifndef AFS_SGI_XFS_IOPS_ENV
417 int
418 IsRootInode(struct afs_stat *status)
419 {
420     /*
421      * The root inode is not a fixed value in XFS partitions. So we need to
422      * see if the partition is in the list of mounted partitions. This only
423      * affects the SalvageFileSys path, so we check there.
424      */
425     return (status->st_ino == ROOTINODE);
426 }
427 #endif
428
429 #ifdef AFS_AIX42_ENV
430 #ifndef AFS_NAMEI_ENV
431 /* We don't want to salvage big files filesystems, since we can't put volumes on
432  * them.
433  */
434 int
435 CheckIfBigFilesFS(char *mountPoint, char *devName)
436 {
437     struct superblock fs;
438     char name[128];
439
440     if (strncmp(devName, "/dev/", 5)) {
441         (void)sprintf(name, "/dev/%s", devName);
442     } else {
443         (void)strcpy(name, devName);
444     }
445
446     if (ReadSuper(&fs, name) < 0) {
447         Log("Unable to read superblock. Not salvaging partition %s.\n",
448             mountPoint);
449         return 1;
450     }
451     if (IsBigFilesFileSystem(&fs)) {
452         Log("Partition %s is a big files filesystem, not salvaging.\n",
453             mountPoint);
454         return 1;
455     }
456     return 0;
457 }
458 #endif
459 #endif
460
461 #ifdef AFS_NT40_ENV
462 #define HDSTR "\\Device\\Harddisk"
463 #define HDLEN  (sizeof(HDSTR)-1)        /* Length of "\Device\Harddisk" */
464 int
465 SameDisk(struct DiskPartition64 *p1, struct DiskPartition64 *p2)
466 {
467 #define RES_LEN 256
468     char res[RES_LEN];
469     int d1, d2;
470     static int dowarn = 1;
471
472     if (!QueryDosDevice(p1->devName, res, RES_LEN - 1))
473         return 1;
474     if (strncmp(res, HDSTR, HDLEN)) {
475         if (dowarn) {
476             dowarn = 0;
477             Log("WARNING: QueryDosDevice is returning %s, not %s for %s\n",
478                 res, HDSTR, p1->devName);
479         }
480         return 1;
481     }
482     d1 = atoi(&res[HDLEN]);
483
484     if (!QueryDosDevice(p2->devName, res, RES_LEN - 1))
485         return 1;
486     if (strncmp(res, HDSTR, HDLEN)) {
487         if (dowarn) {
488             dowarn = 0;
489             Log("WARNING: QueryDosDevice is returning %s, not %s for %s\n",
490                 res, HDSTR, p2->devName);
491         }
492         return 1;
493     }
494     d2 = atoi(&res[HDLEN]);
495
496     return d1 == d2;
497 }
498 #else
499 #define SameDisk(P1, P2) ((P1)->device/PartsPerDisk == (P2)->device/PartsPerDisk)
500 #endif
501
502 /* This assumes that two partitions with the same device number divided by
503  * PartsPerDisk are on the same disk.
504  */
505 void
506 SalvageFileSysParallel(struct DiskPartition64 *partP)
507 {
508     struct job {
509         struct DiskPartition64 *partP;
510         int pid;                /* Pid for this job */
511         int jobnumb;            /* Log file job number */
512         struct job *nextjob;    /* Next partition on disk to salvage */
513     };
514     static struct job *jobs[MAXPARALLEL] = { 0 };       /* Need to zero this */
515     struct job *thisjob = 0;
516     static int numjobs = 0;
517     static int jobcount = 0;
518     char buf[1024];
519     int wstatus;
520     struct job *oldjob;
521     int startjob;
522     FILE *passLog;
523     char logFileName[256];
524     int i, j, pid;
525
526     if (partP) {
527         /* We have a partition to salvage. Copy it into thisjob */
528         thisjob = (struct job *)malloc(sizeof(struct job));
529         if (!thisjob) {
530             Log("Can't salvage '%s'. Not enough memory\n", partP->name);
531             return;
532         }
533         memset(thisjob, 0, sizeof(struct job));
534         thisjob->partP = partP;
535         thisjob->jobnumb = jobcount;
536         jobcount++;
537     } else if (jobcount == 0) {
538         /* We are asking to wait for all jobs (partp == 0), yet we never
539          * started any.
540          */
541         Log("No file system partitions named %s* found; not salvaged\n",
542             VICE_PARTITION_PREFIX);
543         return;
544     }
545
546     if (debug || Parallel == 1) {
547         if (thisjob) {
548             SalvageFileSys(thisjob->partP, 0);
549             free(thisjob);
550         }
551         return;
552     }
553
554     if (thisjob) {
555         /* Check to see if thisjob is for a disk that we are already
556          * salvaging. If it is, link it in as the next job to do. The
557          * jobs array has 1 entry per disk being salvages. numjobs is
558          * the total number of disks currently being salvaged. In
559          * order to keep thejobs array compact, when a disk is
560          * completed, the hightest element in the jobs array is moved
561          * down to now open slot.
562          */
563         for (j = 0; j < numjobs; j++) {
564             if (SameDisk(jobs[j]->partP, thisjob->partP)) {
565                 /* On same disk, add it to this list and return */
566                 thisjob->nextjob = jobs[j]->nextjob;
567                 jobs[j]->nextjob = thisjob;
568                 thisjob = 0;
569                 break;
570             }
571         }
572     }
573
574     /* Loop until we start thisjob or until all existing jobs are finished */
575     while (thisjob || (!partP && (numjobs > 0))) {
576         startjob = -1;          /* No new job to start */
577
578         if ((numjobs >= Parallel) || (!partP && (numjobs > 0))) {
579             /* Either the max jobs are running or we have to wait for all
580              * the jobs to finish. In either case, we wait for at least one
581              * job to finish. When it's done, clean up after it.
582              */
583             pid = wait(&wstatus);
584             assert(pid != -1);
585             for (j = 0; j < numjobs; j++) {     /* Find which job it is */
586                 if (pid == jobs[j]->pid)
587                     break;
588             }
589             assert(j < numjobs);
590             if (WCOREDUMP(wstatus)) {   /* Say if the job core dumped */
591                 Log("Salvage of %s core dumped!\n", jobs[j]->partP->name);
592             }
593
594             numjobs--;          /* job no longer running */
595             oldjob = jobs[j];   /* remember */
596             jobs[j] = jobs[j]->nextjob; /* Step to next part on same disk */
597             free(oldjob);       /* free the old job */
598
599             /* If there is another partition on the disk to salvage, then
600              * say we will start it (startjob). If not, then put thisjob there
601              * and say we will start it.
602              */
603             if (jobs[j]) {      /* Another partitions to salvage */
604                 startjob = j;   /* Will start it */
605             } else {            /* There is not another partition to salvage */
606                 if (thisjob) {
607                     jobs[j] = thisjob;  /* Add thisjob */
608                     thisjob = 0;
609                     startjob = j;       /* Will start it */
610                 } else {
611                     jobs[j] = jobs[numjobs];    /* Move last job up to this slot */
612                     startjob = -1;      /* Don't start it - already running */
613                 }
614             }
615         } else {
616             /* We don't have to wait for a job to complete */
617             if (thisjob) {
618                 jobs[numjobs] = thisjob;        /* Add this job */
619                 thisjob = 0;
620                 startjob = numjobs;     /* Will start it */
621             }
622         }
623
624         /* Start up a new salvage job on a partition in job slot "startjob" */
625         if (startjob != -1) {
626             if (!Showmode)
627                 Log("Starting salvage of file system partition %s\n",
628                     jobs[startjob]->partP->name);
629 #ifdef AFS_NT40_ENV
630             /* For NT, we not only fork, but re-exec the salvager. Pass in the
631              * commands and pass the child job number via the data path.
632              */
633             pid =
634                 nt_SalvagePartition(jobs[startjob]->partP->name,
635                                     jobs[startjob]->jobnumb);
636             jobs[startjob]->pid = pid;
637             numjobs++;
638 #else
639             pid = Fork();
640             if (pid) {
641                 jobs[startjob]->pid = pid;
642                 numjobs++;
643             } else {
644                 int fd;
645
646                 ShowLog = 0;
647                 for (fd = 0; fd < 16; fd++)
648                     close(fd);
649                 open("/", 0);
650                 dup2(0, 1);
651                 dup2(0, 2);
652 #ifndef AFS_NT40_ENV
653                 if (useSyslog) {
654                     openlog("salvager", LOG_PID, useSyslogFacility);
655                 } else
656 #endif
657                 {
658                     (void)afs_snprintf(logFileName, sizeof logFileName,
659                                        "%s.%d",
660                                        AFSDIR_SERVER_SLVGLOG_FILEPATH,
661                                        jobs[startjob]->jobnumb);
662                     logFile = afs_fopen(logFileName, "w");
663                 }
664                 if (!logFile)
665                     logFile = stdout;
666
667                 SalvageFileSys1(jobs[startjob]->partP, 0);
668                 Exit(0);
669             }
670 #endif
671         }
672     }                           /* while ( thisjob || (!partP && numjobs > 0) ) */
673
674     /* If waited for all jobs to complete, now collect log files and return */
675 #ifndef AFS_NT40_ENV
676     if (!useSyslog)             /* if syslogging - no need to collect */
677 #endif
678         if (!partP) {
679             for (i = 0; i < jobcount; i++) {
680                 (void)afs_snprintf(logFileName, sizeof logFileName, "%s.%d",
681                                    AFSDIR_SERVER_SLVGLOG_FILEPATH, i);
682                 if ((passLog = afs_fopen(logFileName, "r"))) {
683                     while (fgets(buf, sizeof(buf), passLog)) {
684                         fputs(buf, logFile);
685                     }
686                     fclose(passLog);
687                 }
688                 (void)unlink(logFileName);
689             }
690             fflush(logFile);
691         }
692     return;
693 }
694
695
696 void
697 SalvageFileSys(struct DiskPartition64 *partP, VolumeId singleVolumeNumber)
698 {
699     if (!canfork || debug || Fork() == 0) {
700         SalvageFileSys1(partP, singleVolumeNumber);
701         if (canfork && !debug) {
702             ShowLog = 0;
703             Exit(0);
704         }
705     } else
706         Wait("SalvageFileSys");
707 }
708
709 char *
710 get_DevName(char *pbuffer, char *wpath)
711 {
712     char pbuf[128], *ptr;
713     strcpy(pbuf, pbuffer);
714     ptr = (char *)strrchr(pbuf, '/');
715     if (ptr) {
716         *ptr = '\0';
717         strcpy(wpath, pbuf);
718     } else
719         return NULL;
720     ptr = (char *)strrchr(pbuffer, '/');
721     if (ptr) {
722         strcpy(pbuffer, ptr + 1);
723         return pbuffer;
724     } else
725         return NULL;
726 }
727
728 void
729 SalvageFileSys1(struct DiskPartition64 *partP, VolumeId singleVolumeNumber)
730 {
731     char *name, *tdir;
732     char inodeListPath[256];
733     FILE *inodeFile = NULL;
734     static char tmpDevName[100];
735     static char wpath[100];
736     struct VolumeSummary *vsp, *esp;
737     int i, j;
738     int code;
739     int tries = 0;
740     struct SalvInfo l_salvinfo;
741     struct SalvInfo *salvinfo = &l_salvinfo;
742
743  retry:
744     memset(salvinfo, 0, sizeof(*salvinfo));
745
746     tries++;
747     if (inodeFile) {
748         fclose(inodeFile);
749         inodeFile = NULL;
750     }
751     if (tries > VOL_MAX_CHECKOUT_RETRIES) {
752         Abort("Raced too many times with fileserver restarts while trying to "
753               "checkout/lock volumes; Aborted\n");
754     }
755 #ifdef AFS_DEMAND_ATTACH_FS
756     if (tries > 1) {
757         /* unlock all previous volume locks, since we're about to lock them
758          * again */
759         VLockFileReinit(&partP->volLockFile);
760     }
761 #endif /* AFS_DEMAND_ATTACH_FS */
762
763     salvinfo->fileSysPartition = partP;
764     salvinfo->fileSysDevice = salvinfo->fileSysPartition->device;
765     salvinfo->fileSysPathName = VPartitionPath(salvinfo->fileSysPartition);
766
767 #ifdef AFS_NT40_ENV
768     /* Opendir can fail on "C:" but not on "C:\" if C is empty! */
769     (void)sprintf(salvinfo->fileSysPath, "%s\\", salvinfo->fileSysPathName);
770     name = partP->devName;
771 #else
772     strlcpy(salvinfo->fileSysPath, salvinfo->fileSysPathName, sizeof(salvinfo->fileSysPath));
773     strcpy(tmpDevName, partP->devName);
774     name = get_DevName(tmpDevName, wpath);
775     salvinfo->fileSysDeviceName = name;
776     salvinfo->filesysfulldev = wpath;
777 #endif
778
779     if (singleVolumeNumber) {
780 #ifndef AFS_DEMAND_ATTACH_FS
781         /* only non-DAFS locks the partition when salvaging a single volume;
782          * DAFS will lock the individual volumes in the VG */
783         VLockPartition(partP->name);
784 #endif /* !AFS_DEMAND_ATTACH_FS */
785
786         ForceSalvage = 1;
787
788         /* salvageserver already setup fssync conn for us */
789         if ((programType != salvageServer) && !VConnectFS()) {
790             Abort("Couldn't connect to file server\n");
791         }
792
793         AskOffline(salvinfo, singleVolumeNumber);
794 #ifdef AFS_DEMAND_ATTACH_FS
795         if (LockVolume(salvinfo, singleVolumeNumber)) {
796             goto retry;
797         }
798 #endif /* AFS_DEMAND_ATTACH_FS */
799
800     } else {
801         VLockPartition(partP->name);
802         if (ForceSalvage) {
803             ForceSalvage = 1;
804         } else {
805             ForceSalvage = UseTheForceLuke(salvinfo->fileSysPath);
806         }
807         if (!Showmode)
808             Log("SALVAGING FILE SYSTEM PARTITION %s (device=%s%s)\n",
809                 partP->name, name, (Testing ? "(READONLY mode)" : ""));
810         if (ForceSalvage)
811             Log("***Forced salvage of all volumes on this partition***\n");
812     }
813
814
815     /*
816      * Remove any leftover /vicepa/salvage.inodes.* or /vicepa/salvage.temp.*
817      * files
818      */
819     {
820         DIR *dirp;
821         struct dirent *dp;
822
823         assert((dirp = opendir(salvinfo->fileSysPath)) != NULL);
824         while ((dp = readdir(dirp))) {
825             if (!strncmp(dp->d_name, "salvage.inodes.", 15)
826                 || !strncmp(dp->d_name, "salvage.temp.", 13)) {
827                 char npath[1024];
828                 Log("Removing old salvager temp files %s\n", dp->d_name);
829                 strcpy(npath, salvinfo->fileSysPath);
830                 strcat(npath, "/");
831                 strcat(npath, dp->d_name);
832                 unlink(npath);
833             }
834         }
835         closedir(dirp);
836     }
837     tdir = (tmpdir ? tmpdir : salvinfo->fileSysPath);
838 #ifdef AFS_NT40_ENV
839     (void)_putenv("TMP=");      /* If "TMP" is set, then that overrides tdir. */
840     (void)strncpy(inodeListPath, _tempnam(tdir, "salvage.inodes."), 255);
841 #else
842     snprintf(inodeListPath, 255, "%s/salvage.inodes.%s.%d", tdir, name,
843              getpid());
844 #endif
845
846     inodeFile = fopen(inodeListPath, "w+b");
847     if (!inodeFile) {
848         Abort("Error %d when creating inode description file %s; not salvaged\n", errno, inodeListPath);
849     }
850 #ifdef AFS_NT40_ENV
851     /* Using nt_unlink here since we're really using the delete on close
852      * semantics of unlink. In most places in the salvager, we really do
853      * mean to unlink the file at that point. Those places have been
854      * modified to actually do that so that the NT crt can be used there.
855      */
856     code = nt_unlink(inodeListPath);
857 #else
858     code = unlink(inodeListPath);
859 #endif
860     if (code < 0) {
861         Log("Error %d when trying to unlink %s\n", errno, inodeListPath);
862     }
863
864     if (GetInodeSummary(salvinfo, inodeFile, singleVolumeNumber) < 0) {
865         fclose(inodeFile);
866         return;
867     }
868     salvinfo->inodeFd = fileno(inodeFile);
869     if (salvinfo->inodeFd == -1)
870         Abort("Temporary file %s is missing...\n", inodeListPath);
871     afs_lseek(salvinfo->inodeFd, 0L, SEEK_SET);
872     if (ListInodeOption) {
873         PrintInodeList(salvinfo);
874         return;
875     }
876     /* enumerate volumes in the partition.
877      * figure out sets of read-only + rw volumes.
878      * salvage each set, read-only volumes first, then read-write.
879      * Fix up inodes on last volume in set (whether it is read-write
880      * or read-only).
881      */
882     if (GetVolumeSummary(salvinfo, singleVolumeNumber)) {
883         goto retry;
884     }
885
886     for (i = j = 0, vsp = salvinfo->volumeSummaryp, esp = vsp + salvinfo->nVolumes;
887          i < salvinfo->nVolumesInInodeFile; i = j) {
888         VolumeId rwvid = salvinfo->inodeSummary[i].RWvolumeId;
889         for (j = i;
890              j < salvinfo->nVolumesInInodeFile && salvinfo->inodeSummary[j].RWvolumeId == rwvid;
891              j++) {
892             VolumeId vid = salvinfo->inodeSummary[j].volumeId;
893             struct VolumeSummary *tsp;
894             /* Scan volume list (from partition root directory) looking for the
895              * current rw volume number in the volume list from the inode scan.
896              * If there is one here that is not in the inode volume list,
897              * delete it now. */
898             for (; vsp < esp && (vsp->header.parent < rwvid); vsp++) {
899                 if (vsp->fileName)
900                     DeleteExtraVolumeHeaderFile(salvinfo, vsp);
901             }
902             /* Now match up the volume summary info from the root directory with the
903              * entry in the volume list obtained from scanning inodes */
904             salvinfo->inodeSummary[j].volSummary = NULL;
905             for (tsp = vsp; tsp < esp && (tsp->header.parent == rwvid); tsp++) {
906                 if (tsp->header.id == vid) {
907                     salvinfo->inodeSummary[j].volSummary = tsp;
908                     tsp->fileName = 0;
909                     break;
910                 }
911             }
912         }
913         /* Salvage the group of volumes (several read-only + 1 read/write)
914          * starting with the current read-only volume we're looking at.
915          */
916         SalvageVolumeGroup(salvinfo, &salvinfo->inodeSummary[i], j - i);
917     }
918
919     /* Delete any additional volumes that were listed in the partition but which didn't have any corresponding inodes */
920     for (; vsp < esp; vsp++) {
921         if (vsp->fileName)
922             DeleteExtraVolumeHeaderFile(salvinfo, vsp);
923     }
924
925     if (!singleVolumeNumber)    /* Remove the FORCESALVAGE file */
926         RemoveTheForce(salvinfo->fileSysPath);
927
928     if (!Testing && singleVolumeNumber) {
929 #ifdef AFS_DEMAND_ATTACH_FS
930         /* unlock vol headers so the fs can attach them when we AskOnline */
931         VLockFileReinit(&salvinfo->fileSysPartition->volLockFile);
932 #endif /* AFS_DEMAND_ATTACH_FS */
933
934         AskOnline(salvinfo, singleVolumeNumber);
935
936         /* Step through the volumeSummary list and set all volumes on-line.
937          * The volumes were taken off-line in GetVolumeSummary.
938          */
939         for (j = 0; j < salvinfo->nVolumes; j++) {
940             AskOnline(salvinfo, salvinfo->volumeSummaryp[j].header.id);
941         }
942     } else {
943         if (!Showmode)
944             Log("SALVAGING OF PARTITION %s%s COMPLETED\n",
945                 salvinfo->fileSysPartition->name, (Testing ? " (READONLY mode)" : ""));
946     }
947
948     fclose(inodeFile);          /* SalvageVolumeGroup was the last which needed it. */
949 }
950
951 void
952 DeleteExtraVolumeHeaderFile(struct SalvInfo *salvinfo, struct VolumeSummary *vsp)
953 {
954     char path[64];
955     sprintf(path, "%s/%s", salvinfo->fileSysPath, vsp->fileName);
956
957     if (!Showmode)
958         Log("The volume header file %s is not associated with any actual data (%sdeleted)\n", path, (Testing ? "would have been " : ""));
959     if (!Testing) {
960         afs_int32 code;
961         code = VDestroyVolumeDiskHeader(salvinfo->fileSysPartition, vsp->header.id, vsp->header.parent);
962         if (code) {
963             Log("Error %ld destroying volume disk header for volume %lu\n",
964                 afs_printable_int32_ld(code),
965                 afs_printable_uint32_lu(vsp->header.id));
966         }
967
968         /* make sure we actually delete the fileName file; ENOENT
969          * is fine, since VDestroyVolumeDiskHeader probably already
970          * unlinked it */
971         if (unlink(path) && errno != ENOENT) {
972             Log("Unable to unlink %s (errno = %d)\n", path, errno);
973         }
974     }
975     vsp->fileName = 0;
976 }
977
978 int
979 CompareInodes(const void *_p1, const void *_p2)
980 {
981     const struct ViceInodeInfo *p1 = _p1;
982     const struct ViceInodeInfo *p2 = _p2;
983     if (p1->u.vnode.vnodeNumber == INODESPECIAL
984         || p2->u.vnode.vnodeNumber == INODESPECIAL) {
985         VolumeId p1rwid, p2rwid;
986         p1rwid =
987             (p1->u.vnode.vnodeNumber ==
988              INODESPECIAL ? p1->u.special.parentId : p1->u.vnode.volumeId);
989         p2rwid =
990             (p2->u.vnode.vnodeNumber ==
991              INODESPECIAL ? p2->u.special.parentId : p2->u.vnode.volumeId);
992         if (p1rwid < p2rwid)
993             return -1;
994         if (p1rwid > p2rwid)
995             return 1;
996         if (p1->u.vnode.vnodeNumber == INODESPECIAL
997             && p2->u.vnode.vnodeNumber == INODESPECIAL) {
998             if (p1->u.vnode.volumeId == p2->u.vnode.volumeId)
999                 return (p1->u.special.type < p2->u.special.type ? -1 : 1);
1000             if (p1->u.vnode.volumeId == p1rwid)
1001                 return -1;
1002             if (p2->u.vnode.volumeId == p2rwid)
1003                 return 1;
1004             return (p1->u.vnode.volumeId < p2->u.vnode.volumeId ? -1 : 1);
1005         }
1006         if (p1->u.vnode.vnodeNumber != INODESPECIAL)
1007             return (p2->u.vnode.volumeId == p2rwid ? 1 : -1);
1008         return (p1->u.vnode.volumeId == p1rwid ? -1 : 1);
1009     }
1010     if (p1->u.vnode.volumeId < p2->u.vnode.volumeId)
1011         return -1;
1012     if (p1->u.vnode.volumeId > p2->u.vnode.volumeId)
1013         return 1;
1014     if (p1->u.vnode.vnodeNumber < p2->u.vnode.vnodeNumber)
1015         return -1;
1016     if (p1->u.vnode.vnodeNumber > p2->u.vnode.vnodeNumber)
1017         return 1;
1018     /* The following tests are reversed, so that the most desirable
1019      * of several similar inodes comes first */
1020     if (p1->u.vnode.vnodeUniquifier > p2->u.vnode.vnodeUniquifier) {
1021 #ifdef  AFS_3DISPARES
1022         if (p1->u.vnode.vnodeUniquifier > 3775414 /* 90% of 4.2M */  &&
1023             p2->u.vnode.vnodeUniquifier < 419490 /* 10% of 4.2M */ )
1024             return 1;
1025 #endif
1026 #ifdef  AFS_SGI_EXMAG
1027         if (p1->u.vnode.vnodeUniquifier > 15099494 /* 90% of 16M */  &&
1028             p2->u.vnode.vnodeUniquifier < 1677721 /* 10% of 16M */ )
1029             return 1;
1030 #endif
1031         return -1;
1032     }
1033     if (p1->u.vnode.vnodeUniquifier < p2->u.vnode.vnodeUniquifier) {
1034 #ifdef  AFS_3DISPARES
1035         if (p2->u.vnode.vnodeUniquifier > 3775414 /* 90% of 4.2M */  &&
1036             p1->u.vnode.vnodeUniquifier < 419490 /* 10% of 4.2M */ )
1037             return -1;
1038 #endif
1039 #ifdef  AFS_SGI_EXMAG
1040         if (p2->u.vnode.vnodeUniquifier > 15099494 /* 90% of 16M */  &&
1041             p1->u.vnode.vnodeUniquifier < 1677721 /* 10% of 16M */ )
1042             return 1;
1043 #endif
1044         return 1;
1045     }
1046     if (p1->u.vnode.inodeDataVersion > p2->u.vnode.inodeDataVersion) {
1047 #ifdef  AFS_3DISPARES
1048         if (p1->u.vnode.inodeDataVersion > 1887437 /* 90% of 2.1M */  &&
1049             p2->u.vnode.inodeDataVersion < 209716 /* 10% of 2.1M */ )
1050             return 1;
1051 #endif
1052 #ifdef  AFS_SGI_EXMAG
1053         if (p1->u.vnode.inodeDataVersion > 15099494 /* 90% of 16M */  &&
1054             p2->u.vnode.inodeDataVersion < 1677721 /* 10% of 16M */ )
1055             return 1;
1056 #endif
1057         return -1;
1058     }
1059     if (p1->u.vnode.inodeDataVersion < p2->u.vnode.inodeDataVersion) {
1060 #ifdef  AFS_3DISPARES
1061         if (p2->u.vnode.inodeDataVersion > 1887437 /* 90% of 2.1M */  &&
1062             p1->u.vnode.inodeDataVersion < 209716 /* 10% of 2.1M */ )
1063             return -1;
1064 #endif
1065 #ifdef  AFS_SGI_EXMAG
1066         if (p2->u.vnode.inodeDataVersion > 15099494 /* 90% of 16M */  &&
1067             p1->u.vnode.inodeDataVersion < 1677721 /* 10% of 16M */ )
1068             return 1;
1069 #endif
1070         return 1;
1071     }
1072     return 0;
1073 }
1074
1075 void
1076 CountVolumeInodes(struct ViceInodeInfo *ip, int maxInodes,
1077                   struct InodeSummary *summary)
1078 {
1079     VolumeId volume = ip->u.vnode.volumeId;
1080     VolumeId rwvolume = volume;
1081     int n, nSpecial;
1082     Unique maxunique;
1083     n = nSpecial = 0;
1084     maxunique = 0;
1085     while (maxInodes-- && volume == ip->u.vnode.volumeId) {
1086         n++;
1087         if (ip->u.vnode.vnodeNumber == INODESPECIAL) {
1088             nSpecial++;
1089             rwvolume = ip->u.special.parentId;
1090             /* This isn't quite right, as there could (in error) be different
1091              * parent inodes in different special vnodes */
1092         } else {
1093             if (maxunique < ip->u.vnode.vnodeUniquifier)
1094                 maxunique = ip->u.vnode.vnodeUniquifier;
1095         }
1096         ip++;
1097     }
1098     summary->volumeId = volume;
1099     summary->RWvolumeId = rwvolume;
1100     summary->nInodes = n;
1101     summary->nSpecialInodes = nSpecial;
1102     summary->maxUniquifier = maxunique;
1103 }
1104
1105 int
1106 OnlyOneVolume(struct ViceInodeInfo *inodeinfo, afs_uint32 singleVolumeNumber, void *rock)
1107 {
1108     if (inodeinfo->u.vnode.vnodeNumber == INODESPECIAL)
1109         return (inodeinfo->u.special.parentId == singleVolumeNumber);
1110     return (inodeinfo->u.vnode.volumeId == singleVolumeNumber);
1111 }
1112
1113 /* GetInodeSummary
1114  *
1115  * Collect list of inodes in file named by path. If a truly fatal error,
1116  * unlink the file and abort. For lessor errors, return -1. The file will
1117  * be unlinked by the caller.
1118  */
1119 int
1120 GetInodeSummary(struct SalvInfo *salvinfo, FILE *inodeFile, VolumeId singleVolumeNumber)
1121 {
1122     struct afs_stat status;
1123     int forceSal, err;
1124     int code;
1125     struct ViceInodeInfo *ip, *ip_save;
1126     struct InodeSummary summary;
1127     char summaryFileName[50];
1128     FILE *summaryFile;
1129 #ifdef AFS_NT40_ENV
1130     char *dev = salvinfo->fileSysPath;
1131     char *wpath = salvinfo->fileSysPath;
1132 #else
1133     char *dev = salvinfo->fileSysDeviceName;
1134     char *wpath = salvinfo->filesysfulldev;
1135 #endif
1136     char *part = salvinfo->fileSysPath;
1137     char *tdir;
1138     int i;
1139
1140     /* This file used to come from vfsck; cobble it up ourselves now... */
1141     if ((err =
1142          ListViceInodes(dev, salvinfo->fileSysPath, inodeFile,
1143                         singleVolumeNumber ? OnlyOneVolume : 0,
1144                         singleVolumeNumber, &forceSal, forceR, wpath, NULL)) < 0) {
1145         if (err == -2) {
1146             Log("*** I/O error %d when writing a tmp inode file; Not salvaged %s ***\nIncrease space on partition or use '-tmpdir'\n", errno, dev);
1147             return -1;
1148         }
1149         Abort("Unable to get inodes for \"%s\"; not salvaged\n", dev);
1150     }
1151     if (forceSal && !ForceSalvage) {
1152         Log("***Forced salvage of all volumes on this partition***\n");
1153         ForceSalvage = 1;
1154     }
1155     fseek(inodeFile, 0L, SEEK_SET);
1156     salvinfo->inodeFd = fileno(inodeFile);
1157     if (salvinfo->inodeFd == -1 || afs_fstat(salvinfo->inodeFd, &status) == -1) {
1158         Abort("No inode description file for \"%s\"; not salvaged\n", dev);
1159     }
1160     tdir = (tmpdir ? tmpdir : part);
1161 #ifdef AFS_NT40_ENV
1162     (void)_putenv("TMP=");      /* If "TMP" is set, then that overrides tdir. */
1163     (void)strcpy(summaryFileName, _tempnam(tdir, "salvage.temp"));
1164 #else
1165     (void)afs_snprintf(summaryFileName, sizeof summaryFileName,
1166                        "%s/salvage.temp.%d", tdir, getpid());
1167 #endif
1168     summaryFile = afs_fopen(summaryFileName, "a+");
1169     if (summaryFile == NULL) {
1170         Abort("Unable to create inode summary file\n");
1171     }
1172
1173 #ifdef AFS_NT40_ENV
1174     /* Using nt_unlink here since we're really using the delete on close
1175      * semantics of unlink. In most places in the salvager, we really do
1176      * mean to unlink the file at that point. Those places have been
1177      * modified to actually do that so that the NT crt can be used there.
1178      */
1179     code = nt_unlink(summaryFileName);
1180 #else
1181     code = unlink(summaryFileName);
1182 #endif
1183     if (code < 0) {
1184         Log("Error %d when trying to unlink %s\n", errno, summaryFileName);
1185     }
1186
1187     if (!canfork || debug || Fork() == 0) {
1188         int nInodes;
1189         unsigned long st_size=(unsigned long) status.st_size;
1190         nInodes = st_size / sizeof(struct ViceInodeInfo);
1191         if (nInodes == 0) {
1192             fclose(summaryFile);
1193             if (!singleVolumeNumber)    /* Remove the FORCESALVAGE file */
1194                 RemoveTheForce(salvinfo->fileSysPath);
1195             else {
1196                 struct VolumeSummary *vsp;
1197                 int i;
1198
1199                 GetVolumeSummary(salvinfo, singleVolumeNumber);
1200
1201                 for (i = 0, vsp = salvinfo->volumeSummaryp; i < salvinfo->nVolumes; i++) {
1202                     if (vsp->fileName)
1203                         DeleteExtraVolumeHeaderFile(salvinfo, vsp);
1204                 }
1205             }
1206             Log("%s vice inodes on %s; not salvaged\n",
1207                 singleVolumeNumber ? "No applicable" : "No", dev);
1208             return -1;
1209         }
1210         ip = (struct ViceInodeInfo *)malloc(nInodes*sizeof(struct ViceInodeInfo));
1211         if (ip == NULL) {
1212             fclose(summaryFile);
1213             Abort
1214                 ("Unable to allocate enough space to read inode table; %s not salvaged\n",
1215                  dev);
1216         }
1217         if (read(salvinfo->inodeFd, ip, st_size) != st_size) {
1218             fclose(summaryFile);
1219             Abort("Unable to read inode table; %s not salvaged\n", dev);
1220         }
1221         qsort(ip, nInodes, sizeof(struct ViceInodeInfo), CompareInodes);
1222         if (afs_lseek(salvinfo->inodeFd, 0, SEEK_SET) == -1
1223             || write(salvinfo->inodeFd, ip, st_size) != st_size) {
1224             fclose(summaryFile);
1225             Abort("Unable to rewrite inode table; %s not salvaged\n", dev);
1226         }
1227         summary.index = 0;
1228         ip_save = ip;
1229         while (nInodes) {
1230             CountVolumeInodes(ip, nInodes, &summary);
1231             if (fwrite(&summary, sizeof(summary), 1, summaryFile) != 1) {
1232                 Log("Difficulty writing summary file (errno = %d); %s not salvaged\n", errno, dev);
1233                 fclose(summaryFile);
1234                 return -1;
1235             }
1236             summary.index += (summary.nInodes);
1237             nInodes -= summary.nInodes;
1238             ip += summary.nInodes;
1239         }
1240         free(ip_save);
1241         ip = ip_save = NULL;
1242         /* Following fflush is not fclose, because if it was debug mode would not work */
1243         if (fflush(summaryFile) == EOF || fsync(fileno(summaryFile)) == -1) {
1244             Log("Unable to write summary file (errno = %d); %s not salvaged\n", errno, dev);
1245             fclose(summaryFile);
1246             return -1;
1247         }
1248         if (canfork && !debug) {
1249             ShowLog = 0;
1250             Exit(0);
1251         }
1252     } else {
1253         if (Wait("Inode summary") == -1) {
1254             fclose(summaryFile);
1255             Exit(1);            /* salvage of this partition aborted */
1256         }
1257     }
1258     assert(afs_fstat(fileno(summaryFile), &status) != -1);
1259     if (status.st_size != 0) {
1260         int ret;
1261         unsigned long st_status=(unsigned long)status.st_size;
1262         salvinfo->inodeSummary = (struct InodeSummary *)malloc(st_status);
1263         assert(salvinfo->inodeSummary != NULL);
1264         /* For GNU we need to do lseek to get the file pointer moved. */
1265         assert(afs_lseek(fileno(summaryFile), 0, SEEK_SET) == 0);
1266         ret = read(fileno(summaryFile), salvinfo->inodeSummary, st_status);
1267         assert(ret == st_status);
1268     }
1269     salvinfo->nVolumesInInodeFile =(unsigned long)(status.st_size) / sizeof(struct InodeSummary);
1270     for (i = 0; i < salvinfo->nVolumesInInodeFile; i++) {
1271         salvinfo->inodeSummary[i].volSummary = NULL;
1272     }
1273     Log("%d nVolumesInInodeFile %lu \n",salvinfo->nVolumesInInodeFile,(unsigned long)(status.st_size));
1274     fclose(summaryFile);
1275     return 0;
1276 }
1277
1278 /* Comparison routine for volume sort.
1279    This is setup so that a read-write volume comes immediately before
1280    any read-only clones of that volume */
1281 int
1282 CompareVolumes(const void *_p1, const void *_p2)
1283 {
1284     const struct VolumeSummary *p1 = _p1;
1285     const struct VolumeSummary *p2 = _p2;
1286     if (p1->header.parent != p2->header.parent)
1287         return p1->header.parent < p2->header.parent ? -1 : 1;
1288     if (p1->header.id == p1->header.parent)     /* p1 is rw volume */
1289         return -1;
1290     if (p2->header.id == p2->header.parent)     /* p2 is rw volume */
1291         return 1;
1292     return p1->header.id < p2->header.id ? -1 : 1;      /* Both read-only */
1293 }
1294
1295 /**
1296  * Gleans volumeSummary information by asking the fileserver
1297  *
1298  * @param[in] singleVolumeNumber  the volume we're salvaging. 0 if we're
1299  *                                salvaging a whole partition
1300  *
1301  * @return whether we obtained the volume summary information or not
1302  *  @retval 0  success; we obtained the volume summary information
1303  *  @retval -1 we raced with a fileserver restart; volume locks and checkout
1304  *             must be retried
1305  *  @retval 1  we did not get the volume summary information; either the
1306  *             fileserver responded with an error, or we are not supposed to
1307  *             ask the fileserver for the information (e.g. we are salvaging
1308  *             the entire partition or we are not the salvageserver)
1309  *
1310  * @note for non-DAFS, always returns 1
1311  */
1312 static int
1313 AskVolumeSummary(struct SalvInfo *salvinfo, VolumeId singleVolumeNumber)
1314 {
1315     afs_int32 code = 1;
1316 #if defined(FSSYNC_BUILD_CLIENT) && defined(AFS_DEMAND_ATTACH_FS)
1317     if (programType == salvageServer) {
1318         if (singleVolumeNumber) {
1319             FSSYNC_VGQry_response_t q_res;
1320             SYNC_response res;
1321             struct VolumeSummary *vsp;
1322             int i;
1323             struct VolumeDiskHeader diskHdr;
1324
1325             memset(&res, 0, sizeof(res));
1326
1327             code = FSYNC_VGCQuery(salvinfo->fileSysPartition->name, singleVolumeNumber, &q_res, &res);
1328
1329             /*
1330              * We must wait for the partition to finish scanning before
1331              * can continue, since we will not know if we got the entire
1332              * VG membership unless the partition is fully scanned.
1333              * We could, in theory, just scan the partition ourselves if
1334              * the VG cache is not ready, but we would be doing the exact
1335              * same scan the fileserver is doing; it will almost always
1336              * be faster to wait for the fileserver. The only exceptions
1337              * are if the partition does not take very long to scan, and
1338              * in that case it's fast either way, so who cares?
1339              */
1340             if (code == SYNC_FAILED && res.hdr.reason == FSYNC_PART_SCANNING) {
1341                 Log("waiting for fileserver to finish scanning partition %s...\n",
1342                     salvinfo->fileSysPartition->name);
1343
1344                 for (i = 1; code == SYNC_FAILED && res.hdr.reason == FSYNC_PART_SCANNING; i++) {
1345                     /* linearly ramp up from 1 to 10 seconds; nothing fancy,
1346                      * just so small partitions don't need to wait over 10
1347                      * seconds every time, and large partitions are generally
1348                      * polled only once every ten seconds. */
1349                     sleep((i > 10) ? (i = 10) : i);
1350
1351                     code = FSYNC_VGCQuery(salvinfo->fileSysPartition->name, singleVolumeNumber, &q_res, &res);
1352                 }
1353             }
1354
1355             if (code == SYNC_FAILED && res.hdr.reason == FSYNC_UNKNOWN_VOLID) {
1356                 /* This can happen if there's no header for the volume
1357                  * we're salvaging, or no headers exist for the VG (if
1358                  * we're salvaging an RW). Act as if we got a response
1359                  * with no VG members. The headers may be created during
1360                  * salvaging, if there are inodes in this VG. */
1361                 code = 0;
1362                 memset(&q_res, 0, sizeof(q_res));
1363                 q_res.rw = singleVolumeNumber;
1364             }
1365
1366             if (code) {
1367                 Log("fileserver refused VGCQuery request for volume %lu on "
1368                     "partition %s, code %ld reason %ld\n",
1369                     afs_printable_uint32_lu(singleVolumeNumber),
1370                     salvinfo->fileSysPartition->name,
1371                     afs_printable_int32_ld(code),
1372                     afs_printable_int32_ld(res.hdr.reason));
1373                 goto done;
1374             }
1375
1376             if (q_res.rw != singleVolumeNumber) {
1377                 Log("fileserver requested salvage of clone %lu; scheduling salvage of volume group %lu...\n",
1378                     afs_printable_uint32_lu(singleVolumeNumber),
1379                     afs_printable_uint32_lu(q_res.rw));
1380 #ifdef SALVSYNC_BUILD_CLIENT
1381                 if (SALVSYNC_LinkVolume(q_res.rw,
1382                                        singleVolumeNumber,
1383                                        salvinfo->fileSysPartition->name,
1384                                        NULL) != SYNC_OK) {
1385                     Log("schedule request failed\n");
1386                 }
1387 #endif /* SALVSYNC_BUILD_CLIENT */
1388                 Exit(SALSRV_EXIT_VOLGROUP_LINK);
1389             }
1390
1391             salvinfo->volumeSummaryp = malloc(VOL_VG_MAX_VOLS * sizeof(struct VolumeSummary));
1392             assert(salvinfo->volumeSummaryp != NULL);
1393
1394             salvinfo->nVolumes = 0;
1395             vsp = salvinfo->volumeSummaryp;
1396
1397             for (i = 0; i < VOL_VG_MAX_VOLS; i++) {
1398                 char name[VMAXPATHLEN];
1399
1400                 if (!q_res.children[i]) {
1401                     continue;
1402                 }
1403
1404                 /* AskOffline for singleVolumeNumber was called much earlier */
1405                 if (q_res.children[i] != singleVolumeNumber) {
1406                     AskOffline(salvinfo, q_res.children[i]);
1407                     if (LockVolume(salvinfo, q_res.children[i])) {
1408                         /* need to retry */
1409                         return -1;
1410                     }
1411                 }
1412
1413                 code = VReadVolumeDiskHeader(q_res.children[i], salvinfo->fileSysPartition, &diskHdr);
1414                 if (code) {
1415                     Log("Cannot read header for %lu; trying to salvage group anyway\n",
1416                         afs_printable_uint32_lu(q_res.children[i]));
1417                     code = 0;
1418                     continue;
1419                 }
1420
1421                 DiskToVolumeHeader(&vsp->header, &diskHdr);
1422                 VolumeExternalName_r(q_res.children[i], name, sizeof(name));
1423                 vsp->fileName = ToString(name);
1424                 salvinfo->nVolumes++;
1425                 vsp++;
1426             }
1427
1428             qsort(salvinfo->volumeSummaryp, salvinfo->nVolumes, sizeof(struct VolumeSummary),
1429                   CompareVolumes);
1430         }
1431       done:
1432         if (code) {
1433             Log("Cannot get volume summary from fileserver; falling back to scanning "
1434                 "entire partition\n");
1435         }
1436     }
1437 #endif /* FSSYNC_BUILD_CLIENT && AFS_DEMAND_ATTACH_FS */
1438     return code;
1439 }
1440
1441 /**
1442  * count how many volume headers are found by VWalkVolumeHeaders.
1443  *
1444  * @param[in] dp   the disk partition (unused)
1445  * @param[in] name full path to the .vol header (unused)
1446  * @param[in] hdr  the header data (unused)
1447  * @param[in] last whether this is the last try or not (unused)
1448  * @param[in] rock actually an afs_int32*; the running count of how many
1449  *                 volumes we have found
1450  *
1451  * @retval 0 always
1452  */
1453 static int
1454 CountHeader(struct DiskPartition64 *dp, const char *name,
1455             struct VolumeDiskHeader *hdr, int last, void *rock)
1456 {
1457     afs_int32 *nvols = (afs_int32 *)rock;
1458     (*nvols)++;
1459     return 0;
1460 }
1461
1462 /**
1463  * parameters to pass to the VWalkVolumeHeaders callbacks when recording volume
1464  * data.
1465  */
1466 struct SalvageScanParams {
1467     VolumeId singleVolumeNumber; /**< 0 for a partition-salvage, otherwise the
1468                                   * vol id of the VG we're salvaging */
1469     struct VolumeSummary *vsp;   /**< ptr to the current volume summary object
1470                                   * we're filling in */
1471     afs_int32 nVolumes;          /**< # of vols we've encountered */
1472     afs_int32 totalVolumes;      /**< max # of vols we should encounter (the
1473                                   * # of vols we've alloc'd memory for) */
1474     int retry;  /**< do we need to retry vol lock/checkout? */
1475     struct SalvInfo *salvinfo; /**< salvage job info */
1476 };
1477
1478 /**
1479  * records volume summary info found from VWalkVolumeHeaders.
1480  *
1481  * Found volumes are also taken offline if they are in the specific volume
1482  * group we are looking for.
1483  *
1484  * @param[in] dp   the disk partition
1485  * @param[in] name full path to the .vol header
1486  * @param[in] hdr  the header data
1487  * @param[in] last 1 if this is the last try to read the header, 0 otherwise
1488  * @param[in] rock actually a struct SalvageScanParams*, containing the
1489  *                 information needed to record the volume summary data
1490  *
1491  * @return operation status
1492  *  @retval 0  success
1493  *  @retval -1 volume locking raced with fileserver restart; checking out
1494  *             and locking volumes needs to be retried
1495  *  @retval 1  volume header is mis-named and should be deleted
1496  */
1497 static int
1498 RecordHeader(struct DiskPartition64 *dp, const char *name,
1499              struct VolumeDiskHeader *hdr, int last, void *rock)
1500 {
1501     char nameShouldBe[64];
1502     struct SalvageScanParams *params;
1503     struct VolumeSummary summary;
1504     VolumeId singleVolumeNumber;
1505     struct SalvInfo *salvinfo;
1506
1507     params = (struct SalvageScanParams *)rock;
1508
1509     singleVolumeNumber = params->singleVolumeNumber;
1510     salvinfo = params->salvinfo;
1511
1512     DiskToVolumeHeader(&summary.header, hdr);
1513
1514     if (singleVolumeNumber && summary.header.id == singleVolumeNumber
1515         && summary.header.parent != singleVolumeNumber) {
1516
1517         if (programType == salvageServer) {
1518 #ifdef SALVSYNC_BUILD_CLIENT
1519             Log("fileserver requested salvage of clone %u; scheduling salvage of volume group %u...\n",
1520                 summary.header.id, summary.header.parent);
1521             if (SALVSYNC_LinkVolume(summary.header.parent,
1522                                     summary.header.id,
1523                                     dp->name,
1524                                     NULL) != SYNC_OK) {
1525                 Log("schedule request failed\n");
1526             }
1527 #endif
1528             Exit(SALSRV_EXIT_VOLGROUP_LINK);
1529
1530         } else {
1531             Log("%u is a read-only volume; not salvaged\n",
1532                 singleVolumeNumber);
1533             Exit(1);
1534         }
1535     }
1536
1537     if (!singleVolumeNumber || summary.header.id == singleVolumeNumber
1538         || summary.header.parent == singleVolumeNumber) {
1539
1540         /* check if the header file is incorrectly named */
1541         int badname = 0;
1542         const char *base = strrchr(name, '/');
1543         if (base) {
1544             base++;
1545         } else {
1546             base = name;
1547         }
1548
1549         (void)afs_snprintf(nameShouldBe, sizeof nameShouldBe,
1550                            VFORMAT, afs_printable_uint32_lu(summary.header.id));
1551
1552
1553         if (strcmp(nameShouldBe, base)) {
1554             /* .vol file has wrong name; retry/delete */
1555             badname = 1;
1556         }
1557
1558         if (!badname || last) {
1559             /* only offline the volume if the header is good, or if this is
1560              * the last try looking at it; avoid AskOffline'ing the same vol
1561              * multiple times */
1562
1563             if (singleVolumeNumber
1564                 && summary.header.id != singleVolumeNumber) {
1565                 /* don't offline singleVolumeNumber; we already did that
1566                  * earlier */
1567
1568                 AskOffline(salvinfo, summary.header.id);
1569
1570 #ifdef AFS_DEMAND_ATTACH_FS
1571                 if (!badname) {
1572                     /* don't lock the volume if the header is bad, since we're
1573                      * about to delete it anyway. */
1574                     if (LockVolume(salvinfo, summary.header.id)) {
1575                         params->retry = 1;
1576                         return -1;
1577                     }
1578                 }
1579 #endif /* AFS_DEMAND_ATTACH_FS */
1580             }
1581         }
1582         if (badname) {
1583             if (last && !Showmode) {
1584                 Log("Volume header file %s is incorrectly named (should be %s "
1585                     "not %s); %sdeleted (it will be recreated later, if "
1586                     "necessary)\n", name, nameShouldBe, base,
1587                     (Testing ? "it would have been " : ""));
1588             }
1589             return 1;
1590         }
1591
1592         summary.fileName = ToString(base);
1593         params->nVolumes++;
1594
1595         if (params->nVolumes > params->totalVolumes) {
1596             /* We found more volumes than we found on the first partition walk;
1597              * apparently something created a volume while we were
1598              * partition-salvaging, or we found more than 20 vols when salvaging a
1599              * particular volume. Abort if we detect this, since other programs
1600              * supposed to not touch the partition while it is partition-salvaging,
1601              * and we shouldn't find more than 20 vols in a VG.
1602              */
1603             Abort("Found %ld vol headers, but should have found at most %ld! "
1604                   "Make sure the volserver/fileserver are not running at the "
1605                   "same time as a partition salvage\n",
1606                   afs_printable_int32_ld(params->nVolumes),
1607                   afs_printable_int32_ld(params->totalVolumes));
1608         }
1609
1610         memcpy(params->vsp, &summary, sizeof(summary));
1611         params->vsp++;
1612     }
1613
1614     return 0;
1615 }
1616
1617 /**
1618  * possibly unlinks bad volume headers found from VWalkVolumeHeaders.
1619  *
1620  * If the header could not be read in at all, the header is always unlinked.
1621  * If instead RecordHeader said the header was bad (that is, the header file
1622  * is mis-named), we only unlink if we are doing a partition salvage, as
1623  * opposed to salvaging a specific volume group.
1624  *
1625  * @param[in] dp   the disk partition
1626  * @param[in] name full path to the .vol header
1627  * @param[in] hdr  header data, or NULL if the header could not be read
1628  * @param[in] rock actually a struct SalvageScanParams*, with some information
1629  *                 about the scan
1630  */
1631 static void
1632 UnlinkHeader(struct DiskPartition64 *dp, const char *name,
1633              struct VolumeDiskHeader *hdr, void *rock)
1634 {
1635     struct SalvageScanParams *params;
1636     int dounlink = 0;
1637
1638     params = (struct SalvageScanParams *)rock;
1639
1640     if (!hdr) {
1641         /* no header; header is too bogus to read in at all */
1642         if (!Showmode) {
1643             Log("%s is not a legitimate volume header file; %sdeleted\n", name, (Testing ? "it would have been " : ""));
1644         }
1645         if (!Testing) {
1646             dounlink = 1;
1647         }
1648
1649     } else if (!params->singleVolumeNumber) {
1650         /* We were able to read in a header, but RecordHeader said something
1651          * was wrong with it. We only unlink those if we are doing a partition
1652          * salvage. */
1653         if (!Testing) {
1654             dounlink = 1;
1655         }
1656     }
1657
1658     if (dounlink && unlink(name)) {
1659         Log("Error %d while trying to unlink %s\n", errno, name);
1660     }
1661 }
1662
1663 /**
1664  * Populates salvinfo->volumeSummaryp with volume summary information, either by asking
1665  * the fileserver for VG information, or by scanning the /vicepX partition.
1666  *
1667  * @param[in] singleVolumeNumber  the volume ID of the single volume group we
1668  *                                are salvaging, or 0 if this is a partition
1669  *                                salvage
1670  *
1671  * @return operation status
1672  *  @retval 0  success
1673  *  @retval -1 we raced with a fileserver restart; checking out and locking
1674  *             volumes must be retried
1675  */
1676 int
1677 GetVolumeSummary(struct SalvInfo *salvinfo, VolumeId singleVolumeNumber)
1678 {
1679     afs_int32 nvols = 0;
1680     struct SalvageScanParams params;
1681     int code;
1682
1683     code = AskVolumeSummary(salvinfo, singleVolumeNumber);
1684     if (code == 0) {
1685         /* we successfully got the vol information from the fileserver; no
1686          * need to scan the partition */
1687         return 0;
1688     }
1689     if (code < 0) {
1690         /* we need to retry volume checkout */
1691         return code;
1692     }
1693
1694     if (!singleVolumeNumber) {
1695         /* Count how many volumes we have in /vicepX */
1696         code = VWalkVolumeHeaders(salvinfo->fileSysPartition, salvinfo->fileSysPath, CountHeader,
1697                                   NULL, &nvols);
1698         if (code < 0) {
1699             Abort("Can't read directory %s; not salvaged\n", salvinfo->fileSysPath);
1700         }
1701         if (!nvols)
1702             nvols = 1;
1703     } else {
1704         nvols = VOL_VG_MAX_VOLS;
1705     }
1706
1707     salvinfo->volumeSummaryp = malloc(nvols * sizeof(struct VolumeSummary));
1708     assert(salvinfo->volumeSummaryp != NULL);
1709
1710     params.singleVolumeNumber = singleVolumeNumber;
1711     params.vsp = salvinfo->volumeSummaryp;
1712     params.nVolumes = 0;
1713     params.totalVolumes = nvols;
1714     params.retry = 0;
1715     params.salvinfo = salvinfo;
1716
1717     /* walk the partition directory of volume headers and record the info
1718      * about them; unlinking invalid headers */
1719     code = VWalkVolumeHeaders(salvinfo->fileSysPartition, salvinfo->fileSysPath, RecordHeader,
1720                               UnlinkHeader, &params);
1721     if (params.retry) {
1722         /* we apparently need to retry checking-out/locking volumes */
1723         return -1;
1724     }
1725     if (code < 0) {
1726         Abort("Failed to get volume header summary\n");
1727     }
1728     salvinfo->nVolumes = params.nVolumes;
1729
1730     qsort(salvinfo->volumeSummaryp, salvinfo->nVolumes, sizeof(struct VolumeSummary),
1731           CompareVolumes);
1732
1733     return 0;
1734 }
1735
1736 /* Find the link table. This should be associated with the RW volume or, if
1737  * a RO only site, then the RO volume. For now, be cautious and hunt carefully.
1738  */
1739 Inode
1740 FindLinkHandle(struct InodeSummary *isp, int nVols,
1741                struct ViceInodeInfo *allInodes)
1742 {
1743     int i, j;
1744     struct ViceInodeInfo *ip;
1745
1746     for (i = 0; i < nVols; i++) {
1747         ip = allInodes + isp[i].index;
1748         for (j = 0; j < isp[i].nSpecialInodes; j++) {
1749             if (ip[j].u.special.type == VI_LINKTABLE)
1750                 return ip[j].inodeNumber;
1751         }
1752     }
1753     return (Inode) - 1;
1754 }
1755
1756 int
1757 CreateLinkTable(struct SalvInfo *salvinfo, struct InodeSummary *isp, Inode ino)
1758 {
1759     struct versionStamp version;
1760     FdHandle_t *fdP;
1761
1762     if (!VALID_INO(ino))
1763         ino =
1764             IH_CREATE(NULL, salvinfo->fileSysDevice, salvinfo->fileSysPath, 0, isp->volumeId,
1765                       INODESPECIAL, VI_LINKTABLE, isp->RWvolumeId);
1766     if (!VALID_INO(ino))
1767         Abort
1768             ("Unable to allocate link table inode for volume %u (error = %d)\n",
1769              isp->RWvolumeId, errno);
1770     IH_INIT(salvinfo->VGLinkH, salvinfo->fileSysDevice, isp->RWvolumeId, ino);
1771     fdP = IH_OPEN(salvinfo->VGLinkH);
1772     if (fdP == NULL)
1773         Abort("Can't open link table for volume %u (error = %d)\n",
1774               isp->RWvolumeId, errno);
1775
1776     if (FDH_TRUNC(fdP, sizeof(version) + sizeof(short)) < 0)
1777         Abort("Can't truncate link table for volume %u (error = %d)\n",
1778               isp->RWvolumeId, errno);
1779
1780     version.magic = LINKTABLEMAGIC;
1781     version.version = LINKTABLEVERSION;
1782
1783     if (FDH_WRITE(fdP, (char *)&version, sizeof(version))
1784         != sizeof(version))
1785         Abort("Can't truncate link table for volume %u (error = %d)\n",
1786               isp->RWvolumeId, errno);
1787
1788     FDH_REALLYCLOSE(fdP);
1789
1790     /* If the volume summary exits (i.e.,  the V*.vol header file exists),
1791      * then set this inode there as well.
1792      */
1793     if (isp->volSummary)
1794         isp->volSummary->header.linkTable = ino;
1795
1796     return 0;
1797 }
1798
1799 #ifdef AFS_NT40_ENV
1800 void *
1801 nt_SVG(void *arg)
1802 {
1803     SVGParms_t *parms = (SVGParms_t *) arg;
1804     DoSalvageVolumeGroup(parms->salvinfo, parms->svgp_inodeSummaryp, parms->svgp_count);
1805     return NULL;
1806 }
1807
1808 void
1809 SalvageVolumeGroup(struct SalvInfo *salvinfo, struct InodeSummary *isp, int nVols)
1810 {
1811     pthread_t tid;
1812     pthread_attr_t tattr;
1813     int code;
1814     SVGParms_t parms;
1815
1816     /* Initialize per volume global variables, even if later code does so */
1817     salvinfo->VolumeChanged = 0;
1818     salvinfo->VGLinkH = NULL;
1819     salvinfo->VGLinkH_cnt = 0;
1820     memset(&salvinfo->VolInfo, 0, sizeof(salvinfo->VolInfo));
1821
1822     parms.svgp_inodeSummaryp = isp;
1823     parms.svgp_count = nVols;
1824     parms.svgp_salvinfo = salvinfo;
1825     code = pthread_attr_init(&tattr);
1826     if (code) {
1827         Log("Failed to salvage volume group %u: pthread_attr_init()\n",
1828             isp->RWvolumeId);
1829         return;
1830     }
1831     code = pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_JOINABLE);
1832     if (code) {
1833         Log("Failed to salvage volume group %u: pthread_attr_setdetachstate()\n", isp->RWvolumeId);
1834         return;
1835     }
1836     code = pthread_create(&tid, &tattr, nt_SVG, &parms);
1837     if (code) {
1838         Log("Failed to create thread to salvage volume group %u\n",
1839             isp->RWvolumeId);
1840         return;
1841     }
1842     (void)pthread_join(tid, NULL);
1843 }
1844 #endif /* AFS_NT40_ENV */
1845
1846 void
1847 DoSalvageVolumeGroup(struct SalvInfo *salvinfo, struct InodeSummary *isp, int nVols)
1848 {
1849     struct ViceInodeInfo *inodes, *allInodes, *ip;
1850     int i, totalInodes, size, salvageTo;
1851     int haveRWvolume;
1852     int check;
1853     Inode ino;
1854     int dec_VGLinkH = 0;
1855     int VGLinkH_p1 =0;
1856     FdHandle_t *fdP = NULL;
1857
1858     salvinfo->VGLinkH_cnt = 0;
1859     haveRWvolume = (isp->volumeId == isp->RWvolumeId
1860                     && isp->nSpecialInodes > 0);
1861     if ((!ShowMounts) || (ShowMounts && !haveRWvolume)) {
1862         if (!ForceSalvage && QuickCheck(salvinfo, isp, nVols))
1863             return;
1864     }
1865     if (ShowMounts && !haveRWvolume)
1866         return;
1867     if (canfork && !debug && Fork() != 0) {
1868         (void)Wait("Salvage volume group");
1869         return;
1870     }
1871     for (i = 0, totalInodes = 0; i < nVols; i++)
1872         totalInodes += isp[i].nInodes;
1873     size = totalInodes * sizeof(struct ViceInodeInfo);
1874     inodes = (struct ViceInodeInfo *)malloc(size);
1875     allInodes = inodes - isp->index;    /* this would the base of all the inodes
1876                                          * for the partition, if all the inodes
1877                                          * had been read into memory */
1878     assert(afs_lseek
1879            (salvinfo->inodeFd, isp->index * sizeof(struct ViceInodeInfo),
1880             SEEK_SET) != -1);
1881     assert(read(salvinfo->inodeFd, inodes, size) == size);
1882
1883     /* Don't try to salvage a read write volume if there isn't one on this
1884      * partition */
1885     salvageTo = haveRWvolume ? 0 : 1;
1886
1887 #ifdef AFS_NAMEI_ENV
1888     ino = FindLinkHandle(isp, nVols, allInodes);
1889     if (VALID_INO(ino)) {
1890         IH_INIT(salvinfo->VGLinkH, salvinfo->fileSysDevice, isp->RWvolumeId, ino);
1891         fdP = IH_OPEN(salvinfo->VGLinkH);
1892     }
1893     if (!VALID_INO(ino) || fdP == NULL) {
1894         Log("%s link table for volume %u.\n",
1895             Testing ? "Would have recreated" : "Recreating", isp->RWvolumeId);
1896         if (Testing) {
1897             IH_INIT(salvinfo->VGLinkH, salvinfo->fileSysDevice, -1, -1);
1898         } else {
1899             int i, j;
1900             struct ViceInodeInfo *ip;
1901             CreateLinkTable(salvinfo, isp, ino);
1902             fdP = IH_OPEN(salvinfo->VGLinkH);
1903             /* Sync fake 1 link counts to the link table, now that it exists */
1904             if (fdP) {
1905                 for (i = 0; i < nVols; i++) {
1906                         ip = allInodes + isp[i].index;
1907                          for (j = isp[i].nSpecialInodes; j < isp[i].nInodes; j++) {
1908 #ifdef AFS_NT40_ENV
1909                                  nt_SetLinkCount(fdP, ip[j].inodeNumber, 1, 1);
1910 #else
1911                                  namei_SetLinkCount(fdP, ip[j].inodeNumber, 1, 1);
1912 #endif
1913                     }
1914                 }
1915             }
1916         }
1917     }
1918     if (fdP)
1919         FDH_REALLYCLOSE(fdP);
1920 #else
1921     IH_INIT(salvinfo->VGLinkH, salvinfo->fileSysDevice, -1, -1);
1922 #endif
1923
1924     /* Salvage in reverse order--read/write volume last; this way any
1925      * Inodes not referenced by the time we salvage the read/write volume
1926      * can be picked up by the read/write volume */
1927     /* ACTUALLY, that's not done right now--the inodes just vanish */
1928     for (i = nVols - 1; i >= salvageTo; i--) {
1929         int rw = (i == 0);
1930         struct InodeSummary *lisp = &isp[i];
1931 #ifdef AFS_NAMEI_ENV
1932         /* If only the RO is present on this partition, the link table
1933          * shows up as a RW volume special file. Need to make sure the
1934          * salvager doesn't try to salvage the non-existent RW.
1935          */
1936         if (rw && nVols > 1 && isp[i].nSpecialInodes == 1) {
1937             /* If this only special inode is the link table, continue */
1938             if (inodes->u.special.type == VI_LINKTABLE) {
1939                 haveRWvolume = 0;
1940                 continue;
1941             }
1942         }
1943 #endif
1944         if (!Showmode)
1945             Log("%s VOLUME %u%s.\n", rw ? "SALVAGING" : "CHECKING CLONED",
1946                 lisp->volumeId, (Testing ? "(READONLY mode)" : ""));
1947         /* Check inodes twice.  The second time do things seriously.  This
1948          * way the whole RO volume can be deleted, below, if anything goes wrong */
1949         for (check = 1; check >= 0; check--) {
1950             int deleteMe;
1951             if (SalvageVolumeHeaderFile(salvinfo, lisp, allInodes, rw, check, &deleteMe)
1952                 == -1) {
1953                 MaybeZapVolume(salvinfo, lisp, "Volume header", deleteMe, check);
1954                 if (rw && deleteMe) {
1955                     haveRWvolume = 0;   /* This will cause its inodes to be deleted--since salvage
1956                                          * volume won't be called */
1957                     break;
1958                 }
1959                 if (!rw)
1960                     break;
1961             }
1962             if (rw && check == 1)
1963                 continue;
1964             if (SalvageVnodes(salvinfo, isp, lisp, allInodes, check) == -1) {
1965                 MaybeZapVolume(salvinfo, lisp, "Vnode index", 0, check);
1966                 break;
1967             }
1968         }
1969     }
1970
1971     /* Fix actual inode counts */
1972     if (!Showmode) {
1973         Log("totalInodes %d\n",totalInodes);
1974         for (ip = inodes; totalInodes; ip++, totalInodes--) {
1975             static int TraceBadLinkCounts = 0;
1976 #ifdef AFS_NAMEI_ENV
1977             if (salvinfo->VGLinkH->ih_ino == ip->inodeNumber) {
1978                 dec_VGLinkH = ip->linkCount - salvinfo->VGLinkH_cnt;
1979                 VGLinkH_p1 = ip->u.param[0];
1980                 continue;       /* Deal with this last. */
1981             }
1982 #endif
1983             if (ip->linkCount != 0 && TraceBadLinkCounts) {
1984                 TraceBadLinkCounts--;   /* Limit reports, per volume */
1985                 Log("#### DEBUG #### Link count incorrect by %d; inode %s, size %llu, p=(%u,%u,%u,%u)\n", ip->linkCount, PrintInode(NULL, ip->inodeNumber), (afs_uintmax_t) ip->byteCount, ip->u.param[0], ip->u.param[1], ip->u.param[2], ip->u.param[3]);
1986             }
1987             while (ip->linkCount > 0) {
1988                 /* below used to assert, not break */
1989                 if (!Testing) {
1990                     if (IH_DEC(salvinfo->VGLinkH, ip->inodeNumber, ip->u.param[0])) {
1991                         Log("idec failed. inode %s errno %d\n",
1992                             PrintInode(NULL, ip->inodeNumber), errno);
1993                         break;
1994                     }
1995                 }
1996                 ip->linkCount--;
1997             }
1998             while (ip->linkCount < 0) {
1999                 /* these used to be asserts */
2000                 if (!Testing) {
2001                     if (IH_INC(salvinfo->VGLinkH, ip->inodeNumber, ip->u.param[0])) {
2002                         Log("iinc failed. inode %s errno %d\n",
2003                             PrintInode(NULL, ip->inodeNumber), errno);
2004                         break;
2005                     }
2006                 }
2007                 ip->linkCount++;
2008             }
2009         }
2010 #ifdef AFS_NAMEI_ENV
2011         while (dec_VGLinkH > 0) {
2012             if (IH_DEC(salvinfo->VGLinkH, salvinfo->VGLinkH->ih_ino, VGLinkH_p1) < 0) {
2013                 Log("idec failed on link table, errno = %d\n", errno);
2014             }
2015             dec_VGLinkH--;
2016         }
2017         while (dec_VGLinkH < 0) {
2018             if (IH_INC(salvinfo->VGLinkH, salvinfo->VGLinkH->ih_ino, VGLinkH_p1) < 0) {
2019                 Log("iinc failed on link table, errno = %d\n", errno);
2020             }
2021             dec_VGLinkH++;
2022         }
2023 #endif
2024     }
2025     free(inodes);
2026     /* Directory consistency checks on the rw volume */
2027     if (haveRWvolume)
2028         SalvageVolume(salvinfo, isp, salvinfo->VGLinkH);
2029     IH_RELEASE(salvinfo->VGLinkH);
2030
2031     if (canfork && !debug) {
2032         ShowLog = 0;
2033         Exit(0);
2034     }
2035 }
2036
2037 int
2038 QuickCheck(struct SalvInfo *salvinfo, struct InodeSummary *isp, int nVols)
2039 {
2040     /* Check headers BEFORE forking */
2041     int i;
2042     IHandle_t *h;
2043
2044     for (i = 0; i < nVols; i++) {
2045         struct VolumeSummary *vs = isp[i].volSummary;
2046         VolumeDiskData volHeader;
2047         if (!vs) {
2048             /* Don't salvage just because phantom rw volume is there... */
2049             /* (If a read-only volume exists, read/write inodes must also exist) */
2050             if (i == 0 && isp->nSpecialInodes == 0 && nVols > 1)
2051                 continue;
2052             return 0;
2053         }
2054         IH_INIT(h, salvinfo->fileSysDevice, vs->header.parent, vs->header.volumeInfo);
2055         if (IH_IREAD(h, 0, (char *)&volHeader, sizeof(volHeader))
2056             == sizeof(volHeader)
2057             && volHeader.stamp.magic == VOLUMEINFOMAGIC
2058             && volHeader.dontSalvage == DONT_SALVAGE
2059             && volHeader.needsSalvaged == 0 && volHeader.destroyMe == 0) {
2060             if (volHeader.inUse != 0) {
2061                 volHeader.inUse = 0;
2062                 volHeader.inService = 1;
2063                 if (!Testing) {
2064                     if (IH_IWRITE(h, 0, (char *)&volHeader, sizeof(volHeader))
2065                         != sizeof(volHeader)) {
2066                         IH_RELEASE(h);
2067                         return 0;
2068                     }
2069                 }
2070             }
2071             IH_RELEASE(h);
2072         } else {
2073             IH_RELEASE(h);
2074             return 0;
2075         }
2076     }
2077     return 1;
2078 }
2079
2080
2081 /* SalvageVolumeHeaderFile
2082  *
2083  * Salvage the top level V*.vol header file. Make sure the special files
2084  * exist and that there are no duplicates.
2085  *
2086  * Calls SalvageHeader for each possible type of volume special file.
2087  */
2088
2089 int
2090 SalvageVolumeHeaderFile(struct SalvInfo *salvinfo, struct InodeSummary *isp,
2091                         struct ViceInodeInfo *inodes, int RW,
2092                         int check, int *deleteMe)
2093 {
2094     int i;
2095     struct ViceInodeInfo *ip;
2096     int allinodesobsolete = 1;
2097     struct VolumeDiskHeader diskHeader;
2098     afs_int32 (*writefunc)(VolumeDiskHeader_t *, struct DiskPartition64 *) = NULL;
2099     int *skip;
2100
2101     /* keeps track of special inodes that are probably 'good'; they are
2102      * referenced in the vol header, and are included in the given inodes
2103      * array */
2104     struct {
2105         int valid;
2106         Inode inode;
2107     } goodspecial[MAXINODETYPE];
2108
2109     if (deleteMe)
2110         *deleteMe = 0;
2111
2112     memset(goodspecial, 0, sizeof(goodspecial));
2113
2114     skip = malloc(isp->nSpecialInodes * sizeof(*skip));
2115     if (skip) {
2116         memset(skip, 0, isp->nSpecialInodes * sizeof(*skip));
2117     } else {
2118         Log("cannot allocate memory for inode skip array when salvaging "
2119             "volume %lu; not performing duplicate special inode recovery\n",
2120             afs_printable_uint32_lu(isp->volumeId));
2121         /* still try to perform the salvage; the skip array only does anything
2122          * if we detect duplicate special inodes */
2123     }
2124
2125     /*
2126      * First, look at the special inodes and see if any are referenced by
2127      * the existing volume header. If we find duplicate special inodes, we
2128      * can use this information to use the referenced inode (it's more
2129      * likely to be the 'good' one), and throw away the duplicates.
2130      */
2131     if (isp->volSummary && skip) {
2132         /* use tempHeader, so we can use the stuff[] array to easily index
2133          * into the isp->volSummary special inodes */
2134         memcpy(&tempHeader, &isp->volSummary->header, sizeof(struct VolumeHeader));
2135
2136         for (i = 0; i < isp->nSpecialInodes; i++) {
2137             ip = &inodes[isp->index + i];
2138             if (ip->u.special.type <= 0 || ip->u.special.type > MAXINODETYPE) {
2139                 /* will get taken care of in a later loop */
2140                 continue;
2141             }
2142             if (ip->inodeNumber == *(stuff[ip->u.special.type - 1].inode)) {
2143                 goodspecial[ip->u.special.type-1].valid = 1;
2144                 goodspecial[ip->u.special.type-1].inode = ip->inodeNumber;
2145             }
2146         }
2147     }
2148
2149     memset(&tempHeader, 0, sizeof(tempHeader));
2150     tempHeader.stamp.magic = VOLUMEHEADERMAGIC;
2151     tempHeader.stamp.version = VOLUMEHEADERVERSION;
2152     tempHeader.id = isp->volumeId;
2153     tempHeader.parent = isp->RWvolumeId;
2154
2155     /* Check for duplicates (inodes are sorted by type field) */
2156     for (i = 0; i < isp->nSpecialInodes - 1; i++) {
2157         ip = &inodes[isp->index + i];
2158         if (ip->u.special.type == (ip + 1)->u.special.type) {
2159             afs_ino_str_t stmp1, stmp2;
2160
2161             if (ip->u.special.type <= 0 || ip->u.special.type > MAXINODETYPE) {
2162                 /* Will be caught in the loop below */
2163                 continue;
2164             }
2165             if (!Showmode) {
2166                 Log("Duplicate special %d inodes for volume %u found (%s, %s);\n",
2167                     ip->u.special.type, isp->volumeId,
2168                     PrintInode(stmp1, ip->inodeNumber),
2169                     PrintInode(stmp2, (ip+1)->inodeNumber));
2170             }
2171             if (skip && goodspecial[ip->u.special.type-1].valid) {
2172                 Inode gi = goodspecial[ip->u.special.type-1].inode;
2173
2174                 if (!Showmode) {
2175                     Log("using special inode referenced by vol header (%s)\n",
2176                         PrintInode(stmp1, gi));
2177                 }
2178
2179                 /* the volume header references some special inode of
2180                  * this type in the inodes array; are we it? */
2181                 if (ip->inodeNumber != gi) {
2182                     skip[i] = 1;
2183                 } else if ((ip+1)->inodeNumber != gi) {
2184                     /* in case this is the last iteration; we need to
2185                      * make sure we check ip+1, too */
2186                     skip[i+1] = 1;
2187                 }
2188             } else {
2189                 if (!Showmode)
2190                     Log("cannot determine which is correct; salvage of volume %u aborted\n", isp->volumeId);
2191                 if (skip) {
2192                     free(skip);
2193                 }
2194                 return -1;
2195             }
2196         }
2197     }
2198     for (i = 0; i < isp->nSpecialInodes; i++) {
2199         ip = &inodes[isp->index + i];
2200         if (ip->u.special.type <= 0 || ip->u.special.type > MAXINODETYPE) {
2201             if (check) {
2202                 Log("Rubbish header inode %s of type %d\n",
2203                     PrintInode(NULL, ip->inodeNumber),
2204                     ip->u.special.type);
2205                 if (skip) {
2206                     free(skip);
2207                 }
2208                 return -1;
2209             }
2210             Log("Rubbish header inode %s of type %d; deleted\n",
2211                 PrintInode(NULL, ip->inodeNumber),
2212                 ip->u.special.type);
2213         } else if (!stuff[ip->u.special.type - 1].obsolete) {
2214             if (skip && skip[i]) {
2215                 if (orphans == ORPH_REMOVE) {
2216                     Log("Removing orphan special inode %s of type %d\n",
2217                         PrintInode(NULL, ip->inodeNumber), ip->u.special.type);
2218                     continue;
2219                 } else {
2220                     Log("Ignoring orphan special inode %s of type %d\n",
2221                         PrintInode(NULL, ip->inodeNumber), ip->u.special.type);
2222                     /* fall through to the ip->linkCount--; line below */
2223                 }
2224             } else {
2225                 *(stuff[ip->u.special.type - 1].inode) = ip->inodeNumber;
2226                 allinodesobsolete = 0;
2227             }
2228             if (!check && ip->u.special.type != VI_LINKTABLE)
2229                 ip->linkCount--;        /* Keep the inode around */
2230         }
2231     }
2232     if (skip) {
2233         free(skip);
2234     }
2235     skip = NULL;
2236
2237     if (allinodesobsolete) {
2238         if (deleteMe)
2239             *deleteMe = 1;
2240         return -1;
2241     }
2242
2243     if (!check)
2244         salvinfo->VGLinkH_cnt++;                /* one for every header. */
2245
2246     if (!RW && !check && isp->volSummary) {
2247         ClearROInUseBit(isp->volSummary);
2248         return 0;
2249     }
2250
2251     for (i = 0; i < MAXINODETYPE; i++) {
2252         if (stuff[i].inodeType == VI_LINKTABLE) {
2253             /* Gross hack: SalvageHeader does a bcmp on the volume header.
2254              * And we may have recreated the link table earlier, so set the
2255              * RW header as well.
2256              */
2257             if (VALID_INO(salvinfo->VGLinkH->ih_ino)) {
2258                 *stuff[i].inode = salvinfo->VGLinkH->ih_ino;
2259             }
2260             continue;
2261         }
2262         if (SalvageHeader(salvinfo, &stuff[i], isp, check, deleteMe) == -1 && check)
2263             return -1;
2264     }
2265
2266     if (isp->volSummary == NULL) {
2267         char path[64];
2268         char headerName[64];
2269         (void)afs_snprintf(headerName, sizeof headerName, VFORMAT, afs_printable_uint32_lu(isp->volumeId));
2270         (void)afs_snprintf(path, sizeof path, "%s/%s", salvinfo->fileSysPath, headerName);
2271         if (check) {
2272             Log("No header file for volume %u\n", isp->volumeId);
2273             return -1;
2274         }
2275         if (!Showmode)
2276             Log("No header file for volume %u; %screating %s\n",
2277                 isp->volumeId, (Testing ? "it would have been " : ""),
2278                 path);
2279         isp->volSummary = (struct VolumeSummary *)
2280             malloc(sizeof(struct VolumeSummary));
2281         isp->volSummary->fileName = ToString(headerName);
2282
2283         writefunc = VCreateVolumeDiskHeader;
2284     } else {
2285         char path[64];
2286         char headerName[64];
2287         /* hack: these two fields are obsolete... */
2288         isp->volSummary->header.volumeAcl = 0;
2289         isp->volSummary->header.volumeMountTable = 0;
2290
2291         if (memcmp
2292             (&isp->volSummary->header, &tempHeader,
2293              sizeof(struct VolumeHeader))) {
2294             /* We often remove the name before calling us, so we make a fake one up */
2295             if (isp->volSummary->fileName) {
2296                 strcpy(headerName, isp->volSummary->fileName);
2297             } else {
2298                 (void)afs_snprintf(headerName, sizeof headerName, VFORMAT, afs_printable_uint32_lu(isp->volumeId));
2299                 isp->volSummary->fileName = ToString(headerName);
2300             }
2301             (void)afs_snprintf(path, sizeof path, "%s/%s", salvinfo->fileSysPath, headerName);
2302
2303             Log("Header file %s is damaged or no longer valid%s\n", path,
2304                 (check ? "" : "; repairing"));
2305             if (check)
2306                 return -1;
2307
2308             writefunc = VWriteVolumeDiskHeader;
2309         }
2310     }
2311     if (writefunc) {
2312         memcpy(&isp->volSummary->header, &tempHeader,
2313                sizeof(struct VolumeHeader));
2314         if (Testing) {
2315             if (!Showmode)
2316                 Log("It would have written a new header file for volume %u\n",
2317                     isp->volumeId);
2318         } else {
2319             afs_int32 code;
2320             VolumeHeaderToDisk(&diskHeader, &tempHeader);
2321             code = (*writefunc)(&diskHeader, salvinfo->fileSysPartition);
2322             if (code) {
2323                 Log("Error %ld writing volume header file for volume %lu\n",
2324                     afs_printable_int32_ld(code),
2325                     afs_printable_uint32_lu(diskHeader.id));
2326                 return -1;
2327             }
2328         }
2329     }
2330     IH_INIT(isp->volSummary->volumeInfoHandle, salvinfo->fileSysDevice, isp->RWvolumeId,
2331             isp->volSummary->header.volumeInfo);
2332     return 0;
2333 }
2334
2335 int
2336 SalvageHeader(struct SalvInfo *salvinfo, struct stuff *sp,
2337               struct InodeSummary *isp, int check, int *deleteMe)
2338 {
2339     union {
2340         VolumeDiskData volumeInfo;
2341         struct versionStamp fileHeader;
2342     } header;
2343     IHandle_t *specH;
2344     int recreate = 0;
2345     ssize_t nBytes;
2346     FdHandle_t *fdP;
2347
2348     if (sp->obsolete)
2349         return 0;
2350 #ifndef AFS_NAMEI_ENV
2351     if (sp->inodeType == VI_LINKTABLE)
2352         return 0;
2353 #endif
2354     if (*(sp->inode) == 0) {
2355         if (check) {
2356             Log("Missing inode in volume header (%s)\n", sp->description);
2357             return -1;
2358         }
2359         if (!Showmode)
2360             Log("Missing inode in volume header (%s); %s\n", sp->description,
2361                 (Testing ? "it would have recreated it" : "recreating"));
2362         if (!Testing) {
2363             *(sp->inode) =
2364                 IH_CREATE(NULL, salvinfo->fileSysDevice, salvinfo->fileSysPath, 0, isp->volumeId,
2365                           INODESPECIAL, sp->inodeType, isp->RWvolumeId);
2366             if (!VALID_INO(*(sp->inode)))
2367                 Abort
2368                     ("Unable to allocate inode (%s) for volume header (error = %d)\n",
2369                      sp->description, errno);
2370         }
2371         recreate = 1;
2372     }
2373
2374     IH_INIT(specH, salvinfo->fileSysDevice, isp->RWvolumeId, *(sp->inode));
2375     fdP = IH_OPEN(specH);
2376     if (OKToZap && (fdP == NULL) && BadError(errno)) {
2377         /* bail out early and destroy the volume */
2378         if (!Showmode)
2379             Log("Still can't open volume header inode (%s), destroying volume\n", sp->description);
2380         if (deleteMe)
2381             *deleteMe = 1;
2382         IH_RELEASE(specH);
2383         return -1;
2384     }
2385     if (fdP == NULL)
2386         Abort("Unable to open inode (%s) of volume header (error = %d)\n",
2387               sp->description, errno);
2388
2389     if (!recreate
2390         && (FDH_READ(fdP, (char *)&header, sp->size) != sp->size
2391             || header.fileHeader.magic != sp->stamp.magic)) {
2392         if (check) {
2393             Log("Part of the header (%s) is corrupted\n", sp->description);
2394             FDH_REALLYCLOSE(fdP);
2395             IH_RELEASE(specH);
2396             return -1;
2397         }
2398         Log("Part of the header (%s) is corrupted; recreating\n",
2399             sp->description);
2400         recreate = 1;
2401         /* header can be garbage; make sure we don't read garbage data from
2402          * it below */
2403         memset(&header, 0, sizeof(header));
2404     }
2405     if (sp->inodeType == VI_VOLINFO
2406         && header.volumeInfo.destroyMe == DESTROY_ME) {
2407         if (deleteMe)
2408             *deleteMe = 1;
2409         FDH_REALLYCLOSE(fdP);
2410         IH_RELEASE(specH);
2411         return -1;
2412     }
2413     if (recreate && !Testing) {
2414         if (check)
2415             Abort
2416                 ("Internal error: recreating volume header (%s) in check mode\n",
2417                  sp->description);
2418         nBytes = FDH_TRUNC(fdP, 0);
2419         if (nBytes == -1)
2420             Abort("Unable to truncate volume header file (%s) (error = %d)\n",
2421                   sp->description, errno);
2422
2423         /* The following code should be moved into vutil.c */
2424         if (sp->inodeType == VI_VOLINFO) {
2425             struct timeval tp;
2426             memset(&header.volumeInfo, 0, sizeof(header.volumeInfo));
2427             header.volumeInfo.stamp = sp->stamp;
2428             header.volumeInfo.id = isp->volumeId;
2429             header.volumeInfo.parentId = isp->RWvolumeId;
2430             sprintf(header.volumeInfo.name, "bogus.%u", isp->volumeId);
2431             Log("Warning: the name of volume %u is now \"bogus.%u\"\n",
2432                 isp->volumeId, isp->volumeId);
2433             header.volumeInfo.inService = 0;
2434             header.volumeInfo.blessed = 0;
2435             /* The + 1000 is a hack in case there are any files out in venus caches */
2436             header.volumeInfo.uniquifier = (isp->maxUniquifier + 1) + 1000;
2437             header.volumeInfo.type = (isp->volumeId == isp->RWvolumeId ? readwriteVolume : readonlyVolume);     /* XXXX */
2438             header.volumeInfo.needsCallback = 0;
2439             gettimeofday(&tp, 0);
2440             header.volumeInfo.creationDate = tp.tv_sec;
2441             if (FDH_SEEK(fdP, 0, SEEK_SET) < 0) {
2442                 Abort
2443                     ("Unable to seek to beginning of volume header file (%s) (errno = %d)\n",
2444                      sp->description, errno);
2445             }
2446             nBytes =
2447                 FDH_WRITE(fdP, (char *)&header.volumeInfo,
2448                           sizeof(header.volumeInfo));
2449             if (nBytes != sizeof(header.volumeInfo)) {
2450                 if (nBytes < 0)
2451                     Abort
2452                         ("Unable to write volume header file (%s) (errno = %d)\n",
2453                          sp->description, errno);
2454                 Abort("Unable to write entire volume header file (%s)\n",
2455                       sp->description);
2456             }
2457         } else {
2458             if (FDH_SEEK(fdP, 0, SEEK_SET) < 0) {
2459                 Abort
2460                     ("Unable to seek to beginning of volume header file (%s) (errno = %d)\n",
2461                      sp->description, errno);
2462             }
2463             nBytes = FDH_WRITE(fdP, (char *)&sp->stamp, sizeof(sp->stamp));
2464             if (nBytes != sizeof(sp->stamp)) {
2465                 if (nBytes < 0)
2466                     Abort
2467                         ("Unable to write version stamp in volume header file (%s) (errno = %d)\n",
2468                          sp->description, errno);
2469                 Abort
2470                     ("Unable to write entire version stamp in volume header file (%s)\n",
2471                      sp->description);
2472             }
2473         }
2474     }
2475     FDH_REALLYCLOSE(fdP);
2476     IH_RELEASE(specH);
2477     if (sp->inodeType == VI_VOLINFO) {
2478         salvinfo->VolInfo = header.volumeInfo;
2479         if (check) {
2480             char update[25];
2481
2482             if (salvinfo->VolInfo.updateDate) {
2483                 strcpy(update, TimeStamp(salvinfo->VolInfo.updateDate, 0));
2484                 if (!Showmode)
2485                     Log("%s (%u) %supdated %s\n", salvinfo->VolInfo.name,
2486                         salvinfo->VolInfo.id,
2487                         (Testing ? "it would have been " : ""), update);
2488             } else {
2489                 strcpy(update, TimeStamp(salvinfo->VolInfo.creationDate, 0));
2490                 if (!Showmode)
2491                     Log("%s (%u) not updated (created %s)\n",
2492                         salvinfo->VolInfo.name, salvinfo->VolInfo.id, update);
2493             }
2494
2495         }
2496     }
2497
2498     return 0;
2499 }
2500
2501 int
2502 SalvageVnodes(struct SalvInfo *salvinfo,
2503               struct InodeSummary *rwIsp,
2504               struct InodeSummary *thisIsp,
2505               struct ViceInodeInfo *inodes, int check)
2506 {
2507     int ilarge, ismall, ioffset, RW, nInodes;
2508     ioffset = rwIsp->index + rwIsp->nSpecialInodes;     /* first inode */
2509     if (Showmode)
2510         return 0;
2511     RW = (rwIsp == thisIsp);
2512     nInodes = (rwIsp->nInodes - rwIsp->nSpecialInodes);
2513     ismall =
2514         SalvageIndex(salvinfo, thisIsp->volSummary->header.smallVnodeIndex, vSmall, RW,
2515                      &inodes[ioffset], nInodes, thisIsp->volSummary, check);
2516     if (check && ismall == -1)
2517         return -1;
2518     ilarge =
2519         SalvageIndex(salvinfo, thisIsp->volSummary->header.largeVnodeIndex, vLarge, RW,
2520                      &inodes[ioffset], nInodes, thisIsp->volSummary, check);
2521     return (ilarge == 0 && ismall == 0 ? 0 : -1);
2522 }
2523
2524 int
2525 SalvageIndex(struct SalvInfo *salvinfo, Inode ino, VnodeClass class, int RW,
2526              struct ViceInodeInfo *ip, int nInodes,
2527              struct VolumeSummary *volSummary, int check)
2528 {
2529     VolumeId volumeNumber;
2530     char buf[SIZEOF_LARGEDISKVNODE];
2531     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
2532     int err = 0;
2533     StreamHandle_t *file;
2534     struct VnodeClassInfo *vcp;
2535     afs_sfsize_t size;
2536     afs_sfsize_t nVnodes;
2537     afs_fsize_t vnodeLength;
2538     int vnodeIndex;
2539     afs_ino_str_t stmp1, stmp2;
2540     IHandle_t *handle;
2541     FdHandle_t *fdP;
2542
2543     volumeNumber = volSummary->header.id;
2544     IH_INIT(handle, salvinfo->fileSysDevice, volSummary->header.parent, ino);
2545     fdP = IH_OPEN(handle);
2546     assert(fdP != NULL);
2547     file = FDH_FDOPEN(fdP, "r+");
2548     assert(file != NULL);
2549     vcp = &VnodeClassInfo[class];
2550     size = OS_SIZE(fdP->fd_fd);
2551     assert(size != -1);
2552     nVnodes = (size / vcp->diskSize) - 1;
2553     if (nVnodes > 0) {
2554         assert((nVnodes + 1) * vcp->diskSize == size);
2555         assert(STREAM_SEEK(file, vcp->diskSize, 0) == 0);
2556     } else {
2557         nVnodes = 0;
2558     }
2559     for (vnodeIndex = 0;
2560          nVnodes && STREAM_READ(vnode, vcp->diskSize, 1, file) == 1;
2561          nVnodes--, vnodeIndex++) {
2562         if (vnode->type != vNull) {
2563             int vnodeChanged = 0;
2564             int vnodeNumber = bitNumberToVnodeNumber(vnodeIndex, class);
2565             /* Log programs that belong to root (potentially suid root);
2566              * don't bother for read-only or backup volumes */
2567 #ifdef  notdef                  /* This is done elsewhere */
2568             if (ShowRootFiles && RW && vnode->owner == 0 && vnodeNumber != 1)
2569                 Log("OWNER IS ROOT %s %u dir %u vnode %u author %u owner %u mode %o\n", salvinfo->VolInfo.name, volumeNumber, vnode->parent, vnodeNumber, vnode->author, vnode->owner, vnode->modeBits);
2570 #endif
2571             if (VNDISK_GET_INO(vnode) == 0) {
2572                 if (RW) {
2573                     /* Log("### DEBUG ### Deleted Vnode with 0 inode (vnode %d)\n", vnodeNumber); */
2574                     memset(vnode, 0, vcp->diskSize);
2575                     vnodeChanged = 1;
2576                 }
2577             } else {
2578                 if (vcp->magic != vnode->vnodeMagic) {
2579                     /* bad magic #, probably partially created vnode */
2580                     Log("Partially allocated vnode %d deleted.\n",
2581                         vnodeNumber);
2582                     memset(vnode, 0, vcp->diskSize);
2583                     vnodeChanged = 1;
2584                     goto vnodeDone;
2585                 }
2586                 /* ****** Should do a bit more salvage here:  e.g. make sure
2587                  * vnode type matches what it should be given the index */
2588                 while (nInodes && ip->u.vnode.vnodeNumber < vnodeNumber) {
2589 /*                  if (vnodeIdToClass(ip->u.vnode.vnodeNumber) == class && RW) {
2590  *                     Log("Inode %d: says it belongs to non-existing vnode %d\n",
2591  *                         ip->inodeNumber, ip->u.vnode.vnodeNumber);
2592  *                  }
2593  */
2594                     ip++;
2595                     nInodes--;
2596                 }
2597                 if (!RW) {
2598                     while (nInodes && ip->u.vnode.vnodeNumber == vnodeNumber) {
2599                         /* The following doesn't work, because the version number
2600                          * is not maintained correctly by the file server */
2601                         /*if (vnode->uniquifier == ip->u.vnode.vnodeUniquifier &&
2602                          * vnode->dataVersion == ip->u.vnode.inodeDataVersion)
2603                          * break; */
2604                         if (VNDISK_GET_INO(vnode) == ip->inodeNumber)
2605                             break;
2606                         ip++;
2607                         nInodes--;
2608                     }
2609                 } else {
2610                     /* For RW volume, look for vnode with matching inode number;
2611                      * if no such match, take the first determined by our sort
2612                      * order */
2613                     struct ViceInodeInfo *lip = ip;
2614                     int lnInodes = nInodes;
2615                     while (lnInodes
2616                            && lip->u.vnode.vnodeNumber == vnodeNumber) {
2617                         if (VNDISK_GET_INO(vnode) == lip->inodeNumber) {
2618                             ip = lip;
2619                             nInodes = lnInodes;
2620                             break;
2621                         }
2622                         lip++;
2623                         lnInodes--;
2624                     }
2625                 }
2626                 if (nInodes && ip->u.vnode.vnodeNumber == vnodeNumber) {
2627                     /* "Matching" inode */
2628                     if (RW) {
2629                         Unique vu, iu;
2630                         FileVersion vd, id;
2631                         vu = vnode->uniquifier;
2632                         iu = ip->u.vnode.vnodeUniquifier;
2633                         vd = vnode->dataVersion;
2634                         id = ip->u.vnode.inodeDataVersion;
2635                         /*
2636                          * Because of the possibility of the uniquifier overflows (> 4M)
2637                          * we compare them modulo the low 22-bits; we shouldn't worry
2638                          * about mismatching since they shouldn't to many old
2639                          * uniquifiers of the same vnode...
2640                          */
2641                         if (IUnique(vu) != IUnique(iu)) {
2642                             if (!Showmode) {
2643                                 Log("Vnode %u: vnode.unique, %u, does not match inode unique, %u; fixed, but status will be wrong\n", vnodeNumber, IUnique(vu), IUnique(iu));
2644                             }
2645
2646                             vnode->uniquifier = iu;
2647 #ifdef  AFS_3DISPARES
2648                             vnode->dataVersion = (id >= vd ?
2649                                                   /* 90% of 2.1M */
2650                                                   ((id - vd) >
2651                                                    1887437 ? vd : id) :
2652                                                   /* 90% of 2.1M */
2653                                                   ((vd - id) >
2654                                                    1887437 ? id : vd));
2655 #else
2656 #if defined(AFS_SGI_EXMAG)
2657                             vnode->dataVersion = (id >= vd ?
2658                                                   /* 90% of 16M */
2659                                                   ((id - vd) >
2660                                                    15099494 ? vd : id) :
2661                                                   /* 90% of 16M */
2662                                                   ((vd - id) >
2663                                                    15099494 ? id : vd));
2664 #else
2665                             vnode->dataVersion = (id > vd ? id : vd);
2666 #endif /* AFS_SGI_EXMAG */
2667 #endif /* AFS_3DISPARES */
2668                             vnodeChanged = 1;
2669                         } else {
2670                             /* don't bother checking for vd > id any more, since
2671                              * partial file transfers always result in this state,
2672                              * and you can't do much else anyway (you've already
2673                              * found the best data you can) */
2674 #ifdef  AFS_3DISPARES
2675                             if (!vnodeIsDirectory(vnodeNumber)
2676                                 && ((vd < id && (id - vd) < 1887437)
2677                                     || ((vd > id && (vd - id) > 1887437)))) {
2678 #else
2679 #if defined(AFS_SGI_EXMAG)
2680                             if (!vnodeIsDirectory(vnodeNumber)
2681                                 && ((vd < id && (id - vd) < 15099494)
2682                                     || ((vd > id && (vd - id) > 15099494)))) {
2683 #else
2684                             if (!vnodeIsDirectory(vnodeNumber) && vd < id) {
2685 #endif /* AFS_SGI_EXMAG */
2686 #endif
2687                                 if (!Showmode)
2688                                     Log("Vnode %d: version < inode version; fixed (old status)\n", vnodeNumber);
2689                                 vnode->dataVersion = id;
2690                                 vnodeChanged = 1;
2691                             }
2692                         }
2693                     }
2694                     if (ip->inodeNumber != VNDISK_GET_INO(vnode)) {
2695                         if (check) {
2696                             if (!Showmode) {
2697                                 Log("Vnode %d:  inode number incorrect (is %s should be %s). FileSize=%llu\n", vnodeNumber, PrintInode(stmp1, VNDISK_GET_INO(vnode)), PrintInode(stmp2, ip->inodeNumber), (afs_uintmax_t) ip->byteCount);
2698                             }
2699                             VNDISK_SET_INO(vnode, ip->inodeNumber);
2700                             err = -1;
2701                             goto zooks;
2702                         }
2703                         if (!Showmode) {
2704                             Log("Vnode %d: inode number incorrect; changed from %s to %s. FileSize=%llu\n", vnodeNumber, PrintInode(stmp1, VNDISK_GET_INO(vnode)), PrintInode(stmp2, ip->inodeNumber), (afs_uintmax_t) ip->byteCount);
2705                         }
2706                         VNDISK_SET_INO(vnode, ip->inodeNumber);
2707                         vnodeChanged = 1;
2708                     }
2709                     VNDISK_GET_LEN(vnodeLength, vnode);
2710                     if (ip->byteCount != vnodeLength) {
2711                         if (check) {
2712                             if (!Showmode)
2713                                 Log("Vnode %d: length incorrect; (is %llu should be %llu)\n", vnodeNumber, (afs_uintmax_t) vnodeLength, (afs_uintmax_t) ip->byteCount);
2714                             err = -1;
2715                             goto zooks;
2716                         }
2717                         if (!Showmode)
2718                             Log("Vnode %d: length incorrect; changed from %llu to %llu\n", vnodeNumber, (afs_uintmax_t) vnodeLength, (afs_uintmax_t) ip->byteCount);
2719                         VNDISK_SET_LEN(vnode, ip->byteCount);
2720                         vnodeChanged = 1;
2721                     }
2722                     if (!check)
2723                         ip->linkCount--;        /* Keep the inode around */
2724                     ip++;
2725                     nInodes--;
2726                 } else {        /* no matching inode */
2727                     if (VNDISK_GET_INO(vnode) != 0
2728                         || vnode->type == vDirectory) {
2729                         /* No matching inode--get rid of the vnode */
2730                         if (check) {
2731                             if (VNDISK_GET_INO(vnode)) {
2732                                 if (!Showmode) {
2733                                     Log("Vnode %d (unique %u): corresponding inode %s is missing\n", vnodeNumber, vnode->uniquifier, PrintInode(NULL, VNDISK_GET_INO(vnode)));
2734                                 }
2735                             } else {
2736                                 if (!Showmode)
2737                                     Log("Vnode %d (unique %u): bad directory vnode (no inode number listed)\n", vnodeNumber, vnode->uniquifier);
2738                             }
2739                             err = -1;
2740                             goto zooks;
2741                         }
2742                         if (VNDISK_GET_INO(vnode)) {
2743                             if (!Showmode) {
2744                                 time_t serverModifyTime = vnode->serverModifyTime;
2745                                 Log("Vnode %d (unique %u): corresponding inode %s is missing; vnode deleted, vnode mod time=%s", vnodeNumber, vnode->uniquifier, PrintInode(NULL, VNDISK_GET_INO(vnode)), ctime(&serverModifyTime));
2746                             }
2747                         } else {
2748                             if (!Showmode) {
2749                                 time_t serverModifyTime = vnode->serverModifyTime;
2750                                 Log("Vnode %d (unique %u): bad directory vnode (no inode number listed); vnode deleted, vnode mod time=%s", vnodeNumber, vnode->uniquifier, ctime(&serverModifyTime));
2751                             }
2752                         }
2753                         memset(vnode, 0, vcp->diskSize);
2754                         vnodeChanged = 1;
2755                     } else {
2756                         /* Should not reach here becuase we checked for
2757                          * (inodeNumber == 0) above. And where we zero the vnode,
2758                          * we also goto vnodeDone.
2759                          */
2760                     }
2761                 }
2762                 while (nInodes && ip->u.vnode.vnodeNumber == vnodeNumber) {
2763                     ip++;
2764                     nInodes--;
2765                 }
2766             }                   /* VNDISK_GET_INO(vnode) != 0 */
2767           vnodeDone:
2768             assert(!(vnodeChanged && check));
2769             if (vnodeChanged && !Testing) {
2770                 assert(IH_IWRITE
2771                        (handle, vnodeIndexOffset(vcp, vnodeNumber),
2772                         (char *)vnode, vcp->diskSize)
2773                        == vcp->diskSize);
2774                 salvinfo->VolumeChanged = 1;    /* For break call back */
2775             }
2776         }
2777     }
2778   zooks:
2779     STREAM_CLOSE(file);
2780     FDH_CLOSE(fdP);
2781     IH_RELEASE(handle);
2782     return err;
2783 }
2784
2785 struct VnodeEssence *
2786 CheckVnodeNumber(struct SalvInfo *salvinfo, VnodeId vnodeNumber)
2787 {
2788     VnodeClass class;
2789     struct VnodeInfo *vip;
2790     int offset;
2791
2792     class = vnodeIdToClass(vnodeNumber);
2793     vip = &salvinfo->vnodeInfo[class];
2794     offset = vnodeIdToBitNumber(vnodeNumber);
2795     return (offset >= vip->nVnodes ? NULL : &vip->vnodes[offset]);
2796 }
2797
2798 void
2799 CopyOnWrite(struct SalvInfo *salvinfo, struct DirSummary *dir)
2800 {
2801     /* Copy the directory unconditionally if we are going to change it:
2802      * not just if was cloned.
2803      */
2804     struct VnodeDiskObject vnode;
2805     struct VnodeClassInfo *vcp = &VnodeClassInfo[vLarge];
2806     Inode oldinode, newinode;
2807     afs_sfsize_t code;
2808
2809     if (dir->copied || Testing)
2810         return;
2811     DFlush();                   /* Well justified paranoia... */
2812
2813     code =
2814         IH_IREAD(salvinfo->vnodeInfo[vLarge].handle,
2815                  vnodeIndexOffset(vcp, dir->vnodeNumber), (char *)&vnode,
2816                  sizeof(vnode));
2817     assert(code == sizeof(vnode));
2818     oldinode = VNDISK_GET_INO(&vnode);
2819     /* Increment the version number by a whole lot to avoid problems with
2820      * clients that were promised new version numbers--but the file server
2821      * crashed before the versions were written to disk.
2822      */
2823     newinode =
2824         IH_CREATE(dir->ds_linkH, salvinfo->fileSysDevice, salvinfo->fileSysPath, 0, dir->rwVid,
2825                   dir->vnodeNumber, vnode.uniquifier, vnode.dataVersion +=
2826                   200);
2827     assert(VALID_INO(newinode));
2828     assert(CopyInode(salvinfo->fileSysDevice, oldinode, newinode, dir->rwVid) == 0);
2829     vnode.cloned = 0;
2830     VNDISK_SET_INO(&vnode, newinode);
2831     code =
2832         IH_IWRITE(salvinfo->vnodeInfo[vLarge].handle,
2833                   vnodeIndexOffset(vcp, dir->vnodeNumber), (char *)&vnode,
2834                   sizeof(vnode));
2835     assert(code == sizeof(vnode));
2836
2837     SetSalvageDirHandle(&dir->dirHandle, dir->dirHandle.dirh_handle->ih_vid,
2838                         salvinfo->fileSysDevice, newinode,
2839                         &salvinfo->VolumeChanged);
2840     /* Don't delete the original inode right away, because the directory is
2841      * still being scanned.
2842      */
2843     dir->copied = 1;
2844 }
2845
2846 /*
2847  * This function should either successfully create a new dir, or give up
2848  * and leave things the way they were.  In particular, if it fails to write
2849  * the new dir properly, it should return w/o changing the reference to the
2850  * old dir.
2851  */
2852 void
2853 CopyAndSalvage(struct SalvInfo *salvinfo, struct DirSummary *dir)
2854 {
2855     struct VnodeDiskObject vnode;
2856     struct VnodeClassInfo *vcp = &VnodeClassInfo[vLarge];
2857     Inode oldinode, newinode;
2858     DirHandle newdir;
2859     FdHandle_t *fdP;
2860     afs_int32 code;
2861     afs_sfsize_t lcode;
2862     afs_int32 parentUnique = 1;
2863     struct VnodeEssence *vnodeEssence;
2864     afs_fsize_t length;
2865
2866     if (Testing)
2867         return;
2868     Log("Salvaging directory %u...\n", dir->vnodeNumber);
2869     lcode =
2870         IH_IREAD(salvinfo->vnodeInfo[vLarge].handle,
2871                  vnodeIndexOffset(vcp, dir->vnodeNumber), (char *)&vnode,
2872                  sizeof(vnode));
2873     assert(lcode == sizeof(vnode));
2874     oldinode = VNDISK_GET_INO(&vnode);
2875     /* Increment the version number by a whole lot to avoid problems with
2876      * clients that were promised new version numbers--but the file server
2877      * crashed before the versions were written to disk.
2878      */
2879     newinode =
2880         IH_CREATE(dir->ds_linkH, salvinfo->fileSysDevice, salvinfo->fileSysPath, 0, dir->rwVid,
2881                   dir->vnodeNumber, vnode.uniquifier, vnode.dataVersion +=
2882                   200);
2883     assert(VALID_INO(newinode));
2884     SetSalvageDirHandle(&newdir, dir->rwVid, salvinfo->fileSysDevice, newinode,
2885                         &salvinfo->VolumeChanged);
2886
2887     /* Assign . and .. vnode numbers from dir and vnode.parent.
2888      * The uniquifier for . is in the vnode.
2889      * The uniquifier for .. might be set to a bogus value of 1 and
2890      * the salvager will later clean it up.
2891      */
2892     if (vnode.parent && (vnodeEssence = CheckVnodeNumber(salvinfo, vnode.parent))) {
2893         parentUnique = (vnodeEssence->unique ? vnodeEssence->unique : 1);
2894     }
2895     code =
2896         DirSalvage(&dir->dirHandle, &newdir, dir->vnodeNumber,
2897                    vnode.uniquifier,
2898                    (vnode.parent ? vnode.parent : dir->vnodeNumber),
2899                    parentUnique);
2900     if (code == 0)
2901         code = DFlush();
2902     if (code) {
2903         /* didn't really build the new directory properly, let's just give up. */
2904         code = IH_DEC(dir->ds_linkH, newinode, dir->rwVid);
2905         Log("Directory salvage returned code %d, continuing.\n", code);
2906         if (code) {
2907             Log("also failed to decrement link count on new inode");
2908         }
2909         assert(1 == 2);
2910     }
2911     Log("Checking the results of the directory salvage...\n");
2912     if (!DirOK(&newdir)) {
2913         Log("Directory salvage failed!!!; restoring old version of the directory.\n");
2914         code = IH_DEC(dir->ds_linkH, newinode, dir->rwVid);
2915         assert(code == 0);
2916         assert(1 == 2);
2917     }
2918     vnode.cloned = 0;
2919     VNDISK_SET_INO(&vnode, newinode);
2920     length = Length(&newdir);
2921     VNDISK_SET_LEN(&vnode, length);
2922     lcode =
2923         IH_IWRITE(salvinfo->vnodeInfo[vLarge].handle,
2924                   vnodeIndexOffset(vcp, dir->vnodeNumber), (char *)&vnode,
2925                   sizeof(vnode));
2926     assert(lcode == sizeof(vnode));
2927 #if 0
2928 #ifdef AFS_NT40_ENV
2929     nt_sync(salvinfo->fileSysDevice);
2930 #else
2931     sync();                     /* this is slow, but hopefully rarely called.  We don't have
2932                                  * an open FD on the file itself to fsync.
2933                                  */
2934 #endif
2935 #else
2936     salvinfo->vnodeInfo[vLarge].handle->ih_synced = 1;
2937 #endif
2938     /* make sure old directory file is really closed */
2939     fdP = IH_OPEN(dir->dirHandle.dirh_handle);
2940     FDH_REALLYCLOSE(fdP);
2941
2942     code = IH_DEC(dir->ds_linkH, oldinode, dir->rwVid);
2943     assert(code == 0);
2944     dir->dirHandle = newdir;
2945 }
2946
2947 /**
2948  * arguments for JudgeEntry.
2949  */
2950 struct judgeEntry_params {
2951     struct DirSummary *dir;    /**< directory we're examining entries in */
2952     struct SalvInfo *salvinfo; /**< SalvInfo for the current salvage job */
2953 };
2954
2955 int
2956 JudgeEntry(void *arock, char *name, afs_int32 vnodeNumber,
2957            afs_int32 unique)
2958 {
2959     struct judgeEntry_params *params = arock;
2960     struct DirSummary *dir = params->dir;
2961     struct SalvInfo *salvinfo = params->salvinfo;
2962     struct VnodeEssence *vnodeEssence;
2963     afs_int32 dirOrphaned, todelete;
2964
2965     dirOrphaned = IsVnodeOrphaned(salvinfo, dir->vnodeNumber);
2966
2967     vnodeEssence = CheckVnodeNumber(salvinfo, vnodeNumber);
2968     if (vnodeEssence == NULL) {
2969         if (!Showmode) {
2970             Log("dir vnode %u: invalid entry deleted: %s/%s (vnode %u, unique %u)\n", dir->vnodeNumber, dir->name ? dir->name : "??", name, vnodeNumber, unique);
2971         }
2972         if (!Testing) {
2973             CopyOnWrite(salvinfo, dir);
2974             assert(Delete(&dir->dirHandle, name) == 0);
2975         }
2976         return 0;
2977     }
2978 #ifdef AFS_AIX_ENV
2979 #ifndef AFS_NAMEI_ENV
2980     /* On AIX machines, don't allow entries to point to inode 0. That is a special
2981      * mount inode for the partition. If this inode were deleted, it would crash
2982      * the machine.
2983      */
2984     if (vnodeEssence->InodeNumber == 0) {
2985         Log("dir vnode %d: invalid entry: %s/%s has no inode (vnode %d, unique %d)%s\n", dir->vnodeNumber, (dir->name ? dir->name : "??"), name, vnodeNumber, unique, (Testing ? "-- would have deleted" : " -- deleted"));
2986         if (!Testing) {
2987             CopyOnWrite(salvinfo, dir);
2988             assert(Delete(&dir->dirHandle, name) == 0);
2989         }
2990         return 0;
2991     }
2992 #endif
2993 #endif
2994
2995     if (!(vnodeNumber & 1) && !Showmode
2996         && !(vnodeEssence->count || vnodeEssence->unique
2997              || vnodeEssence->modeBits)) {
2998         Log("dir vnode %u: invalid entry: %s/%s (vnode %u, unique %u)%s\n",
2999             dir->vnodeNumber, (dir->name ? dir->name : "??"), name,
3000             vnodeNumber, unique,
3001             ((!unique) ? (Testing ? "-- would have deleted" : " -- deleted") :
3002              ""));
3003         if (!unique) {
3004             if (!Testing) {
3005                 CopyOnWrite(salvinfo, dir);
3006                 assert(Delete(&dir->dirHandle, name) == 0);
3007             }
3008             return 0;
3009         }
3010     }
3011
3012     /* Check if the Uniquifiers match. If not, change the directory entry
3013      * so its unique matches the vnode unique. Delete if the unique is zero
3014      * or if the directory is orphaned.
3015      */
3016     if (!vnodeEssence->unique || (vnodeEssence->unique) != unique) {
3017         if (!vnodeEssence->unique
3018             && ((strcmp(name, "..") == 0) || (strcmp(name, ".") == 0))) {
3019             /* This is an orphaned directory. Don't delete the . or ..
3020              * entry. Otherwise, it will get created in the next
3021              * salvage and deleted again here. So Just skip it.
3022              */
3023             return 0;
3024         }
3025
3026         todelete = ((!vnodeEssence->unique || dirOrphaned) ? 1 : 0);
3027
3028         if (!Showmode) {
3029             Log("dir vnode %u: %s/%s (vnode %u): unique changed from %u to %u %s\n", dir->vnodeNumber, (dir->name ? dir->name : "??"), name, vnodeNumber, unique, vnodeEssence->unique, (!todelete ? "" : (Testing ? "-- would have deleted" : "-- deleted")));
3030         }
3031         if (!Testing) {
3032             AFSFid fid;
3033             fid.Vnode = vnodeNumber;
3034             fid.Unique = vnodeEssence->unique;
3035             CopyOnWrite(salvinfo, dir);
3036             assert(Delete(&dir->dirHandle, name) == 0);
3037             if (!todelete)
3038                 assert(Create(&dir->dirHandle, name, &fid) == 0);
3039         }
3040         if (todelete)
3041             return 0;           /* no need to continue */
3042     }
3043
3044     if (strcmp(name, ".") == 0) {
3045         if (dir->vnodeNumber != vnodeNumber || (dir->unique != unique)) {
3046             AFSFid fid;
3047             if (!Showmode)
3048                 Log("directory vnode %u.%u: bad '.' entry (was %u.%u); fixed\n", dir->vnodeNumber, dir->unique, vnodeNumber, unique);
3049             if (!Testing) {
3050                 CopyOnWrite(salvinfo, dir);
3051                 assert(Delete(&dir->dirHandle, ".") == 0);
3052                 fid.Vnode = dir->vnodeNumber;
3053                 fid.Unique = dir->unique;
3054                 assert(Create(&dir->dirHandle, ".", &fid) == 0);
3055             }
3056
3057             vnodeNumber = fid.Vnode;    /* Get the new Essence */
3058             unique = fid.Unique;
3059             vnodeEssence = CheckVnodeNumber(salvinfo, vnodeNumber);
3060         }
3061         dir->haveDot = 1;
3062     } else if (strcmp(name, "..") == 0) {
3063         AFSFid pa;
3064         if (dir->parent) {
3065             struct VnodeEssence *dotdot;
3066             pa.Vnode = dir->parent;
3067             dotdot = CheckVnodeNumber(salvinfo, pa.Vnode);
3068             assert(dotdot != NULL);     /* XXX Should not be assert */
3069             pa.Unique = dotdot->unique;
3070         } else {
3071             pa.Vnode = dir->vnodeNumber;
3072             pa.Unique = dir->unique;
3073         }
3074         if ((pa.Vnode != vnodeNumber) || (pa.Unique != unique)) {
3075             if (!Showmode)
3076                 Log("directory vnode %u.%u: bad '..' entry (was %u.%u); fixed\n", dir->vnodeNumber, dir->unique, vnodeNumber, unique);
3077             if (!Testing) {
3078                 CopyOnWrite(salvinfo, dir);
3079                 assert(Delete(&dir->dirHandle, "..") == 0);
3080                 assert(Create(&dir->dirHandle, "..", &pa) == 0);
3081             }
3082
3083             vnodeNumber = pa.Vnode;     /* Get the new Essence */
3084             unique = pa.Unique;
3085             vnodeEssence = CheckVnodeNumber(salvinfo, vnodeNumber);
3086         }
3087         dir->haveDotDot = 1;
3088     } else if (strncmp(name, ".__afs", 6) == 0) {
3089         if (!Showmode) {
3090             Log("dir vnode %u: special old unlink-while-referenced file %s %s deleted (vnode %u)\n", dir->vnodeNumber, name, (Testing ? "would have been" : "is"), vnodeNumber);
3091         }
3092         if (!Testing) {
3093             CopyOnWrite(salvinfo, dir);
3094             assert(Delete(&dir->dirHandle, name) == 0);
3095         }
3096         vnodeEssence->claimed = 0;      /* Not claimed: Orphaned */
3097         vnodeEssence->todelete = 1;     /* Will later delete vnode and decr inode */
3098         return 0;
3099     } else {
3100         if (ShowSuid && (vnodeEssence->modeBits & 06000))
3101             Log("FOUND suid/sgid file: %s/%s (%u.%u %05o) author %u (vnode %u dir %u)\n", dir->name ? dir->name : "??", name, vnodeEssence->owner, vnodeEssence->group, vnodeEssence->modeBits, vnodeEssence->author, vnodeNumber, dir->vnodeNumber);
3102         if (/* ShowMounts && */ (vnodeEssence->type == vSymlink)
3103             && !(vnodeEssence->modeBits & 0111)) {
3104             ssize_t nBytes;
3105             afs_sfsize_t size;
3106             char buf[1025];
3107             IHandle_t *ihP;
3108             FdHandle_t *fdP;
3109
3110             IH_INIT(ihP, salvinfo->fileSysDevice, dir->dirHandle.dirh_handle->ih_vid,
3111                     vnodeEssence->InodeNumber);
3112             fdP = IH_OPEN(ihP);
3113             if (fdP == NULL) {
3114                 Log("ERROR %s could not open mount point vnode %u\n", dir->vname, vnodeNumber);
3115                 IH_RELEASE(ihP);
3116                 return 0;
3117             }
3118             size = FDH_SIZE(fdP);
3119             if (size < 0) {
3120                 Log("ERROR %s mount point has invalid size %d, vnode %u\n", dir->vname, (int)size, vnodeNumber);
3121                 FDH_REALLYCLOSE(fdP);
3122                 IH_RELEASE(ihP);
3123                 return 0;
3124             }
3125
3126             if (size > 1024)
3127                 size = 1024;
3128             nBytes = FDH_READ(fdP, buf, size);
3129             if (nBytes == size) {
3130                 buf[size] = '\0';
3131                 if ( (*buf != '#' && *buf != '%') || buf[strlen(buf)-1] != '.' ) {
3132                     Log("Volume %u (%s) mount point %s/%s to '%s' invalid, %s to symbolic link\n",
3133                         dir->dirHandle.dirh_handle->ih_vid, dir->vname, dir->name ? dir->name : "??", name, buf,
3134                         Testing ? "would convert" : "converted");
3135                     vnodeEssence->modeBits |= 0111;
3136                     vnodeEssence->changed = 1;
3137                 } else if (ShowMounts) Log("In volume %u (%s) found mountpoint %s/%s to '%s'\n",
3138                     dir->dirHandle.dirh_handle->ih_vid, dir->vname,
3139                     dir->name ? dir->name : "??", name, buf);
3140             } else {
3141                 Log("Volume %s cound not read mount point vnode %u size %d code %d\n",
3142                     dir->vname, vnodeNumber, (int)size, (int)nBytes);
3143             }
3144             FDH_REALLYCLOSE(fdP);
3145             IH_RELEASE(ihP);
3146         }
3147         if (ShowRootFiles && vnodeEssence->owner == 0 && vnodeNumber != 1)
3148             Log("FOUND root file: %s/%s (%u.%u %05o) author %u (vnode %u dir %u)\n", dir->name ? dir->name : "??", name, vnodeEssence->owner, vnodeEssence->group, vnodeEssence->modeBits, vnodeEssence->author, vnodeNumber, dir->vnodeNumber);
3149         if (vnodeIdToClass(vnodeNumber) == vLarge
3150             && vnodeEssence->name == NULL) {
3151             char *n;
3152             if ((n = (char *)malloc(strlen(name) + 1)))
3153                 strcpy(n, name);
3154             vnodeEssence->name = n;
3155         }
3156
3157         /* The directory entry points to the vnode. Check to see if the
3158          * vnode points back to the directory. If not, then let the
3159          * directory claim it (else it might end up orphaned). Vnodes
3160          * already claimed by another directory are deleted from this
3161          * directory: hardlinks to the same vnode are not allowed
3162          * from different directories.
3163          */
3164         if (vnodeEssence->parent != dir->vnodeNumber) {
3165             if (!vnodeEssence->claimed && !dirOrphaned && vnodeNumber != 1) {
3166                 /* Vnode does not point back to this directory.
3167                  * Orphaned dirs cannot claim a file (it may belong to
3168                  * another non-orphaned dir).
3169                  */
3170                 if (!Showmode) {
3171                     Log("dir vnode %u: %s/%s (vnode %u, unique %u) -- parent vnode %schanged from %u to %u\n", dir->vnodeNumber, (dir->name ? dir->name : "??"), name, vnodeNumber, unique, (Testing ? "would have been " : ""), vnodeEssence->parent, dir->vnodeNumber);
3172                 }
3173                 vnodeEssence->parent = dir->vnodeNumber;
3174                 vnodeEssence->changed = 1;
3175             } else {
3176                 /* Vnode was claimed by another directory */
3177                 if (!Showmode) {
3178                     if (dirOrphaned) {
3179                         Log("dir vnode %u: %s/%s parent vnode is %u (vnode %u, unique %u) -- %sdeleted\n", dir->vnodeNumber, (dir->name ? dir->name : "??"), name, vnodeEssence->parent, vnodeNumber, unique, (Testing ? "would have been " : ""));
3180                     } else if (vnodeNumber == 1) {
3181                         Log("dir vnode %d: %s/%s is invalid (vnode %d, unique %d) -- %sdeleted\n", dir->vnodeNumber, (dir->name ? dir->name : "??"), name, vnodeNumber, unique, (Testing ? "would have been " : ""));
3182                     } else {
3183                         Log("dir vnode %u: %s/%s already claimed by directory vnode %u (vnode %u, unique %u) -- %sdeleted\n", dir->vnodeNumber, (dir->name ? dir->name : "??"), name, vnodeEssence->parent, vnodeNumber, unique, (Testing ? "would have been " : ""));
3184                     }
3185                 }
3186                 if (!Testing) {
3187                     CopyOnWrite(salvinfo, dir);
3188                     assert(Delete(&dir->dirHandle, name) == 0);
3189                 }
3190                 return 0;
3191             }
3192         }
3193         /* This directory claims the vnode */
3194         vnodeEssence->claimed = 1;
3195     }
3196     vnodeEssence->count--;
3197     return 0;
3198 }
3199
3200 void
3201 DistilVnodeEssence(struct SalvInfo *salvinfo, VolumeId rwVId,
3202                    VnodeClass class, Inode ino, Unique * maxu)
3203 {
3204     struct VnodeInfo *vip = &salvinfo->vnodeInfo[class];
3205     struct VnodeClassInfo *vcp = &VnodeClassInfo[class];
3206     char buf[SIZEOF_LARGEDISKVNODE];
3207     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)buf;
3208     afs_sfsize_t size;
3209     StreamHandle_t *file;
3210     int vnodeIndex;
3211     int nVnodes;
3212     FdHandle_t *fdP;
3213
3214     IH_INIT(vip->handle, salvinfo->fileSysDevice, rwVId, ino);
3215     fdP = IH_OPEN(vip->handle);
3216     assert(fdP != NULL);
3217     file = FDH_FDOPEN(fdP, "r+");
3218     assert(file != NULL);
3219     size = OS_SIZE(fdP->fd_fd);
3220     assert(size != -1);
3221     vip->nVnodes = (size / vcp->diskSize) - 1;
3222     if (vip->nVnodes > 0) {
3223         assert((vip->nVnodes + 1) * vcp->diskSize == size);
3224         assert(STREAM_SEEK(file, vcp->diskSize, 0) == 0);
3225         assert((vip->vnodes = (struct VnodeEssence *)
3226                 calloc(vip->nVnodes, sizeof(struct VnodeEssence))) != NULL);
3227         if (class == vLarge) {
3228             assert((vip->inodes = (Inode *)
3229                     calloc(vip->nVnodes, sizeof(Inode))) != NULL);
3230         } else {
3231             vip->inodes = NULL;
3232         }
3233     } else {
3234         vip->nVnodes = 0;
3235         vip->vnodes = NULL;
3236         vip->inodes = NULL;
3237     }
3238     vip->volumeBlockCount = vip->nAllocatedVnodes = 0;
3239     for (vnodeIndex = 0, nVnodes = vip->nVnodes;
3240          nVnodes && STREAM_READ(vnode, vcp->diskSize, 1, file) == 1;
3241          nVnodes--, vnodeIndex++) {
3242         if (vnode->type != vNull) {
3243             struct VnodeEssence *vep = &vip->vnodes[vnodeIndex];
3244             afs_fsize_t vnodeLength;
3245             vip->nAllocatedVnodes++;
3246             vep->count = vnode->linkCount;
3247             VNDISK_GET_LEN(vnodeLength, vnode);
3248             vep->blockCount = nBlocks(vnodeLength);
3249             vip->volumeBlockCount += vep->blockCount;
3250             vep->parent = vnode->parent;
3251             vep->unique = vnode->uniquifier;
3252             if (*maxu < vnode->uniquifier)
3253                 *maxu = vnode->uniquifier;
3254             vep->modeBits = vnode->modeBits;
3255             vep->InodeNumber = VNDISK_GET_INO(vnode);
3256             vep->type = vnode->type;
3257             vep->author = vnode->author;
3258             vep->owner = vnode->owner;
3259             vep->group = vnode->group;
3260             if (vnode->type == vDirectory) {
3261                 if (class != vLarge) {
3262                     VnodeId vnodeNumber = bitNumberToVnodeNumber(vnodeIndex, class);
3263                     vip->nAllocatedVnodes--;
3264                     memset(vnode, 0, sizeof(vnode));
3265                     IH_IWRITE(salvinfo->vnodeInfo[vSmall].handle,
3266                               vnodeIndexOffset(vcp, vnodeNumber),
3267                               (char *)&vnode, sizeof(vnode));
3268                     salvinfo->VolumeChanged = 1;
3269                 } else
3270                     vip->inodes[vnodeIndex] = VNDISK_GET_INO(vnode);
3271             }
3272         }
3273     }
3274     STREAM_CLOSE(file);
3275     FDH_CLOSE(fdP);
3276 }
3277
3278 static char *
3279 GetDirName(struct SalvInfo *salvinfo, VnodeId vnode, struct VnodeEssence *vp,
3280            char *path)
3281 {
3282     struct VnodeEssence *parentvp;
3283
3284     if (vnode == 1) {
3285         strcpy(path, ".");
3286         return path;
3287     }
3288     if (vp->parent && vp->name && (parentvp = CheckVnodeNumber(salvinfo, vp->parent))
3289         && GetDirName(salvinfo, vp->parent, parentvp, path)) {
3290         strcat(path, "/");
3291         strcat(path, vp->name);
3292         return path;
3293     }
3294     return 0;
3295 }
3296
3297 /* To determine if a vnode is orhpaned or not, the vnode and all its parent
3298  * vnodes must be "claimed". The vep->claimed flag is set in JudgeEntry().
3299  */
3300 static int
3301 IsVnodeOrphaned(struct SalvInfo *salvinfo, VnodeId vnode)
3302 {
3303     struct VnodeEssence *vep;
3304
3305     if (vnode == 0)
3306         return (1);             /* Vnode zero does not exist */
3307     if (vnode == 1)
3308         return (0);             /* The root dir vnode is always claimed */
3309     vep = CheckVnodeNumber(salvinfo, vnode);    /* Get the vnode essence */
3310     if (!vep || !vep->claimed)
3311         return (1);             /* Vnode is not claimed - it is orphaned */
3312
3313     return (IsVnodeOrphaned(salvinfo, vep->parent));
3314 }
3315
3316 void
3317 SalvageDir(struct SalvInfo *salvinfo, char *name, VolumeId rwVid,
3318            struct VnodeInfo *dirVnodeInfo, IHandle_t * alinkH, int i,
3319            struct DirSummary *rootdir, int *rootdirfound)
3320 {
3321     static struct DirSummary dir;
3322     static struct DirHandle dirHandle;
3323     struct VnodeEssence *parent;
3324     static char path[MAXPATHLEN];
3325     int dirok, code;
3326
3327     if (dirVnodeInfo->vnodes[i].salvaged)
3328         return;                 /* already salvaged */
3329
3330     dir.rwVid = rwVid;
3331     dirVnodeInfo->vnodes[i].salvaged = 1;
3332
3333     if (dirVnodeInfo->inodes[i] == 0)
3334         return;                 /* Not allocated to a directory */
3335
3336     if (bitNumberToVnodeNumber(i, vLarge) == 1) {
3337         if (dirVnodeInfo->vnodes[i].parent) {
3338             Log("Bad parent, vnode 1; %s...\n",
3339                 (Testing ? "skipping" : "salvaging"));
3340             dirVnodeInfo->vnodes[i].parent = 0;
3341             dirVnodeInfo->vnodes[i].changed = 1;
3342         }
3343     } else {
3344         parent = CheckVnodeNumber(salvinfo, dirVnodeInfo->vnodes[i].parent);
3345         if (parent && parent->salvaged == 0)
3346             SalvageDir(salvinfo, name, rwVid, dirVnodeInfo, alinkH,
3347                        vnodeIdToBitNumber(dirVnodeInfo->vnodes[i].parent),
3348                        rootdir, rootdirfound);
3349     }
3350
3351     dir.vnodeNumber = bitNumberToVnodeNumber(i, vLarge);
3352     dir.unique = dirVnodeInfo->vnodes[i].unique;
3353     dir.copied = 0;
3354     dir.vname = name;
3355     dir.parent = dirVnodeInfo->vnodes[i].parent;
3356     dir.haveDot = dir.haveDotDot = 0;
3357     dir.ds_linkH = alinkH;
3358     SetSalvageDirHandle(&dir.dirHandle, dir.rwVid, salvinfo->fileSysDevice,
3359                         dirVnodeInfo->inodes[i], &salvinfo->VolumeChanged);
3360
3361     dirok = ((RebuildDirs && !Testing) ? 0 : DirOK(&dir.dirHandle));
3362     if (!dirok) {
3363         if (!RebuildDirs) {
3364             Log("Directory bad, vnode %u; %s...\n", dir.vnodeNumber,
3365                 (Testing ? "skipping" : "salvaging"));
3366         }
3367         if (!Testing) {
3368             CopyAndSalvage(salvinfo, &dir);
3369             dirok = 1;
3370             dirVnodeInfo->inodes[i] = dir.dirHandle.dirh_inode;
3371         }
3372     }
3373     dirHandle = dir.dirHandle;
3374
3375     dir.name =
3376         GetDirName(salvinfo, bitNumberToVnodeNumber(i, vLarge),
3377                    &dirVnodeInfo->vnodes[i], path);
3378
3379     if (dirok) {
3380         /* If enumeration failed for random reasons, we will probably delete
3381          * too much stuff, so we guard against this instead.
3382          */
3383         struct judgeEntry_params judge_params;
3384         judge_params.salvinfo = salvinfo;
3385         judge_params.dir = &dir;
3386
3387         assert(EnumerateDir(&dirHandle, JudgeEntry, &judge_params) == 0);
3388     }
3389
3390     /* Delete the old directory if it was copied in order to salvage.
3391      * CopyOnWrite has written the new inode # to the disk, but we still
3392      * have the old one in our local structure here.  Thus, we idec the
3393      * local dude.
3394      */
3395     DFlush();
3396     if (dir.copied && !Testing) {
3397         code = IH_DEC(dir.ds_linkH, dirHandle.dirh_handle->ih_ino, rwVid);
3398         assert(code == 0);
3399         dirVnodeInfo->inodes[i] = dir.dirHandle.dirh_inode;
3400     }
3401
3402     /* Remember rootdir DirSummary _after_ it has been judged */
3403     if (dir.vnodeNumber == 1 && dir.unique == 1) {
3404         memcpy(rootdir, &dir, sizeof(struct DirSummary));
3405         *rootdirfound = 1;
3406     }
3407
3408     return;
3409 }
3410
3411 /**
3412  * Get a new FID that can be used to create a new file.
3413  *
3414  * @param[in] volHeader vol header for the volume
3415  * @param[in] class     what type of vnode we'll be creating (vLarge or vSmall)
3416  * @param[out] afid     the FID that we can use (only Vnode and Unique are set)
3417  * @param[inout] maxunique  max uniquifier for all vnodes in the volume;
3418  *                          updated to the new max unique if we create a new
3419  *                          vnode
3420  */
3421 static void
3422 GetNewFID(struct SalvInfo *salvinfo, VolumeDiskData *volHeader,
3423           VnodeClass class, AFSFid *afid, Unique *maxunique)
3424 {
3425     int i;
3426     for (i = 0; i < salvinfo->vnodeInfo[class].nVnodes; i++) {
3427         if (salvinfo->vnodeInfo[class].vnodes[i].type == vNull) {
3428             break;
3429         }
3430     }
3431     if (i == salvinfo->vnodeInfo[class].nVnodes) {
3432         /* no free vnodes; make a new one */
3433         salvinfo->vnodeInfo[class].nVnodes++;
3434         salvinfo->vnodeInfo[class].vnodes =
3435             realloc(salvinfo->vnodeInfo[class].vnodes,
3436                     sizeof(struct VnodeEssence) * (i+1));
3437
3438         salvinfo->vnodeInfo[class].vnodes[i].type = vNull;
3439     }
3440
3441     afid->Vnode = bitNumberToVnodeNumber(i, class);
3442
3443     if (volHeader->uniquifier < (*maxunique + 1)) {
3444         /* header uniq is bad; it will get bumped by 2000 later */
3445         afid->Unique = *maxunique + 1 + 2000;
3446         (*maxunique)++;
3447     } else {
3448         /* header uniq seems okay; just use that */
3449         afid->Unique = *maxunique = volHeader->uniquifier++;
3450     }
3451 }
3452
3453 /**
3454  * Create a vnode for a README file explaining not to use a recreated-root vol.
3455  *
3456  * @param[in] volHeader vol header for the volume
3457  * @param[in] alinkH    ihandle for i/o for the volume
3458  * @param[in] vid       volume id
3459  * @param[inout] maxunique  max uniquifier for all vnodes in the volume;
3460  *                          updated to the new max unique if we create a new
3461  *                          vnode
3462  * @param[out] afid     FID for the new readme vnode
3463  * @param[out] ainode   the inode for the new readme file
3464  *
3465  * @return operation status
3466  *  @retval 0 success
3467  *  @retval -1 error
3468  */
3469 static int
3470 CreateReadme(struct SalvInfo *salvinfo, VolumeDiskData *volHeader,
3471              IHandle_t *alinkH, VolumeId vid, Unique *maxunique, AFSFid *afid,
3472              Inode *ainode)
3473 {
3474     Inode readmeinode;
3475     struct VnodeDiskObject *rvnode = NULL;
3476     afs_sfsize_t bytes;
3477     IHandle_t *readmeH = NULL;
3478     struct VnodeEssence *vep;
3479     afs_fsize_t length;
3480     time_t now = time(NULL);
3481
3482     /* Try to make the note brief, but informative. Only administrators should
3483      * be able to read this file at first, so we can hopefully assume they
3484      * know what AFS is, what a volume is, etc. */
3485     char readme[] =
3486 "This volume has been salvaged, but has lost its original root directory.\n"
3487 "The root directory that exists now has been recreated from orphan files\n"
3488 "from the rest of the volume. This recreated root directory may interfere\n"
3489 "with old cached data on clients, and there is no way the salvager can\n"
3490 "reasonably prevent that. So, it is recommended that you do not continue to\n"
3491 "use this volume, but only copy the salvaged data to a new volume.\n"
3492 "Continuing to use this volume as it exists now may cause some clients to\n"
3493 "behave oddly when accessing this volume.\n"
3494 "\n\t -- Your friendly neighborhood OpenAFS salvager\n";
3495     /* ^ the person reading this probably just lost some data, so they could
3496      * use some cheering up. */
3497
3498     /* -1 for the trailing NUL */
3499     length = sizeof(readme) - 1;
3500
3501     GetNewFID(salvinfo, volHeader, vSmall, afid, maxunique);
3502
3503     vep = &salvinfo->vnodeInfo[vSmall].vnodes[vnodeIdToBitNumber(afid->Vnode)];
3504
3505     /* create the inode and write the contents */
3506     readmeinode = IH_CREATE(alinkH, salvinfo->fileSysDevice,
3507                             salvinfo->fileSysPath, 0, vid,
3508                             afid->Vnode, afid->Unique, 1);
3509     if (!VALID_INO(readmeinode)) {
3510         Log("CreateReadme: readme IH_CREATE failed\n");
3511         goto error;
3512     }
3513
3514     IH_INIT(readmeH, salvinfo->fileSysDevice, vid, readmeinode);
3515     bytes = IH_IWRITE(readmeH, 0, readme, length);
3516     IH_RELEASE(readmeH);
3517
3518     if (bytes != length) {
3519         Log("CreateReadme: IWRITE failed (%d/%d)\n", (int)bytes,
3520             (int)sizeof(readme));
3521         goto error;
3522     }
3523
3524     /* create the vnode and write it out */
3525     rvnode = calloc(1, SIZEOF_SMALLDISKVNODE);
3526     if (!rvnode) {
3527         Log("CreateRootDir: error alloc'ing memory\n");
3528         goto error;
3529     }
3530
3531     rvnode->type = vFile;
3532     rvnode->cloned = 0;
3533     rvnode->modeBits = 0777;
3534     rvnode->linkCount = 1;
3535     VNDISK_SET_LEN(rvnode, length);
3536     rvnode->uniquifier = afid->Unique;
3537     rvnode->dataVersion = 1;
3538     VNDISK_SET_INO(rvnode, readmeinode);
3539     rvnode->unixModifyTime = rvnode->serverModifyTime = now;
3540     rvnode->author = 0;
3541     rvnode->owner = 0;
3542     rvnode->parent = 1;
3543     rvnode->group = 0;
3544     rvnode->vnodeMagic = VnodeClassInfo[vSmall].magic;
3545
3546     bytes = IH_IWRITE(salvinfo->vnodeInfo[vSmall].handle,
3547                       vnodeIndexOffset(&VnodeClassInfo[vSmall], afid->Vnode),
3548                       (char*)rvnode, SIZEOF_SMALLDISKVNODE);
3549
3550     if (bytes != SIZEOF_SMALLDISKVNODE) {
3551         Log("CreateReadme: IH_IWRITE failed (%d/%d)\n", (int)bytes,
3552             (int)SIZEOF_SMALLDISKVNODE);
3553         goto error;
3554     }
3555
3556     /* update VnodeEssence for new readme vnode */
3557     salvinfo->vnodeInfo[vSmall].nAllocatedVnodes++;
3558     vep->count = 0;
3559     vep->blockCount = nBlocks(length);
3560     salvinfo->vnodeInfo[vSmall].volumeBlockCount += vep->blockCount;
3561     vep->parent = rvnode->parent;
3562     vep->unique = rvnode->uniquifier;
3563     vep->modeBits = rvnode->modeBits;
3564     vep->InodeNumber = VNDISK_GET_INO(rvnode);
3565     vep->type = rvnode->type;
3566     vep->author = rvnode->author;
3567     vep->owner = rvnode->owner;
3568     vep->group = rvnode->group;
3569
3570     free(rvnode);
3571     rvnode = NULL;
3572
3573     vep->claimed = 1;
3574     vep->changed = 0;
3575     vep->salvaged = 1;
3576     vep->todelete = 0;
3577
3578     *ainode = readmeinode;
3579
3580     return 0;
3581
3582  error:
3583     if (IH_DEC(alinkH, readmeinode, vid)) {
3584         Log("CreateReadme (recovery): IH_DEC failed\n");
3585     }
3586
3587     if (rvnode) {
3588         free(rvnode);
3589         rvnode = NULL;
3590     }
3591
3592     return -1;
3593 }
3594
3595 /**
3596  * create a root dir for a volume that lacks one.
3597  *
3598  * @param[in] volHeader vol header for the volume
3599  * @param[in] alinkH    ihandle for disk access for this volume group
3600  * @param[in] vid       volume id we're dealing with
3601  * @param[out] rootdir  populated with info about the new root dir
3602  * @param[inout] maxunique  max uniquifier for all vnodes in the volume;
3603  *                          updated to the new max unique if we create a new
3604  *                          vnode
3605  *
3606  * @return operation status
3607  *  @retval 0  success
3608  *  @retval -1 error
3609  */
3610 static int
3611 CreateRootDir(struct SalvInfo *salvinfo, VolumeDiskData *volHeader,
3612               IHandle_t *alinkH, VolumeId vid, struct DirSummary *rootdir,
3613               Unique *maxunique)
3614 {
3615     FileVersion dv;
3616     int decroot = 0, decreadme = 0;
3617     AFSFid did, readmeid;
3618     afs_fsize_t length;
3619     Inode rootinode;
3620     struct VnodeDiskObject *rootvnode = NULL;
3621     struct acl_accessList *ACL;
3622     Inode *ip;
3623     afs_sfsize_t bytes;
3624     struct VnodeEssence *vep;
3625     Inode readmeinode;
3626     time_t now = time(NULL);
3627
3628     if (!salvinfo->vnodeInfo[vLarge].vnodes && !salvinfo->vnodeInfo[vSmall].vnodes) {
3629         Log("Not creating new root dir; volume appears to lack any vnodes\n");
3630         goto error;
3631     }
3632
3633     if (!salvinfo->vnodeInfo[vLarge].vnodes) {
3634         /* We don't have any large vnodes in the volume; allocate room
3635          * for one so we can recreate the root dir */
3636         salvinfo->vnodeInfo[vLarge].nVnodes = 1;
3637         salvinfo->vnodeInfo[vLarge].vnodes = calloc(1, sizeof(struct VnodeEssence));
3638         salvinfo->vnodeInfo[vLarge].inodes = calloc(1, sizeof(Inode));
3639
3640         assert(salvinfo->vnodeInfo[vLarge].vnodes);
3641         assert(salvinfo->vnodeInfo[vLarge].inodes);
3642     }
3643
3644     vep = &salvinfo->vnodeInfo[vLarge].vnodes[vnodeIdToBitNumber(1)];
3645     ip = &salvinfo->vnodeInfo[vLarge].inodes[vnodeIdToBitNumber(1)];
3646     if (vep->type != vNull) {
3647         Log("Not creating new root dir; existing vnode 1 is non-null\n");
3648         goto error;
3649     }
3650
3651     if (CreateReadme(salvinfo, volHeader, alinkH, vid, maxunique, &readmeid,
3652                      &readmeinode) != 0) {
3653         goto error;
3654     }
3655     decreadme = 1;
3656
3657     /* set the DV to a very high number, so it is unlikely that we collide
3658      * with a cached DV */
3659     dv = 1 << 30;
3660
3661     rootinode = IH_CREATE(alinkH, salvinfo->fileSysDevice, salvinfo->fileSysPath,
3662                           0, vid, 1, 1, dv);
3663     if (!VALID_INO(rootinode)) {
3664         Log("CreateRootDir: IH_CREATE failed\n");
3665         goto error;
3666     }
3667     decroot = 1;
3668
3669     SetSalvageDirHandle(&rootdir->dirHandle, vid, salvinfo->fileSysDevice,
3670                         rootinode, &salvinfo->VolumeChanged);
3671     did.Volume = vid;
3672     did.Vnode = 1;
3673     did.Unique = 1;
3674     if (MakeDir(&rootdir->dirHandle, (afs_int32*)&did, (afs_int32*)&did)) {
3675         Log("CreateRootDir: MakeDir failed\n");
3676         goto error;
3677     }
3678     if (Create(&rootdir->dirHandle, "README.ROOTDIR", &readmeid)) {
3679         Log("CreateRootDir: Create failed\n");
3680         goto error;
3681     }
3682     DFlush();
3683     length = Length(&rootdir->dirHandle);
3684     DZap((void *)&rootdir->dirHandle);
3685
3686     /* create the new root dir vnode */
3687     rootvnode = calloc(1, SIZEOF_LARGEDISKVNODE);
3688     if (!rootvnode) {
3689         Log("CreateRootDir: malloc failed\n");
3690         goto error;
3691     }
3692
3693     /* only give 'rl' permissions to 'system:administrators'. We do this to
3694      * try to catch the attention of an administrator, that they should not
3695      * be writing to this directory or continue to use it. */
3696     ACL = VVnodeDiskACL(rootvnode);
3697     ACL->size = sizeof(struct acl_accessList);
3698     ACL->version = ACL_ACLVERSION;
3699     ACL->total = 1;
3700     ACL->positive = 1;
3701     ACL->negative = 0;
3702     ACL->entries[0].id = -204; /* system:administrators */
3703     ACL->entries[0].rights = PRSFS_READ | PRSFS_LOOKUP;
3704
3705     rootvnode->type = vDirectory;
3706     rootvnode->cloned = 0;
3707     rootvnode->modeBits = 0777;
3708     rootvnode->linkCount = 2;
3709     VNDISK_SET_LEN(rootvnode, length);
3710     rootvnode->uniquifier = 1;
3711     rootvnode->dataVersion = dv;
3712     VNDISK_SET_INO(rootvnode, rootinode);
3713     rootvnode->unixModifyTime = rootvnode->serverModifyTime = now;
3714     rootvnode->author = 0;
3715     rootvnode->owner = 0;
3716     rootvnode->parent = 0;
3717     rootvnode->group = 0;
3718     rootvnode->vnodeMagic = VnodeClassInfo[vLarge].magic;
3719
3720     /* write it out to disk */
3721     bytes = IH_IWRITE(salvinfo->vnodeInfo[vLarge].handle,
3722               vnodeIndexOffset(&VnodeClassInfo[vLarge], 1),
3723               (char*)rootvnode, SIZEOF_LARGEDISKVNODE);
3724
3725     if (bytes != SIZEOF_LARGEDISKVNODE) {
3726         /* just cast to int and don't worry about printing real 64-bit ints;
3727          * a large disk vnode isn't anywhere near the 32-bit limit */
3728         Log("CreateRootDir: IH_IWRITE failed (%d/%d)\n", (int)bytes,
3729             (int)SIZEOF_LARGEDISKVNODE);
3730         goto error;
3731     }
3732
3733     /* update VnodeEssence for the new root vnode */
3734     salvinfo->vnodeInfo[vLarge].nAllocatedVnodes++;
3735     vep->count = 0;
3736     vep->blockCount = nBlocks(length);
3737     salvinfo->vnodeInfo[vLarge].volumeBlockCount += vep->blockCount;
3738     vep->parent = rootvnode->parent;
3739     vep->unique = rootvnode->uniquifier;
3740     vep->modeBits = rootvnode->modeBits;
3741     vep->InodeNumber = VNDISK_GET_INO(rootvnode);
3742     vep->type = rootvnode->type;
3743     vep->author = rootvnode->author;
3744     vep->owner = rootvnode->owner;
3745     vep->group = rootvnode->group;
3746
3747     free(rootvnode);
3748     rootvnode = NULL;
3749
3750     vep->claimed = 0;
3751     vep->changed = 0;
3752     vep->salvaged = 1;
3753     vep->todelete = 0;
3754
3755     /* update DirSummary for the new root vnode */
3756     rootdir->vnodeNumber = 1;
3757     rootdir->unique = 1;
3758     rootdir->haveDot = 1;
3759     rootdir->haveDotDot = 1;
3760     rootdir->rwVid = vid;
3761     rootdir->copied = 0;
3762     rootdir->parent = 0;
3763     rootdir->name = strdup(".");
3764     rootdir->vname = volHeader->name;
3765     rootdir->ds_linkH = alinkH;
3766
3767     *ip = rootinode;
3768
3769     return 0;
3770
3771  error:
3772     if (decroot && IH_DEC(alinkH, rootinode, vid)) {
3773         Log("CreateRootDir (recovery): IH_DEC (root) failed\n");
3774     }
3775     if (decreadme && IH_DEC(alinkH, readmeinode, vid)) {
3776         Log("CreateRootDir (recovery): IH_DEC (readme) failed\n");
3777     }
3778     if (rootvnode) {
3779         free(rootvnode);
3780         rootvnode = NULL;
3781     }
3782     return -1;
3783 }
3784
3785 /**
3786  * salvage a volume group.
3787  *
3788  * @param[in] salvinfo information for the curent salvage job
3789  * @param[in] rwIsp    inode summary for rw volume
3790  * @param[in] alinkH   link table inode handle
3791  *
3792  * @return operation status
3793  *   @retval 0 success
3794  */
3795 int
3796 SalvageVolume(struct SalvInfo *salvinfo, struct InodeSummary *rwIsp, IHandle_t * alinkH)
3797 {
3798     /* This routine, for now, will only be called for read-write volumes */
3799     int i, j, code;
3800     int BlocksInVolume = 0, FilesInVolume = 0;
3801     VnodeClass class;
3802     struct DirSummary rootdir, oldrootdir;
3803     struct VnodeInfo *dirVnodeInfo;
3804     struct VnodeDiskObject vnode;
3805     VolumeDiskData volHeader;
3806     VolumeId vid;
3807     int orphaned, rootdirfound = 0;
3808     Unique maxunique = 0;       /* the maxUniquifier from the vnodes */
3809     afs_int32 ofiles = 0, oblocks = 0;  /* Number of orphaned files/blocks */
3810     struct VnodeEssence *vep;
3811     afs_int32 v, pv;
3812     IHandle_t *h;
3813     afs_sfsize_t nBytes;
3814     AFSFid pa;
3815     VnodeId LFVnode, ThisVnode;
3816     Unique LFUnique, ThisUnique;
3817     char npath[128];
3818     int newrootdir = 0;
3819
3820     vid = rwIsp->volSummary->header.id;
3821     IH_INIT(h, salvinfo->fileSysDevice, vid, rwIsp->volSummary->header.volumeInfo);
3822     nBytes = IH_IREAD(h, 0, (char *)&volHeader, sizeof(volHeader));
3823     assert(nBytes == sizeof(volHeader));
3824     assert(volHeader.stamp.magic == VOLUMEINFOMAGIC);
3825     assert(volHeader.destroyMe != DESTROY_ME);
3826     /* (should not have gotten this far with DESTROY_ME flag still set!) */
3827
3828     DistilVnodeEssence(salvinfo, vid, vLarge,
3829                        rwIsp->volSummary->header.largeVnodeIndex, &maxunique);
3830     DistilVnodeEssence(salvinfo, vid, vSmall,
3831                        rwIsp->volSummary->header.smallVnodeIndex, &maxunique);
3832
3833     dirVnodeInfo = &salvinfo->vnodeInfo[vLarge];
3834     for (i = 0; i < dirVnodeInfo->nVnodes; i++) {
3835         SalvageDir(salvinfo, volHeader.name, vid, dirVnodeInfo, alinkH, i,
3836                    &rootdir, &rootdirfound);
3837     }
3838 #ifdef AFS_NT40_ENV
3839     nt_sync(salvinfo->fileSysDevice);
3840 #else
3841     sync();                             /* This used to be done lower level, for every dir */
3842 #endif
3843     if (Showmode) {
3844         IH_RELEASE(h);
3845         return 0;
3846     }
3847
3848     if (!rootdirfound && (orphans == ORPH_ATTACH) && !Testing) {
3849
3850         Log("Cannot find root directory for volume %lu; attempting to create "
3851             "a new one\n", afs_printable_uint32_lu(vid));
3852
3853         code = CreateRootDir(salvinfo, &volHeader, alinkH, vid, &rootdir,
3854                              &maxunique);
3855         if (code == 0) {
3856             rootdirfound = 1;
3857             newrootdir = 1;
3858             salvinfo->VolumeChanged = 1;
3859         }
3860     }
3861
3862     /* Parse each vnode looking for orphaned vnodes and
3863      * connect them to the tree as orphaned (if requested).
3864      */
3865     oldrootdir = rootdir;
3866     for (class = 0; class < nVNODECLASSES; class++) {
3867         for (v = 0; v < salvinfo->vnodeInfo[class].nVnodes; v++) {
3868             vep = &(salvinfo->vnodeInfo[class].vnodes[v]);
3869             ThisVnode = bitNumberToVnodeNumber(v, class);
3870             ThisUnique = vep->unique;
3871
3872             if ((vep->type == 0) || vep->claimed || ThisVnode == 1)
3873                 continue;       /* Ignore unused, claimed, and root vnodes */
3874
3875             /* This vnode is orphaned. If it is a directory vnode, then the '..'
3876              * entry in this vnode had incremented the parent link count (In
3877              * JudgeEntry()). We need to go to the parent and decrement that
3878              * link count. But if the parent's unique is zero, then the parent
3879              * link count was not incremented in JudgeEntry().
3880              */
3881             if (class == vLarge) {      /* directory vnode */
3882                 pv = vnodeIdToBitNumber(vep->parent);
3883                 if (salvinfo->vnodeInfo[vLarge].vnodes[pv].unique != 0) {
3884                     if (vep->parent == 1 && newrootdir) {
3885                         /* this vnode's parent was the volume root, and
3886                          * we just created the volume root. So, the parent
3887                          * dir didn't exist during JudgeEntry, so the link
3888                          * count was not inc'd there, so don't dec it here.
3889                          */
3890
3891                          /* noop */
3892
3893                     } else {
3894                         salvinfo->vnodeInfo[vLarge].vnodes[pv].count++;
3895                     }
3896                 }
3897             }
3898
3899             if (!rootdirfound)
3900                 continue;       /* If no rootdir, can't attach orphaned files */
3901
3902             /* Here we attach orphaned files and directories into the
3903              * root directory, LVVnode, making sure link counts stay correct.
3904              */
3905             if ((orphans == ORPH_ATTACH) && !vep->todelete && !Testing) {
3906                 LFVnode = rootdir.vnodeNumber;  /* Lost+Found vnode number */
3907                 LFUnique = rootdir.unique;      /* Lost+Found uniquifier */
3908
3909                 /* Update this orphaned vnode's info. Its parent info and
3910                  * link count (do for orphaned directories and files).
3911                  */
3912                 vep->parent = LFVnode;  /* Parent is the root dir */
3913                 vep->unique = LFUnique;
3914                 vep->changed = 1;
3915                 vep->claimed = 1;
3916                 vep->count--;   /* Inc link count (root dir will pt to it) */
3917
3918                 /* If this orphaned vnode is a directory, change '..'.
3919                  * The name of the orphaned dir/file is unknown, so we
3920                  * build a unique name. No need to CopyOnWrite the directory
3921                  * since it is not connected to tree in BK or RO volume and
3922                  * won't be visible there.
3923                  */
3924                 if (class == vLarge) {
3925                     AFSFid pa;
3926                     DirHandle dh;
3927
3928                     /* Remove and recreate the ".." entry in this orphaned directory */
3929                     SetSalvageDirHandle(&dh, vid, salvinfo->fileSysDevice,
3930                                         salvinfo->vnodeInfo[class].inodes[v],
3931                                         &salvinfo->VolumeChanged);
3932                     pa.Vnode = LFVnode;
3933                     pa.Unique = LFUnique;
3934                     assert(Delete(&dh, "..") == 0);
3935                     assert(Create(&dh, "..", &pa) == 0);
3936
3937                     /* The original parent's link count was decremented above.
3938                      * Here we increment the new parent's link count.
3939                      */
3940                     pv = vnodeIdToBitNumber(LFVnode);
3941                     salvinfo->vnodeInfo[vLarge].vnodes[pv].count--;
3942
3943                 }
3944
3945                 /* Go to the root dir and add this entry. The link count of the
3946                  * root dir was incremented when ".." was created. Try 10 times.
3947                  */
3948                 for (j = 0; j < 10; j++) {
3949                     pa.Vnode = ThisVnode;
3950                     pa.Unique = ThisUnique;
3951
3952                     (void)afs_snprintf(npath, sizeof npath, "%s.%u.%u",
3953                                        ((class ==
3954                                          vLarge) ? "__ORPHANDIR__" :
3955                                         "__ORPHANFILE__"), ThisVnode,
3956                                        ThisUnique);
3957
3958                     CopyOnWrite(salvinfo, &rootdir);
3959                     code = Create(&rootdir.dirHandle, npath, &pa);
3960                     if (!code)
3961                         break;
3962
3963                     ThisUnique += 50;   /* Try creating a different file */
3964                 }
3965                 assert(code == 0);
3966                 Log("Attaching orphaned %s to volume's root dir as %s\n",
3967                     ((class == vLarge) ? "directory" : "file"), npath);
3968             }
3969         }                       /* for each vnode in the class */
3970     }                           /* for each class of vnode */
3971
3972     /* Delete the old rootinode directory if the rootdir was CopyOnWrite */
3973     DFlush();
3974     if (rootdirfound && !oldrootdir.copied && rootdir.copied) {
3975         code =
3976             IH_DEC(oldrootdir.ds_linkH, oldrootdir.dirHandle.dirh_inode,
3977                    oldrootdir.rwVid);
3978         assert(code == 0);
3979         /* dirVnodeInfo->inodes[?] is not updated with new inode number */
3980     }
3981
3982     DFlush();                   /* Flush the changes */
3983     if (!rootdirfound && (orphans == ORPH_ATTACH)) {
3984         Log("Cannot attach orphaned files and directories: Root directory not found\n");
3985         orphans = ORPH_IGNORE;
3986     }
3987
3988     /* Write out all changed vnodes. Orphaned files and directories
3989      * will get removed here also (if requested).
3990      */
3991     for (class = 0; class < nVNODECLASSES; class++) {
3992         int nVnodes = salvinfo->vnodeInfo[class].nVnodes;
3993         struct VnodeClassInfo *vcp = &VnodeClassInfo[class];
3994         struct VnodeEssence *vnodes = salvinfo->vnodeInfo[class].vnodes;
3995         FilesInVolume += salvinfo->vnodeInfo[class].nAllocatedVnodes;
3996         BlocksInVolume += salvinfo->vnodeInfo[class].volumeBlockCount;
3997         for (i = 0; i < nVnodes; i++) {
3998             struct VnodeEssence *vnp = &vnodes[i];
3999             VnodeId vnodeNumber = bitNumberToVnodeNumber(i, class);
4000
4001             /* If the vnode is good but is unclaimed (not listed in
4002              * any directory entries), then it is orphaned.
4003              */
4004             orphaned = -1;
4005             if ((vnp->type != 0) && (orphaned = IsVnodeOrphaned(salvinfo, vnodeNumber))) {
4006                 vnp->claimed = 0;       /* Makes IsVnodeOrphaned calls faster */
4007                 vnp->changed = 1;
4008             }
4009
4010             if (vnp->changed || vnp->count) {
4011                 int oldCount;
4012                 nBytes =
4013           &nb