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