viced: Correct unblessed attach2 errors
[openafs.git] / src / vol / volume.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  * Portions Copyright (c) 2005-2008 Sine Nomine Associates
10  */
11
12 /* 1/1/89: NB:  this stuff is all going to be replaced.  Don't take it too seriously */
13 /*
14
15         System:         VICE-TWO
16         Module:         volume.c
17         Institution:    The Information Technology Center, Carnegie-Mellon University
18
19  */
20
21 #include <afsconfig.h>
22 #include <afs/param.h>
23
24
25 #include <rx/xdr.h>
26 #include <afs/afsint.h>
27 #include <ctype.h>
28 #include <signal.h>
29 #ifndef AFS_NT40_ENV
30 #include <sys/param.h>
31 #if !defined(AFS_SGI_ENV)
32 #ifdef  AFS_OSF_ENV
33 #include <ufs/fs.h>
34 #else /* AFS_OSF_ENV */
35 #ifdef AFS_VFSINCL_ENV
36 #define VFS
37 #ifdef  AFS_SUN5_ENV
38 #include <sys/fs/ufs_fs.h>
39 #else
40 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
41 #include <ufs/ufs/dinode.h>
42 #include <ufs/ffs/fs.h>
43 #else
44 #include <ufs/fs.h>
45 #endif
46 #endif
47 #else /* AFS_VFSINCL_ENV */
48 #if !defined(AFS_AIX_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_XBSD_ENV)
49 #include <sys/fs.h>
50 #endif
51 #endif /* AFS_VFSINCL_ENV */
52 #endif /* AFS_OSF_ENV */
53 #endif /* AFS_SGI_ENV */
54 #endif /* AFS_NT40_ENV */
55 #include <errno.h>
56 #include <sys/stat.h>
57 #include <stdio.h>
58 #ifdef AFS_NT40_ENV
59 #include <fcntl.h>
60 #else
61 #include <sys/file.h>
62 #endif
63 #include <dirent.h>
64 #ifdef  AFS_AIX_ENV
65 #include <sys/vfs.h>
66 #include <fcntl.h>
67 #else
68 #ifdef  AFS_HPUX_ENV
69 #include <fcntl.h>
70 #include <mntent.h>
71 #else
72 #if     defined(AFS_SUN_ENV) || defined(AFS_SUN5_ENV)
73 #ifdef  AFS_SUN5_ENV
74 #include <sys/mnttab.h>
75 #include <sys/mntent.h>
76 #else
77 #include <mntent.h>
78 #endif
79 #else
80 #ifndef AFS_NT40_ENV
81 #if defined(AFS_SGI_ENV)
82 #include <fcntl.h>
83 #include <mntent.h>
84
85 #else
86 #ifndef AFS_LINUX20_ENV
87 #include <fstab.h>              /* Need to find in libc 5, present in libc 6 */
88 #endif
89 #endif
90 #endif /* AFS_SGI_ENV */
91 #endif
92 #endif /* AFS_HPUX_ENV */
93 #endif
94 #ifndef AFS_NT40_ENV
95 #include <netdb.h>
96 #include <netinet/in.h>
97 #include <sys/wait.h>
98 #include <setjmp.h>
99 #ifndef ITIMER_REAL
100 #include <sys/time.h>
101 #endif /* ITIMER_REAL */
102 #endif /* AFS_NT40_ENV */
103 #if defined(AFS_SUN5_ENV) || defined(AFS_NT40_ENV) || defined(AFS_LINUX20_ENV)
104 #include <string.h>
105 #else
106 #include <strings.h>
107 #endif
108
109 #include "nfs.h"
110 #include <afs/errors.h>
111 #include "lock.h"
112 #include "lwp.h"
113 #include <afs/afssyscalls.h>
114 #include "ihandle.h"
115 #include <afs/afsutil.h>
116 #ifdef AFS_NT40_ENV
117 #include <io.h>
118 #endif
119 #include "daemon_com.h"
120 #include "fssync.h"
121 #include "salvsync.h"
122 #include "vnode.h"
123 #include "volume.h"
124 #include "partition.h"
125 #include "volume_inline.h"
126 #include "common.h"
127
128 #ifdef AFS_PTHREAD_ENV
129 #include <assert.h>
130 #else /* AFS_PTHREAD_ENV */
131 #include "afs/assert.h"
132 #endif /* AFS_PTHREAD_ENV */
133 #include "vutils.h"
134 #ifndef AFS_NT40_ENV
135 #include <afs/dir.h>
136 #include <unistd.h>
137 #endif
138
139 #if !defined(offsetof)
140 #include <stddef.h>
141 #endif
142
143 #ifdef O_LARGEFILE
144 #define afs_stat        stat64
145 #define afs_fstat       fstat64
146 #define afs_open        open64
147 #else /* !O_LARGEFILE */
148 #define afs_stat        stat
149 #define afs_fstat       fstat
150 #define afs_open        open
151 #endif /* !O_LARGEFILE */
152
153 #ifdef AFS_PTHREAD_ENV
154 pthread_mutex_t vol_glock_mutex;
155 pthread_mutex_t vol_trans_mutex;
156 pthread_cond_t vol_put_volume_cond;
157 pthread_cond_t vol_sleep_cond;
158 pthread_cond_t vol_init_attach_cond;
159 int vol_attach_threads = 1;
160 #endif /* AFS_PTHREAD_ENV */
161
162 /* start-time configurable I/O parameters */
163 ih_init_params vol_io_params;
164
165 #ifdef AFS_DEMAND_ATTACH_FS
166 pthread_mutex_t vol_salvsync_mutex;
167
168 /*
169  * Set this to 1 to disallow SALVSYNC communication in all threads; used
170  * during shutdown, since the salvageserver may have gone away.
171  */
172 static volatile sig_atomic_t vol_disallow_salvsync = 0;
173 #endif /* AFS_DEMAND_ATTACH_FS */
174
175 #ifdef  AFS_OSF_ENV
176 extern void *calloc(), *realloc();
177 #endif
178
179 /* Forward declarations */
180 static Volume *attach2(Error * ec, VolId volumeId, char *path,
181                        struct DiskPartition64 *partp, Volume * vp, 
182                        int isbusy, int mode);
183 static void ReallyFreeVolume(Volume * vp);
184 #ifdef AFS_DEMAND_ATTACH_FS
185 static void FreeVolume(Volume * vp);
186 #else /* !AFS_DEMAND_ATTACH_FS */
187 #define FreeVolume(vp) ReallyFreeVolume(vp)
188 static void VScanUpdateList(void);
189 #endif /* !AFS_DEMAND_ATTACH_FS */
190 static void VInitVolumeHeaderCache(afs_uint32 howMany);
191 static int GetVolumeHeader(register Volume * vp);
192 static void ReleaseVolumeHeader(register struct volHeader *hd);
193 static void FreeVolumeHeader(register Volume * vp);
194 static void AddVolumeToHashTable(register Volume * vp, int hashid);
195 static void DeleteVolumeFromHashTable(register Volume * vp);
196 #if 0
197 static int VHold(Volume * vp);
198 #endif
199 static int VHold_r(Volume * vp);
200 static void VGetBitmap_r(Error * ec, Volume * vp, VnodeClass class);
201 static void VReleaseVolumeHandles_r(Volume * vp);
202 static void VCloseVolumeHandles_r(Volume * vp);
203 static void LoadVolumeHeader(Error * ec, Volume * vp);
204 static int VCheckOffline(register Volume * vp);
205 static int VCheckDetach(register Volume * vp);
206 static Volume * GetVolume(Error * ec, Error * client_ec, VolId volumeId, Volume * hint, int flags);
207
208 int LogLevel;                   /* Vice loglevel--not defined as extern so that it will be
209                                  * defined when not linked with vice, XXXX */
210 ProgramType programType;        /* The type of program using the package */
211 static VolumePackageOptions vol_opts;
212
213 /* extended volume package statistics */
214 VolPkgStats VStats;
215
216 #ifdef VOL_LOCK_DEBUG
217 pthread_t vol_glock_holder = 0;
218 #endif
219
220
221 #define VOLUME_BITMAP_GROWSIZE  16      /* bytes, => 128vnodes */
222                                         /* Must be a multiple of 4 (1 word) !! */
223
224 /* this parameter needs to be tunable at runtime.
225  * 128 was really inadequate for largish servers -- at 16384 volumes this
226  * puts average chain length at 128, thus an average 65 deref's to find a volptr.
227  * talk about bad spatial locality...
228  *
229  * an AVL or splay tree might work a lot better, but we'll just increase
230  * the default hash table size for now
231  */
232 #define DEFAULT_VOLUME_HASH_SIZE 256   /* Must be a power of 2!! */
233 #define DEFAULT_VOLUME_HASH_MASK (DEFAULT_VOLUME_HASH_SIZE-1)
234 #define VOLUME_HASH(volumeId) (volumeId&(VolumeHashTable.Mask))
235
236 /*
237  * turn volume hash chains into partially ordered lists.
238  * when the threshold is exceeded between two adjacent elements,
239  * perform a chain rebalancing operation.
240  *
241  * keep the threshold high in order to keep cache line invalidates
242  * low "enough" on SMPs
243  */
244 #define VOLUME_HASH_REORDER_THRESHOLD 200
245
246 /*
247  * when possible, don't just reorder single elements, but reorder
248  * entire chains of elements at once.  a chain of elements that
249  * exceed the element previous to the pivot by at least CHAIN_THRESH 
250  * accesses are moved in front of the chain whose elements have at
251  * least CHAIN_THRESH less accesses than the pivot element
252  */
253 #define VOLUME_HASH_REORDER_CHAIN_THRESH (VOLUME_HASH_REORDER_THRESHOLD / 2)
254
255 #include "rx/rx_queue.h"
256
257
258 VolumeHashTable_t VolumeHashTable = {
259     DEFAULT_VOLUME_HASH_SIZE,
260     DEFAULT_VOLUME_HASH_MASK,
261     NULL
262 };
263
264
265 static void VInitVolumeHash(void);
266
267
268 #ifndef AFS_HAVE_FFS
269 /* This macro is used where an ffs() call does not exist. Was in util/ffs.c */
270 ffs(x)
271 {
272     afs_int32 ffs_i;
273     afs_int32 ffs_tmp = x;
274     if (ffs_tmp == 0)
275         return (-1);
276     else
277         for (ffs_i = 1;; ffs_i++) {
278             if (ffs_tmp & 1)
279                 return (ffs_i);
280             else
281                 ffs_tmp >>= 1;
282         }
283 }
284 #endif /* !AFS_HAVE_FFS */
285
286 #ifdef AFS_PTHREAD_ENV
287 /**
288  * disk partition queue element
289  */
290 typedef struct diskpartition_queue_t {
291     struct rx_queue queue;             /**< queue header */
292     struct DiskPartition64 *diskP;     /**< disk partition table entry */
293 } diskpartition_queue_t;
294
295 #ifndef AFS_DEMAND_ATTACH_FS
296
297 typedef struct vinitvolumepackage_thread_t {
298     struct rx_queue queue;
299     pthread_cond_t thread_done_cv;
300     int n_threads_complete;
301 } vinitvolumepackage_thread_t;
302 static void * VInitVolumePackageThread(void * args);
303
304 #else  /* !AFS_DEMAND_ATTTACH_FS */
305 #define VINIT_BATCH_MAX_SIZE 512
306
307 /**
308  * disk partition work queue
309  */
310 struct partition_queue {
311     struct rx_queue head;              /**< diskpartition_queue_t queue */
312     pthread_mutex_t mutex;
313     pthread_cond_t cv;
314 };
315
316 /**
317  * volumes parameters for preattach
318  */
319 struct volume_init_batch {
320     struct rx_queue queue;               /**< queue header */
321     int thread;                          /**< posting worker thread */
322     int last;                            /**< indicates thread is done */
323     int size;                            /**< number of volume ids in batch */
324     Volume *batch[VINIT_BATCH_MAX_SIZE]; /**< volumes ids to preattach */
325 };
326
327 /**
328  * volume parameters work queue
329  */
330 struct volume_init_queue {
331     struct rx_queue head;                /**< volume_init_batch queue */
332     pthread_mutex_t mutex;
333     pthread_cond_t cv;
334 };
335
336 /**
337  * volume init worker thread parameters
338  */
339 struct vinitvolumepackage_thread_param {
340     int nthreads;                        /**< total number of worker threads */
341     int thread;                          /**< thread number for this worker thread */
342     struct partition_queue *pq;          /**< queue partitions to scan */
343     struct volume_init_queue *vq;        /**< queue of volume to preattach */
344 };
345
346 static void *VInitVolumePackageThread(void *args);
347 static struct DiskPartition64 *VInitNextPartition(struct partition_queue *pq);
348 static VolId VInitNextVolumeId(DIR *dirp);
349 static int VInitPreAttachVolumes(int nthreads, struct volume_init_queue *vq);
350
351 #endif /* !AFS_DEMAND_ATTACH_FS */
352 #endif /* AFS_PTHREAD_ENV */
353
354 #ifndef AFS_DEMAND_ATTACH_FS
355 static int VAttachVolumesByPartition(struct DiskPartition64 *diskP, 
356                                      int * nAttached, int * nUnattached);
357 #endif /* AFS_DEMAND_ATTACH_FS */
358
359
360 #ifdef AFS_DEMAND_ATTACH_FS
361 /* demand attach fileserver extensions */
362
363 /* XXX
364  * in the future we will support serialization of VLRU state into the fs_state
365  * disk dumps
366  *
367  * these structures are the beginning of that effort
368  */
369 struct VLRU_DiskHeader {
370     struct versionStamp stamp;            /* magic and structure version number */
371     afs_uint32 mtime;                     /* time of dump to disk */
372     afs_uint32 num_records;               /* number of VLRU_DiskEntry records */
373 };
374
375 struct VLRU_DiskEntry {
376     afs_uint32 vid;                       /* volume ID */
377     afs_uint32 idx;                       /* generation */
378     afs_uint32 last_get;                  /* timestamp of last get */
379 };
380
381 struct VLRU_StartupQueue {
382     struct VLRU_DiskEntry * entry;
383     int num_entries;
384     int next_idx;
385 };
386
387 typedef struct vshutdown_thread_t {
388     struct rx_queue q;
389     pthread_mutex_t lock;
390     pthread_cond_t cv;
391     pthread_cond_t master_cv;
392     int n_threads;
393     int n_threads_complete;
394     int vol_remaining;
395     int schedule_version;
396     int pass;
397     byte n_parts;
398     byte n_parts_done_pass;
399     byte part_thread_target[VOLMAXPARTS+1];
400     byte part_done_pass[VOLMAXPARTS+1];
401     struct rx_queue * part_pass_head[VOLMAXPARTS+1];
402     int stats[4][VOLMAXPARTS+1];
403 } vshutdown_thread_t;
404 static void * VShutdownThread(void * args);
405
406
407 static Volume * VAttachVolumeByVp_r(Error * ec, Volume * vp, int mode);
408 static int VCheckFree(Volume * vp);
409
410 /* VByP List */
411 static void AddVolumeToVByPList_r(Volume * vp);
412 static void DeleteVolumeFromVByPList_r(Volume * vp);
413 static void VVByPListBeginExclusive_r(struct DiskPartition64 * dp);
414 static void VVByPListEndExclusive_r(struct DiskPartition64 * dp);
415 static void VVByPListWait_r(struct DiskPartition64 * dp);
416
417 /* online salvager */
418 static int VCheckSalvage(register Volume * vp);
419 #if defined(SALVSYNC_BUILD_CLIENT) || defined(FSSYNC_BUILD_CLIENT)
420 static int VScheduleSalvage_r(Volume * vp);
421 #endif
422
423 /* Volume hash table */
424 static void VReorderHash_r(VolumeHashChainHead * head, Volume * pp, Volume * vp);
425 static void VHashBeginExclusive_r(VolumeHashChainHead * head);
426 static void VHashEndExclusive_r(VolumeHashChainHead * head);
427 static void VHashWait_r(VolumeHashChainHead * head);
428
429 /* shutdown */
430 static int ShutdownVByPForPass_r(struct DiskPartition64 * dp, int pass);
431 static int ShutdownVolumeWalk_r(struct DiskPartition64 * dp, int pass,
432                                 struct rx_queue ** idx);
433 static void ShutdownController(vshutdown_thread_t * params);
434 static void ShutdownCreateSchedule(vshutdown_thread_t * params);
435
436 /* VLRU */
437 static void VLRU_ComputeConstants(void);
438 static void VInitVLRU(void);
439 static void VLRU_Init_Node_r(Volume * vp);
440 static void VLRU_Add_r(Volume * vp);
441 static void VLRU_Delete_r(Volume * vp);
442 static void VLRU_UpdateAccess_r(Volume * vp);
443 static void * VLRU_ScannerThread(void * args);
444 static void VLRU_Scan_r(int idx);
445 static void VLRU_Promote_r(int idx);
446 static void VLRU_Demote_r(int idx);
447 static void VLRU_SwitchQueues(Volume * vp, int new_idx, int append);
448
449 /* soft detach */
450 static int VCheckSoftDetach(Volume * vp, afs_uint32 thresh);
451 static int VCheckSoftDetachCandidate(Volume * vp, afs_uint32 thresh);
452 static int VSoftDetachVolume_r(Volume * vp, afs_uint32 thresh);
453
454
455 pthread_key_t VThread_key;
456 VThreadOptions_t VThread_defaults = {
457     0                           /**< allow salvsync */
458 };
459 #endif /* AFS_DEMAND_ATTACH_FS */
460
461
462 struct Lock vol_listLock;       /* Lock obtained when listing volumes:  
463                                  * prevents a volume from being missed 
464                                  * if the volume is attached during a 
465                                  * list volumes */
466
467
468 /* Common message used when the volume goes off line */
469 char *VSalvageMessage =
470     "Files in this volume are currently unavailable; call operations";
471
472 int VInit;                      /* 0 - uninitialized,
473                                  * 1 - initialized but not all volumes have been attached,
474                                  * 2 - initialized and all volumes have been attached,
475                                  * 3 - initialized, all volumes have been attached, and
476                                  * VConnectFS() has completed. */
477
478 static int vinit_attach_abort = 0;
479
480 bit32 VolumeCacheCheck;         /* Incremented everytime a volume goes on line--
481                                  * used to stamp volume headers and in-core
482                                  * vnodes.  When the volume goes on-line the
483                                  * vnode will be invalidated
484                                  * access only with VOL_LOCK held */
485
486
487
488
489 /***************************************************/
490 /* Startup routines                                */
491 /***************************************************/
492
493 #if defined(FAST_RESTART) && defined(AFS_DEMAND_ATTACH_FS)
494 # error FAST_RESTART and DAFS are incompatible. For the DAFS equivalent \
495         of FAST_RESTART, use the -unsafe-nosalvage fileserver argument
496 #endif
497
498 /**
499  * assign default values to a VolumePackageOptions struct.
500  *
501  * Always call this on a VolumePackageOptions struct first, then set any
502  * specific options you want, then call VInitVolumePackage2.
503  *
504  * @param[in]  pt   caller's program type
505  * @param[out] opts volume package options
506  */
507 void
508 VOptDefaults(ProgramType pt, VolumePackageOptions *opts)
509 {
510     opts->nLargeVnodes = opts->nSmallVnodes = 5;
511     opts->volcache = 0;
512
513     opts->canScheduleSalvage = 0;
514     opts->canUseFSSYNC = 0;
515     opts->canUseSALVSYNC = 0;
516
517 #ifdef FAST_RESTART
518     opts->unsafe_attach = 1;
519 #else /* !FAST_RESTART */
520     opts->unsafe_attach = 0;
521 #endif /* !FAST_RESTART */
522
523     switch (pt) {
524     case fileServer:
525         opts->canScheduleSalvage = 1;
526         opts->canUseSALVSYNC = 1;
527         break;
528
529     case salvageServer:
530         opts->canUseFSSYNC = 1;
531         break;
532
533     case volumeServer:
534         opts->nLargeVnodes = 0;
535         opts->nSmallVnodes = 0;
536
537         opts->canScheduleSalvage = 1;
538         opts->canUseFSSYNC = 1;
539         break;
540
541     default:
542         /* noop */
543         break;
544     }
545 }
546
547 int
548 VInitVolumePackage2(ProgramType pt, VolumePackageOptions * opts)
549 {
550     int errors = 0;             /* Number of errors while finding vice partitions. */
551
552     programType = pt;
553     vol_opts = *opts;
554
555     memset(&VStats, 0, sizeof(VStats));
556     VStats.hdr_cache_size = 200;
557
558     VInitPartitionPackage();
559     VInitVolumeHash();
560 #ifdef AFS_DEMAND_ATTACH_FS
561     if (programType == fileServer) {
562         VInitVLRU();
563     } else {
564         VLRU_SetOptions(VLRU_SET_ENABLED, 0);
565     }
566     assert(pthread_key_create(&VThread_key, NULL) == 0);
567 #endif
568
569 #ifdef AFS_PTHREAD_ENV
570     assert(pthread_mutex_init(&vol_glock_mutex, NULL) == 0);
571     assert(pthread_mutex_init(&vol_trans_mutex, NULL) == 0);
572     assert(pthread_cond_init(&vol_put_volume_cond, NULL) == 0);
573     assert(pthread_cond_init(&vol_sleep_cond, NULL) == 0);
574     assert(pthread_cond_init(&vol_init_attach_cond, NULL) == 0);
575 #else /* AFS_PTHREAD_ENV */
576     IOMGR_Initialize();
577 #endif /* AFS_PTHREAD_ENV */
578     Lock_Init(&vol_listLock);
579
580     srandom(time(0));           /* For VGetVolumeInfo */
581
582 #ifdef AFS_DEMAND_ATTACH_FS
583     assert(pthread_mutex_init(&vol_salvsync_mutex, NULL) == 0);
584 #endif /* AFS_DEMAND_ATTACH_FS */
585
586     /* Ok, we have done enough initialization that fileserver can 
587      * start accepting calls, even though the volumes may not be 
588      * available just yet.
589      */
590     VInit = 1;
591
592 #if defined(AFS_DEMAND_ATTACH_FS) && defined(SALVSYNC_BUILD_SERVER)
593     if (programType == salvageServer) {
594         SALVSYNC_salvInit();
595     }
596 #endif /* AFS_DEMAND_ATTACH_FS */
597 #ifdef FSSYNC_BUILD_SERVER
598     if (programType == fileServer) {
599         FSYNC_fsInit();
600     }
601 #endif
602 #if defined(AFS_DEMAND_ATTACH_FS) && defined(SALVSYNC_BUILD_CLIENT)
603     if (VCanUseSALVSYNC()) {
604         /* establish a connection to the salvager at this point */
605         assert(VConnectSALV() != 0);
606     }
607 #endif /* AFS_DEMAND_ATTACH_FS */
608
609     if (opts->volcache > VStats.hdr_cache_size)
610         VStats.hdr_cache_size = opts->volcache;
611     VInitVolumeHeaderCache(VStats.hdr_cache_size);
612
613     VInitVnodes(vLarge, opts->nLargeVnodes);
614     VInitVnodes(vSmall, opts->nSmallVnodes);
615
616
617     errors = VAttachPartitions();
618     if (errors)
619         return -1;
620
621     if (programType != fileServer) {
622         errors = VInitAttachVolumes(programType);
623         if (errors) {
624             return -1;
625         }
626     }
627
628 #ifdef FSSYNC_BUILD_CLIENT
629     if (VCanUseFSSYNC()) {
630         if (!VConnectFS()) {
631 #ifdef AFS_DEMAND_ATTACH_FS
632             if (programType == salvageServer) {
633                 Log("Unable to connect to file server; aborted\n");
634                 exit(1);
635             }
636 #endif /* AFS_DEMAND_ATTACH_FS */
637             Log("Unable to connect to file server; will retry at need\n");
638         }
639     }
640 #endif /* FSSYNC_BUILD_CLIENT */
641     return 0;
642 }
643
644
645 #if !defined(AFS_PTHREAD_ENV)
646 /**
647  * Attach volumes in vice partitions
648  *
649  * @param[in]  pt         calling program type
650  *
651  * @return 0
652  * @note This is the original, non-threaded version of attach parititions.
653  *
654  * @post VInit state is 2
655  */
656 int
657 VInitAttachVolumes(ProgramType pt)
658 {
659     assert(VInit==1);
660     if (pt == fileServer) {
661         struct DiskPartition64 *diskP;
662         /* Attach all the volumes in this partition */
663         for (diskP = DiskPartitionList; diskP; diskP = diskP->next) {
664             int nAttached = 0, nUnattached = 0;
665             assert(VAttachVolumesByPartition(diskP, &nAttached, &nUnattached) == 0);
666         }
667     }
668     VOL_LOCK;
669     VInit = 2;                  /* Initialized, and all volumes have been attached */
670     LWP_NoYieldSignal(VInitAttachVolumes);
671     VOL_UNLOCK;
672     return 0;
673 }
674 #endif /* !AFS_PTHREAD_ENV */
675
676 #if defined(AFS_PTHREAD_ENV) && !defined(AFS_DEMAND_ATTACH_FS)
677 /**
678  * Attach volumes in vice partitions
679  *
680  * @param[in]  pt         calling program type
681  *
682  * @return 0
683  * @note Threaded version of attach parititions.
684  *
685  * @post VInit state is 2
686  */
687 int
688 VInitAttachVolumes(ProgramType pt)
689 {
690     assert(VInit==1);
691     if (pt == fileServer) {
692         struct DiskPartition64 *diskP;
693         struct vinitvolumepackage_thread_t params;
694         struct diskpartition_queue_t * dpq;
695         int i, threads, parts;
696         pthread_t tid;
697         pthread_attr_t attrs;
698
699         assert(pthread_cond_init(&params.thread_done_cv,NULL) == 0);
700         queue_Init(&params);
701         params.n_threads_complete = 0;
702
703         /* create partition work queue */
704         for (parts=0, diskP = DiskPartitionList; diskP; diskP = diskP->next, parts++) {
705             dpq = (diskpartition_queue_t *) malloc(sizeof(struct diskpartition_queue_t));
706             assert(dpq != NULL);
707             dpq->diskP = diskP;
708             queue_Append(&params,dpq);
709         }
710
711         threads = MIN(parts, vol_attach_threads);
712
713         if (threads > 1) {
714             /* spawn off a bunch of initialization threads */
715             assert(pthread_attr_init(&attrs) == 0);
716             assert(pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED) == 0);
717
718             Log("VInitVolumePackage: beginning parallel fileserver startup\n");
719             Log("VInitVolumePackage: using %d threads to attach volumes on %d partitions\n",
720                 threads, parts);
721
722             VOL_LOCK;
723             for (i=0; i < threads; i++) {
724                 AFS_SIGSET_DECL;
725                 AFS_SIGSET_CLEAR();
726                 assert(pthread_create
727                        (&tid, &attrs, &VInitVolumePackageThread,
728                         &params) == 0);
729                 AFS_SIGSET_RESTORE();
730             }
731
732             while(params.n_threads_complete < threads) {
733                 VOL_CV_WAIT(&params.thread_done_cv);
734             }
735             VOL_UNLOCK;
736
737             assert(pthread_attr_destroy(&attrs) == 0);
738         } else {
739             /* if we're only going to run one init thread, don't bother creating
740              * another LWP */
741             Log("VInitVolumePackage: beginning single-threaded fileserver startup\n");
742             Log("VInitVolumePackage: using 1 thread to attach volumes on %d partition(s)\n",
743                 parts);
744
745             VInitVolumePackageThread(&params);
746         }
747
748         assert(pthread_cond_destroy(&params.thread_done_cv) == 0);
749     }
750     VOL_LOCK;
751     VInit = 2;                  /* Initialized, and all volumes have been attached */
752     assert(pthread_cond_broadcast(&vol_init_attach_cond) == 0);
753     VOL_UNLOCK;
754     return 0;
755 }
756
757 static void *
758 VInitVolumePackageThread(void * args) {
759
760     struct DiskPartition64 *diskP;
761     struct vinitvolumepackage_thread_t * params;
762     struct diskpartition_queue_t * dpq;
763
764     params = (vinitvolumepackage_thread_t *) args;
765
766
767     VOL_LOCK;
768     /* Attach all the volumes in this partition */
769     while (queue_IsNotEmpty(params)) {
770         int nAttached = 0, nUnattached = 0;
771
772         if (vinit_attach_abort) {
773             Log("Aborting initialization\n");
774             goto done;
775         }
776
777         dpq = queue_First(params,diskpartition_queue_t);
778         queue_Remove(dpq);
779         VOL_UNLOCK;
780         diskP = dpq->diskP;
781         free(dpq);
782
783         assert(VAttachVolumesByPartition(diskP, &nAttached, &nUnattached) == 0);
784
785         VOL_LOCK;
786     }
787
788 done:
789     params->n_threads_complete++;
790     pthread_cond_signal(&params->thread_done_cv);
791     VOL_UNLOCK;
792     return NULL;
793 }
794 #endif /* AFS_PTHREAD_ENV && !AFS_DEMAND_ATTACH_FS */
795
796 #if defined(AFS_DEMAND_ATTACH_FS)
797 /**
798  * Attach volumes in vice partitions
799  *
800  * @param[in]  pt         calling program type
801  *
802  * @return 0
803  * @note Threaded version of attach partitions.
804  *
805  * @post VInit state is 2
806  */
807 int
808 VInitAttachVolumes(ProgramType pt)
809 {
810     assert(VInit==1);
811     if (pt == fileServer) {
812
813         struct DiskPartition64 *diskP;
814         struct partition_queue pq;
815         struct volume_init_queue vq;
816
817         int i, threads, parts;
818         pthread_t tid;
819         pthread_attr_t attrs;
820
821         /* create partition work queue */
822         queue_Init(&pq);
823         assert(pthread_cond_init(&(pq.cv), NULL) == 0);
824         assert(pthread_mutex_init(&(pq.mutex), NULL) == 0);
825         for (parts = 0, diskP = DiskPartitionList; diskP; diskP = diskP->next, parts++) {
826             struct diskpartition_queue_t *dp;
827             dp = (struct diskpartition_queue_t*)malloc(sizeof(struct diskpartition_queue_t));
828             assert(dp != NULL);
829             dp->diskP = diskP;
830             queue_Append(&pq, dp);
831         }
832
833         /* number of worker threads; at least one, not to exceed the number of partitions */
834         threads = MIN(parts, vol_attach_threads);
835
836         /* create volume work queue */
837         queue_Init(&vq);
838         assert(pthread_cond_init(&(vq.cv), NULL) == 0);
839         assert(pthread_mutex_init(&(vq.mutex), NULL) == 0);
840
841         assert(pthread_attr_init(&attrs) == 0);
842         assert(pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED) == 0);
843
844         Log("VInitVolumePackage: beginning parallel fileserver startup\n");
845         Log("VInitVolumePackage: using %d threads to pre-attach volumes on %d partitions\n",
846                 threads, parts);
847
848         /* create threads to scan disk partitions. */
849         for (i=0; i < threads; i++) {
850             struct vinitvolumepackage_thread_param *params;
851             AFS_SIGSET_DECL;
852
853             params = (struct vinitvolumepackage_thread_param *)malloc(sizeof(struct vinitvolumepackage_thread_param));
854             assert(params);
855             params->pq = &pq;
856             params->vq = &vq;
857             params->nthreads = threads;
858             params->thread = i+1;
859
860             AFS_SIGSET_CLEAR();
861             assert(pthread_create (&tid, &attrs, &VInitVolumePackageThread, (void*)params) == 0);
862             AFS_SIGSET_RESTORE();
863         }
864
865         VInitPreAttachVolumes(threads, &vq);
866
867         assert(pthread_attr_destroy(&attrs) == 0);
868         assert(pthread_cond_destroy(&pq.cv) == 0);
869         assert(pthread_mutex_destroy(&pq.mutex) == 0);
870         assert(pthread_cond_destroy(&vq.cv) == 0);
871         assert(pthread_mutex_destroy(&vq.mutex) == 0);
872     }
873
874     VOL_LOCK;
875     VInit = 2;                  /* Initialized, and all volumes have been attached */
876     assert(pthread_cond_broadcast(&vol_init_attach_cond) == 0);
877     VOL_UNLOCK;
878
879     return 0;
880 }
881
882 /**
883  * Volume package initialization worker thread. Scan partitions for volume
884  * header files. Gather batches of volume ids and dispatch them to
885  * the main thread to be preattached.  The volume preattachement is done
886  * in the main thread to avoid global volume lock contention.
887  */
888 static void *
889 VInitVolumePackageThread(void *args)
890 {
891     struct vinitvolumepackage_thread_param *params;
892     struct DiskPartition64 *partition;
893     struct partition_queue *pq;
894     struct volume_init_queue *vq;
895     struct volume_init_batch *vb;
896
897     assert(args);
898     params = (struct vinitvolumepackage_thread_param *)args;
899     pq = params->pq;
900     vq = params->vq;
901     assert(pq);
902     assert(vq);
903
904     vb = (struct volume_init_batch*)malloc(sizeof(struct volume_init_batch));
905     assert(vb);
906     vb->thread = params->thread;
907     vb->last = 0;
908     vb->size = 0;
909
910     Log("Scanning partitions on thread %d of %d\n", params->thread, params->nthreads);
911     while((partition = VInitNextPartition(pq))) {
912         DIR *dirp;
913         VolId vid;
914
915         Log("Partition %s: pre-attaching volumes\n", partition->name);
916         dirp = opendir(VPartitionPath(partition));
917         if (!dirp) {
918             Log("opendir on Partition %s failed, errno=%d!\n", partition->name, errno);
919             continue;
920         }
921         while ((vid = VInitNextVolumeId(dirp))) {
922             Volume *vp = (Volume*)malloc(sizeof(Volume));
923             assert(vp);
924             memset(vp, 0, sizeof(Volume));
925             vp->device = partition->device;
926             vp->partition = partition;
927             vp->hashid = vid;
928             queue_Init(&vp->vnode_list);
929             assert(pthread_cond_init(&V_attachCV(vp), NULL) == 0);
930
931             vb->batch[vb->size++] = vp;
932             if (vb->size == VINIT_BATCH_MAX_SIZE) {
933                 assert(pthread_mutex_lock(&vq->mutex) == 0);
934                 queue_Append(vq, vb);
935                 assert(pthread_cond_broadcast(&vq->cv) == 0);
936                 assert(pthread_mutex_unlock(&vq->mutex) == 0);
937
938                 vb = (struct volume_init_batch*)malloc(sizeof(struct volume_init_batch));
939                 assert(vb);
940                 vb->thread = params->thread;
941                 vb->size = 0;
942                 vb->last = 0;
943             }
944         }
945         closedir(dirp);
946     }
947
948     vb->last = 1;
949     assert(pthread_mutex_lock(&vq->mutex) == 0);
950     queue_Append(vq, vb);
951     assert(pthread_cond_broadcast(&vq->cv) == 0);
952     assert(pthread_mutex_unlock(&vq->mutex) == 0);
953
954     Log("Partition scan thread %d of %d ended\n", params->thread, params->nthreads);
955     free(params);
956     return NULL;
957 }
958
959 /**
960  * Read next element from the pre-populated partition list.
961  */
962 static struct DiskPartition64*
963 VInitNextPartition(struct partition_queue *pq)
964 {
965     struct DiskPartition64 *partition;
966     struct diskpartition_queue_t *dp; /* queue element */
967
968     if (vinit_attach_abort) {
969         Log("Aborting volume preattach thread.\n");
970         return NULL;
971     }
972
973     /* get next partition to scan */
974     assert(pthread_mutex_lock(&pq->mutex) == 0);
975     if (queue_IsEmpty(pq)) {
976         assert(pthread_mutex_unlock(&pq->mutex) == 0);
977         return NULL;
978     }
979     dp = queue_First(pq, diskpartition_queue_t);
980     queue_Remove(dp);
981     assert(pthread_mutex_unlock(&pq->mutex) == 0);
982
983     assert(dp);
984     assert(dp->diskP);
985
986     partition = dp->diskP;
987     free(dp);
988     return partition;
989 }
990
991 /**
992  * Find next volume id on the partition.
993  */
994 static VolId
995 VInitNextVolumeId(DIR *dirp)
996 {
997     struct dirent *d;
998     VolId vid = 0;
999     char *ext;
1000
1001     while((d = readdir(dirp))) {
1002         if (vinit_attach_abort) {
1003             Log("Aborting volume preattach thread.\n");
1004             break;
1005         }
1006         ext = strrchr(d->d_name, '.');
1007         if (d->d_name[0] == 'V' && ext && strcmp(ext, VHDREXT) == 0) {
1008             vid = VolumeNumber(d->d_name);
1009             if (vid) {
1010                break;
1011             }
1012             Log("Warning: bogus volume header file: %s\n", d->d_name);
1013         }
1014     }
1015     return vid;
1016 }
1017
1018 /**
1019  * Preattach volumes in batches to avoid lock contention.
1020  */
1021 static int
1022 VInitPreAttachVolumes(int nthreads, struct volume_init_queue *vq)
1023 {
1024     struct volume_init_batch *vb;
1025     int i;
1026
1027     while (nthreads) {
1028         /* dequeue next volume */
1029         pthread_mutex_lock(&vq->mutex);
1030         if (queue_IsEmpty(vq)) {
1031             pthread_cond_wait(&vq->cv, &vq->mutex);
1032         }
1033         vb = queue_First(vq, volume_init_batch);
1034         queue_Remove(vb);
1035         pthread_mutex_unlock(&vq->mutex);
1036
1037         if (vb->size) {
1038             VOL_LOCK;
1039             for (i = 0; i<vb->size; i++) {
1040                 Volume *vp;
1041                 Volume *dup;
1042                 Error ec = 0;
1043
1044                 vp = vb->batch[i];
1045                 dup = VLookupVolume_r(&ec, vp->hashid, NULL);
1046                 if (ec) {
1047                     Log("Error looking up volume, code=%d\n", ec);
1048                 }
1049                 else if (dup) {
1050                     Log("Warning: Duplicate volume id %d detected.\n", vp->hashid);
1051                 }
1052                 else {
1053                     /* put pre-attached volume onto the hash table
1054                      * and bring it up to the pre-attached state */
1055                     AddVolumeToHashTable(vp, vp->hashid);
1056                     AddVolumeToVByPList_r(vp);
1057                     VLRU_Init_Node_r(vp);
1058                     VChangeState_r(vp, VOL_STATE_PREATTACHED);
1059                 }
1060             }
1061             VOL_UNLOCK;
1062         }
1063
1064         if (vb->last) {
1065             nthreads--;
1066         }
1067         free(vb);
1068     }
1069     return 0;
1070 }
1071 #endif /* AFS_DEMAND_ATTACH_FS */
1072
1073 #if !defined(AFS_DEMAND_ATTACH_FS)
1074 /*
1075  * attach all volumes on a given disk partition
1076  */
1077 static int
1078 VAttachVolumesByPartition(struct DiskPartition64 *diskP, int * nAttached, int * nUnattached)
1079 {
1080   DIR * dirp;
1081   struct dirent * dp;
1082   int ret = 0;
1083
1084   Log("Partition %s: attaching volumes\n", diskP->name);
1085   dirp = opendir(VPartitionPath(diskP));
1086   if (!dirp) {
1087     Log("opendir on Partition %s failed!\n", diskP->name);
1088     return 1;
1089   }
1090
1091   while ((dp = readdir(dirp))) {
1092     char *p;
1093     p = strrchr(dp->d_name, '.');
1094
1095     if (vinit_attach_abort) {
1096       Log("Partition %s: abort attach volumes\n", diskP->name);
1097       goto done;
1098     }
1099
1100     if (p != NULL && strcmp(p, VHDREXT) == 0) {
1101       Error error;
1102       Volume *vp;
1103       vp = VAttachVolumeByName(&error, diskP->name, dp->d_name,
1104                                V_VOLUPD);
1105       (*(vp ? nAttached : nUnattached))++;
1106       if (error == VOFFLINE)
1107         Log("Volume %d stays offline (/vice/offline/%s exists)\n", VolumeNumber(dp->d_name), dp->d_name);
1108       else if (LogLevel >= 5) {
1109         Log("Partition %s: attached volume %d (%s)\n",
1110             diskP->name, VolumeNumber(dp->d_name),
1111             dp->d_name);
1112       }
1113       if (vp) {
1114         VPutVolume(vp);
1115       }
1116     }
1117   }
1118
1119   Log("Partition %s: attached %d volumes; %d volumes not attached\n", diskP->name, *nAttached, *nUnattached);
1120 done:
1121   closedir(dirp);
1122   return ret;
1123 }
1124 #endif /* !AFS_DEMAND_ATTACH_FS */
1125
1126 /***************************************************/
1127 /* Shutdown routines                               */
1128 /***************************************************/
1129
1130 /*
1131  * demand attach fs
1132  * highly multithreaded volume package shutdown
1133  *
1134  * with the demand attach fileserver extensions,
1135  * VShutdown has been modified to be multithreaded.
1136  * In order to achieve optimal use of many threads,
1137  * the shutdown code involves one control thread and
1138  * n shutdown worker threads.  The control thread
1139  * periodically examines the number of volumes available
1140  * for shutdown on each partition, and produces a worker
1141  * thread allocation schedule.  The idea is to eliminate
1142  * redundant scheduling computation on the workers by
1143  * having a single master scheduler.
1144  *
1145  * The scheduler's objectives are:
1146  * (1) fairness
1147  *   each partition with volumes remaining gets allocated
1148  *   at least 1 thread (assuming sufficient threads)
1149  * (2) performance
1150  *   threads are allocated proportional to the number of
1151  *   volumes remaining to be offlined.  This ensures that
1152  *   the OS I/O scheduler has many requests to elevator
1153  *   seek on partitions that will (presumably) take the
1154  *   longest amount of time (from now) to finish shutdown
1155  * (3) keep threads busy
1156  *   when there are extra threads, they are assigned to
1157  *   partitions using a simple round-robin algorithm
1158  *
1159  * In the future, we may wish to add the ability to adapt
1160  * to the relative performance patterns of each disk
1161  * partition.
1162  *
1163  *
1164  * demand attach fs
1165  * multi-step shutdown process
1166  *
1167  * demand attach shutdown is a four-step process. Each
1168  * shutdown "pass" shuts down increasingly more difficult
1169  * volumes.  The main purpose is to achieve better cache
1170  * utilization during shutdown.
1171  *
1172  * pass 0
1173  *   shutdown volumes in the unattached, pre-attached
1174  *   and error states
1175  * pass 1
1176  *   shutdown attached volumes with cached volume headers
1177  * pass 2
1178  *   shutdown all volumes in non-exclusive states
1179  * pass 3
1180  *   shutdown all remaining volumes
1181  */
1182
1183 #ifdef AFS_DEMAND_ATTACH_FS
1184
1185 void
1186 VShutdown_r(void)
1187 {
1188     int i;
1189     struct DiskPartition64 * diskP;
1190     struct diskpartition_queue_t * dpq;
1191     vshutdown_thread_t params;
1192     pthread_t tid;
1193     pthread_attr_t attrs;
1194
1195     memset(&params, 0, sizeof(vshutdown_thread_t));
1196
1197     if (VInit < 2) {
1198         Log("VShutdown:  aborting attach volumes\n");
1199         vinit_attach_abort = 1;
1200         VOL_CV_WAIT(&vol_init_attach_cond);
1201     }
1202
1203     for (params.n_parts=0, diskP = DiskPartitionList;
1204          diskP; diskP = diskP->next, params.n_parts++);
1205
1206     Log("VShutdown:  shutting down on-line volumes on %d partition%s...\n", 
1207         params.n_parts, params.n_parts > 1 ? "s" : "");
1208
1209     if (vol_attach_threads > 1) {
1210         /* prepare for parallel shutdown */
1211         params.n_threads = vol_attach_threads;
1212         assert(pthread_mutex_init(&params.lock, NULL) == 0);
1213         assert(pthread_cond_init(&params.cv, NULL) == 0);
1214         assert(pthread_cond_init(&params.master_cv, NULL) == 0);
1215         assert(pthread_attr_init(&attrs) == 0);
1216         assert(pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED) == 0);
1217         queue_Init(&params);
1218
1219         /* setup the basic partition information structures for
1220          * parallel shutdown */
1221         for (diskP = DiskPartitionList; diskP; diskP = diskP->next) {
1222             /* XXX debug */
1223             struct rx_queue * qp, * nqp;
1224             Volume * vp;
1225             int count = 0;
1226
1227             VVByPListWait_r(diskP);
1228             VVByPListBeginExclusive_r(diskP);
1229
1230             /* XXX debug */
1231             for (queue_Scan(&diskP->vol_list, qp, nqp, rx_queue)) {
1232                 vp = (Volume *)((char *)qp - offsetof(Volume, vol_list));
1233                 if (vp->header)
1234                     count++;
1235             }
1236             Log("VShutdown: partition %s has %d volumes with attached headers\n",
1237                 VPartitionPath(diskP), count);
1238                 
1239
1240             /* build up the pass 0 shutdown work queue */
1241             dpq = (struct diskpartition_queue_t *) malloc(sizeof(struct diskpartition_queue_t));
1242             assert(dpq != NULL);
1243             dpq->diskP = diskP;
1244             queue_Prepend(&params, dpq);
1245
1246             params.part_pass_head[diskP->index] = queue_First(&diskP->vol_list, rx_queue);
1247         }
1248
1249         Log("VShutdown:  beginning parallel fileserver shutdown\n");
1250         Log("VShutdown:  using %d threads to offline volumes on %d partition%s\n",
1251             vol_attach_threads, params.n_parts, params.n_parts > 1 ? "s" : "" );
1252
1253         /* do pass 0 shutdown */
1254         assert(pthread_mutex_lock(&params.lock) == 0);
1255         for (i=0; i < params.n_threads; i++) {
1256             assert(pthread_create
1257                    (&tid, &attrs, &VShutdownThread,
1258                     &params) == 0);
1259         }
1260         
1261         /* wait for all the pass 0 shutdowns to complete */
1262         while (params.n_threads_complete < params.n_threads) {
1263             assert(pthread_cond_wait(&params.master_cv, &params.lock) == 0);
1264         }
1265         params.n_threads_complete = 0;
1266         params.pass = 1;
1267         assert(pthread_cond_broadcast(&params.cv) == 0);
1268         assert(pthread_mutex_unlock(&params.lock) == 0);
1269
1270         Log("VShutdown:  pass 0 completed using the 1 thread per partition algorithm\n");
1271         Log("VShutdown:  starting passes 1 through 3 using finely-granular mp-fast algorithm\n");
1272
1273         /* run the parallel shutdown scheduler. it will drop the glock internally */
1274         ShutdownController(&params);
1275         
1276         /* wait for all the workers to finish pass 3 and terminate */
1277         while (params.pass < 4) {
1278             VOL_CV_WAIT(&params.cv);
1279         }
1280         
1281         assert(pthread_attr_destroy(&attrs) == 0);
1282         assert(pthread_cond_destroy(&params.cv) == 0);
1283         assert(pthread_cond_destroy(&params.master_cv) == 0);
1284         assert(pthread_mutex_destroy(&params.lock) == 0);
1285
1286         /* drop the VByPList exclusive reservations */
1287         for (diskP = DiskPartitionList; diskP; diskP = diskP->next) {
1288             VVByPListEndExclusive_r(diskP);
1289             Log("VShutdown:  %s stats : (pass[0]=%d, pass[1]=%d, pass[2]=%d, pass[3]=%d)\n",
1290                 VPartitionPath(diskP),
1291                 params.stats[0][diskP->index],
1292                 params.stats[1][diskP->index],
1293                 params.stats[2][diskP->index],
1294                 params.stats[3][diskP->index]);
1295         }
1296
1297         Log("VShutdown:  shutdown finished using %d threads\n", params.n_threads);
1298     } else {
1299         /* if we're only going to run one shutdown thread, don't bother creating
1300          * another LWP */
1301         Log("VShutdown:  beginning single-threaded fileserver shutdown\n");
1302
1303         for (diskP = DiskPartitionList; diskP; diskP = diskP->next) {
1304             VShutdownByPartition_r(diskP);
1305         }
1306     }
1307
1308     Log("VShutdown:  complete.\n");
1309 }
1310
1311 #else /* AFS_DEMAND_ATTACH_FS */
1312
1313 void
1314 VShutdown_r(void)
1315 {
1316     int i;
1317     register Volume *vp, *np;
1318     register afs_int32 code;
1319
1320     if (VInit < 2) {
1321         Log("VShutdown:  aborting attach volumes\n");
1322         vinit_attach_abort = 1;
1323 #ifdef AFS_PTHREAD_ENV
1324         VOL_CV_WAIT(&vol_init_attach_cond);
1325 #else
1326         LWP_WaitProcess(VInitAttachVolumes);
1327 #endif /* AFS_PTHREAD_ENV */
1328     }
1329
1330     Log("VShutdown:  shutting down on-line volumes...\n");
1331     for (i = 0; i < VolumeHashTable.Size; i++) {
1332         /* try to hold first volume in the hash table */
1333         for (queue_Scan(&VolumeHashTable.Table[i],vp,np,Volume)) {
1334             code = VHold_r(vp);
1335             if (code == 0) {
1336                 if (LogLevel >= 5)
1337                     Log("VShutdown:  Attempting to take volume %u offline.\n",
1338                         vp->hashid);
1339                 
1340                 /* next, take the volume offline (drops reference count) */
1341                 VOffline_r(vp, "File server was shut down");
1342             }
1343         }
1344     }
1345     Log("VShutdown:  complete.\n");
1346 }
1347 #endif /* AFS_DEMAND_ATTACH_FS */
1348
1349
1350 void
1351 VShutdown(void)
1352 {
1353     assert(VInit>0);
1354     VOL_LOCK;
1355     VShutdown_r();
1356     VOL_UNLOCK;
1357 }
1358
1359 /**
1360  * stop new activity (e.g. SALVSYNC) from occurring
1361  *
1362  * Use this to make the volume package less busy; for example, during
1363  * shutdown. This doesn't actually shutdown/detach anything in the
1364  * volume package, but prevents certain processes from ocurring. For
1365  * example, preventing new SALVSYNC communication in DAFS. In theory, we
1366  * could also use this to prevent new volume attachment, or prevent
1367  * other programs from checking out volumes, etc.
1368  */
1369 void
1370 VSetTranquil(void)
1371 {
1372 #ifdef AFS_DEMAND_ATTACH_FS
1373     /* make sure we don't try to contact the salvageserver, since it may
1374      * not be around anymore */
1375     vol_disallow_salvsync = 1;
1376 #endif
1377 }
1378
1379 #ifdef AFS_DEMAND_ATTACH_FS
1380 /*
1381  * demand attach fs
1382  * shutdown control thread
1383  */
1384 static void
1385 ShutdownController(vshutdown_thread_t * params)
1386 {
1387     /* XXX debug */
1388     struct DiskPartition64 * diskP;
1389     Device id;
1390     vshutdown_thread_t shadow;
1391
1392     ShutdownCreateSchedule(params);
1393
1394     while ((params->pass < 4) &&
1395            (params->n_threads_complete < params->n_threads)) {
1396         /* recompute schedule once per second */
1397
1398         memcpy(&shadow, params, sizeof(vshutdown_thread_t));
1399
1400         VOL_UNLOCK;
1401         /* XXX debug */
1402         Log("ShutdownController:  schedule version=%d, vol_remaining=%d, pass=%d\n",
1403             shadow.schedule_version, shadow.vol_remaining, shadow.pass);
1404         Log("ShutdownController:  n_threads_complete=%d, n_parts_done_pass=%d\n",
1405             shadow.n_threads_complete, shadow.n_parts_done_pass);
1406         for (diskP = DiskPartitionList; diskP; diskP=diskP->next) {
1407             id = diskP->index;
1408             Log("ShutdownController:  part[%d] : (len=%d, thread_target=%d, done_pass=%d, pass_head=%p)\n",
1409                 id, 
1410                 diskP->vol_list.len,
1411                 shadow.part_thread_target[id], 
1412                 shadow.part_done_pass[id], 
1413                 shadow.part_pass_head[id]);
1414         }
1415
1416         sleep(1);
1417         VOL_LOCK;
1418
1419         ShutdownCreateSchedule(params);
1420     }
1421 }
1422
1423 /* create the shutdown thread work schedule.
1424  * this scheduler tries to implement fairness
1425  * by allocating at least 1 thread to each 
1426  * partition with volumes to be shutdown,
1427  * and then it attempts to allocate remaining
1428  * threads based upon the amount of work left
1429  */
1430 static void
1431 ShutdownCreateSchedule(vshutdown_thread_t * params)
1432 {
1433     struct DiskPartition64 * diskP;
1434     int sum, thr_workload, thr_left;
1435     int part_residue[VOLMAXPARTS+1];
1436     Device id;
1437
1438     /* compute the total number of outstanding volumes */
1439     sum = 0;
1440     for (diskP = DiskPartitionList; diskP; diskP = diskP->next) {
1441         sum += diskP->vol_list.len;
1442     }
1443     
1444     params->schedule_version++;
1445     params->vol_remaining = sum;
1446
1447     if (!sum)
1448         return;
1449
1450     /* compute average per-thread workload */
1451     thr_workload = sum / params->n_threads;
1452     if (sum % params->n_threads)
1453         thr_workload++;
1454
1455     thr_left = params->n_threads;
1456     memset(&part_residue, 0, sizeof(part_residue));
1457
1458     /* for fairness, give every partition with volumes remaining
1459      * at least one thread */
1460     for (diskP = DiskPartitionList; diskP && thr_left; diskP = diskP->next) {
1461         id = diskP->index;
1462         if (diskP->vol_list.len) {
1463             params->part_thread_target[id] = 1;
1464             thr_left--;
1465         } else {
1466             params->part_thread_target[id] = 0;
1467         }
1468     }
1469
1470     if (thr_left && thr_workload) {
1471         /* compute length-weighted workloads */
1472         int delta;
1473
1474         for (diskP = DiskPartitionList; diskP && thr_left; diskP = diskP->next) {
1475             id = diskP->index;
1476             delta = (diskP->vol_list.len / thr_workload) -
1477                 params->part_thread_target[id];
1478             if (delta < 0) {
1479                 continue;
1480             }
1481             if (delta < thr_left) {
1482                 params->part_thread_target[id] += delta;
1483                 thr_left -= delta;
1484             } else {
1485                 params->part_thread_target[id] += thr_left;
1486                 thr_left = 0;
1487                 break;
1488             }
1489         }
1490     }
1491
1492     if (thr_left) {
1493         /* try to assign any leftover threads to partitions that
1494          * had volume lengths closer to needing thread_target+1 */
1495         int max_residue, max_id = 0;
1496
1497         /* compute the residues */
1498         for (diskP = DiskPartitionList; diskP; diskP = diskP->next) {
1499             id = diskP->index;
1500             part_residue[id] = diskP->vol_list.len - 
1501                 (params->part_thread_target[id] * thr_workload);
1502         }
1503
1504         /* now try to allocate remaining threads to partitions with the
1505          * highest residues */
1506         while (thr_left) {
1507             max_residue = 0;
1508             for (diskP = DiskPartitionList; diskP; diskP = diskP->next) {
1509                 id = diskP->index;
1510                 if (part_residue[id] > max_residue) {
1511                     max_residue = part_residue[id];
1512                     max_id = id;
1513                 }
1514             }
1515
1516             if (!max_residue) {
1517                 break;
1518             }
1519
1520             params->part_thread_target[max_id]++;
1521             thr_left--;
1522             part_residue[max_id] = 0;
1523         }
1524     }
1525
1526     if (thr_left) {
1527         /* punt and give any remaining threads equally to each partition */
1528         int alloc;
1529         if (thr_left >= params->n_parts) {
1530             alloc = thr_left / params->n_parts;
1531             for (diskP = DiskPartitionList; diskP; diskP = diskP->next) {
1532                 id = diskP->index;
1533                 params->part_thread_target[id] += alloc;
1534                 thr_left -= alloc;
1535             }
1536         }
1537
1538         /* finish off the last of the threads */
1539         for (diskP = DiskPartitionList; thr_left && diskP; diskP = diskP->next) {
1540             id = diskP->index;
1541             params->part_thread_target[id]++;
1542             thr_left--;
1543         }
1544     }
1545 }
1546
1547 /* worker thread for parallel shutdown */
1548 static void *
1549 VShutdownThread(void * args)
1550 {
1551     vshutdown_thread_t * params;
1552     int found, pass, schedule_version_save, count;
1553     struct DiskPartition64 *diskP;
1554     struct diskpartition_queue_t * dpq;
1555     Device id;
1556
1557     params = (vshutdown_thread_t *) args;
1558
1559     /* acquire the shutdown pass 0 lock */
1560     assert(pthread_mutex_lock(&params->lock) == 0);
1561
1562     /* if there's still pass 0 work to be done,
1563      * get a work entry, and do a pass 0 shutdown */
1564     if (queue_IsNotEmpty(params)) {
1565         dpq = queue_First(params, diskpartition_queue_t);
1566         queue_Remove(dpq);
1567         assert(pthread_mutex_unlock(&params->lock) == 0);
1568         diskP = dpq->diskP;
1569         free(dpq);
1570         id = diskP->index;
1571
1572         count = 0;
1573         while (ShutdownVolumeWalk_r(diskP, 0, &params->part_pass_head[id]))
1574             count++;
1575         params->stats[0][diskP->index] = count;
1576         assert(pthread_mutex_lock(&params->lock) == 0);
1577     }
1578
1579     params->n_threads_complete++;
1580     if (params->n_threads_complete == params->n_threads) {
1581       /* notify control thread that all workers have completed pass 0 */
1582       assert(pthread_cond_signal(&params->master_cv) == 0);
1583     }
1584     while (params->pass == 0) {
1585       assert(pthread_cond_wait(&params->cv, &params->lock) == 0);
1586     }
1587
1588     /* switch locks */
1589     assert(pthread_mutex_unlock(&params->lock) == 0);
1590     VOL_LOCK;
1591
1592     pass = params->pass;
1593     assert(pass > 0);
1594
1595     /* now escalate through the more complicated shutdowns */
1596     while (pass <= 3) {
1597         schedule_version_save = params->schedule_version;
1598         found = 0;
1599         /* find a disk partition to work on */
1600         for (diskP = DiskPartitionList; diskP; diskP = diskP->next) {
1601             id = diskP->index;
1602             if (params->part_thread_target[id] && !params->part_done_pass[id]) {
1603                 params->part_thread_target[id]--;
1604                 found = 1;
1605                 break;
1606             }
1607         }
1608         
1609         if (!found) {
1610             /* hmm. for some reason the controller thread couldn't find anything for 
1611              * us to do. let's see if there's anything we can do */
1612             for (diskP = DiskPartitionList; diskP; diskP = diskP->next) {
1613                 id = diskP->index;
1614                 if (diskP->vol_list.len && !params->part_done_pass[id]) {
1615                     found = 1;
1616                     break;
1617                 } else if (!params->part_done_pass[id]) {
1618                     params->part_done_pass[id] = 1;
1619                     params->n_parts_done_pass++;
1620                     if (pass == 3) {
1621                         Log("VShutdown:  done shutting down volumes on partition %s.\n",
1622                             VPartitionPath(diskP));
1623                     }
1624                 }
1625             }
1626         }
1627         
1628         /* do work on this partition until either the controller
1629          * creates a new schedule, or we run out of things to do
1630          * on this partition */
1631         if (found) {
1632             count = 0;
1633             while (!params->part_done_pass[id] &&
1634                    (schedule_version_save == params->schedule_version)) {
1635                 /* ShutdownVolumeWalk_r will drop the glock internally */
1636                 if (!ShutdownVolumeWalk_r(diskP, pass, &params->part_pass_head[id])) {
1637                     if (!params->part_done_pass[id]) {
1638                         params->part_done_pass[id] = 1;
1639                         params->n_parts_done_pass++;
1640                         if (pass == 3) {
1641                             Log("VShutdown:  done shutting down volumes on partition %s.\n",
1642                                 VPartitionPath(diskP));
1643                         }
1644                     }
1645                     break;
1646                 }
1647                 count++;
1648             }
1649
1650             params->stats[pass][id] += count;
1651         } else {
1652             /* ok, everyone is done this pass, proceed */
1653
1654             /* barrier lock */
1655             params->n_threads_complete++;
1656             while (params->pass == pass) {
1657                 if (params->n_threads_complete == params->n_threads) {
1658                     /* we are the last thread to complete, so we will
1659                      * reinitialize worker pool state for the next pass */
1660                     params->n_threads_complete = 0;
1661                     params->n_parts_done_pass = 0;
1662                     params->pass++;
1663                     for (diskP = DiskPartitionList; diskP; diskP = diskP->next) {
1664                         id = diskP->index;
1665                         params->part_done_pass[id] = 0;
1666                         params->part_pass_head[id] = queue_First(&diskP->vol_list, rx_queue);
1667                     }
1668
1669                     /* compute a new thread schedule before releasing all the workers */
1670                     ShutdownCreateSchedule(params);
1671
1672                     /* wake up all the workers */
1673                     assert(pthread_cond_broadcast(&params->cv) == 0);
1674
1675                     VOL_UNLOCK;
1676                     Log("VShutdown:  pass %d completed using %d threads on %d partitions\n",
1677                         pass, params->n_threads, params->n_parts);
1678                     VOL_LOCK;
1679                 } else {
1680                     VOL_CV_WAIT(&params->cv);
1681                 }
1682             }
1683             pass = params->pass;
1684         }
1685         
1686         /* for fairness */
1687         VOL_UNLOCK;
1688         pthread_yield();
1689         VOL_LOCK;
1690     }
1691
1692     VOL_UNLOCK;
1693
1694     return NULL;
1695 }
1696
1697 /* shut down all volumes on a given disk partition 
1698  *
1699  * note that this function will not allow mp-fast
1700  * shutdown of a partition */
1701 int
1702 VShutdownByPartition_r(struct DiskPartition64 * dp)
1703 {
1704     int pass;
1705     int pass_stats[4];
1706     int total;
1707
1708     /* wait for other exclusive ops to finish */
1709     VVByPListWait_r(dp);
1710
1711     /* begin exclusive access */
1712     VVByPListBeginExclusive_r(dp);
1713
1714     /* pick the low-hanging fruit first,
1715      * then do the complicated ones last 
1716      * (has the advantage of keeping
1717      *  in-use volumes up until the bitter end) */
1718     for (pass = 0, total=0; pass < 4; pass++) {
1719         pass_stats[pass] = ShutdownVByPForPass_r(dp, pass);
1720         total += pass_stats[pass];
1721     }
1722
1723     /* end exclusive access */
1724     VVByPListEndExclusive_r(dp);
1725
1726     Log("VShutdownByPartition:  shut down %d volumes on %s (pass[0]=%d, pass[1]=%d, pass[2]=%d, pass[3]=%d)\n",
1727         total, VPartitionPath(dp), pass_stats[0], pass_stats[1], pass_stats[2], pass_stats[3]);
1728
1729     return 0;
1730 }
1731
1732 /* internal shutdown functionality
1733  *
1734  * for multi-pass shutdown:
1735  * 0 to only "shutdown" {pre,un}attached and error state volumes
1736  * 1 to also shutdown attached volumes w/ volume header loaded
1737  * 2 to also shutdown attached volumes w/o volume header loaded
1738  * 3 to also shutdown exclusive state volumes 
1739  *
1740  * caller MUST hold exclusive access on the hash chain
1741  * because we drop vol_glock_mutex internally
1742  * 
1743  * this function is reentrant for passes 1--3 
1744  * (e.g. multiple threads can cooperate to 
1745  *  shutdown a partition mp-fast)
1746  *
1747  * pass 0 is not scaleable because the volume state data is
1748  * synchronized by vol_glock mutex, and the locking overhead
1749  * is too high to drop the lock long enough to do linked list
1750  * traversal
1751  */
1752 static int
1753 ShutdownVByPForPass_r(struct DiskPartition64 * dp, int pass)
1754 {
1755     struct rx_queue * q = queue_First(&dp->vol_list, rx_queue);
1756     register int i = 0;
1757
1758     while (ShutdownVolumeWalk_r(dp, pass, &q))
1759         i++;
1760
1761     return i;
1762 }
1763
1764 /* conditionally shutdown one volume on partition dp
1765  * returns 1 if a volume was shutdown in this pass,
1766  * 0 otherwise */
1767 static int
1768 ShutdownVolumeWalk_r(struct DiskPartition64 * dp, int pass,
1769                      struct rx_queue ** idx)
1770 {
1771     struct rx_queue *qp, *nqp;
1772     Volume * vp;
1773
1774     qp = *idx;
1775
1776     for (queue_ScanFrom(&dp->vol_list, qp, qp, nqp, rx_queue)) {
1777         vp = (Volume *) (((char *)qp) - offsetof(Volume, vol_list));
1778         
1779         switch (pass) {
1780         case 0:
1781             if ((V_attachState(vp) != VOL_STATE_UNATTACHED) &&
1782                 (V_attachState(vp) != VOL_STATE_ERROR) &&
1783                 (V_attachState(vp) != VOL_STATE_PREATTACHED)) {
1784                 break;
1785             }
1786         case 1:
1787             if ((V_attachState(vp) == VOL_STATE_ATTACHED) &&
1788                 (vp->header == NULL)) {
1789                 break;
1790             }
1791         case 2:
1792             if (VIsExclusiveState(V_attachState(vp))) {
1793                 break;
1794             }
1795         case 3:
1796             *idx = nqp;
1797             DeleteVolumeFromVByPList_r(vp);
1798             VShutdownVolume_r(vp);
1799             vp = NULL;
1800             return 1;
1801         }
1802     }
1803
1804     return 0;
1805 }
1806
1807 /*
1808  * shutdown a specific volume
1809  */
1810 /* caller MUST NOT hold a heavyweight ref on vp */
1811 int
1812 VShutdownVolume_r(Volume * vp)
1813 {
1814     int code;
1815
1816     VCreateReservation_r(vp);
1817
1818     if (LogLevel >= 5) {
1819         Log("VShutdownVolume_r:  vid=%u, device=%d, state=%hu\n",
1820             vp->hashid, vp->partition->device, V_attachState(vp));
1821     }
1822
1823     /* wait for other blocking ops to finish */
1824     VWaitExclusiveState_r(vp);
1825
1826     assert(VIsValidState(V_attachState(vp)));
1827     
1828     switch(V_attachState(vp)) {
1829     case VOL_STATE_SALVAGING:
1830         /* Leave salvaging volumes alone. Any in-progress salvages will
1831          * continue working after viced shuts down. This is intentional.
1832          */
1833
1834     case VOL_STATE_PREATTACHED:
1835     case VOL_STATE_ERROR:
1836         VChangeState_r(vp, VOL_STATE_UNATTACHED);
1837     case VOL_STATE_UNATTACHED:
1838         break;
1839     case VOL_STATE_GOING_OFFLINE:
1840     case VOL_STATE_SHUTTING_DOWN:
1841     case VOL_STATE_ATTACHED:
1842         code = VHold_r(vp);
1843         if (!code) {
1844             if (LogLevel >= 5)
1845                 Log("VShutdown:  Attempting to take volume %u offline.\n",
1846                     vp->hashid);
1847
1848             /* take the volume offline (drops reference count) */
1849             VOffline_r(vp, "File server was shut down");
1850         }
1851         break;
1852     default:
1853         break;
1854     }
1855     
1856     VCancelReservation_r(vp);
1857     vp = NULL;
1858     return 0;
1859 }
1860 #endif /* AFS_DEMAND_ATTACH_FS */
1861
1862
1863 /***************************************************/
1864 /* Header I/O routines                             */
1865 /***************************************************/
1866
1867 /* open a descriptor for the inode (h),
1868  * read in an on-disk structure into buffer (to) of size (size),
1869  * verify versionstamp in structure has magic (magic) and
1870  * optionally verify version (version) if (version) is nonzero
1871  */
1872 static void
1873 ReadHeader(Error * ec, IHandle_t * h, char *to, int size, bit32 magic,
1874            bit32 version)
1875 {
1876     struct versionStamp *vsn;
1877     FdHandle_t *fdP;
1878
1879     *ec = 0;
1880     if (h == NULL) {
1881         *ec = VSALVAGE;
1882         return;
1883     }
1884
1885     fdP = IH_OPEN(h);
1886     if (fdP == NULL) {
1887         *ec = VSALVAGE;
1888         return;
1889     }
1890
1891     if (FDH_SEEK(fdP, 0, SEEK_SET) < 0) {
1892         *ec = VSALVAGE;
1893         FDH_REALLYCLOSE(fdP);
1894         return;
1895     }
1896     vsn = (struct versionStamp *)to;
1897     if (FDH_READ(fdP, to, size) != size || vsn->magic != magic) {
1898         *ec = VSALVAGE;
1899         FDH_REALLYCLOSE(fdP);
1900         return;
1901     }
1902     FDH_CLOSE(fdP);
1903
1904     /* Check is conditional, in case caller wants to inspect version himself */
1905     if (version && vsn->version != version) {
1906         *ec = VSALVAGE;
1907     }
1908 }
1909
1910 void
1911 WriteVolumeHeader_r(Error * ec, Volume * vp)
1912 {
1913     IHandle_t *h = V_diskDataHandle(vp);
1914     FdHandle_t *fdP;
1915
1916     *ec = 0;
1917
1918     fdP = IH_OPEN(h);
1919     if (fdP == NULL) {
1920         *ec = VSALVAGE;
1921         return;
1922     }
1923     if (FDH_SEEK(fdP, 0, SEEK_SET) < 0) {
1924         *ec = VSALVAGE;
1925         FDH_REALLYCLOSE(fdP);
1926         return;
1927     }
1928     if (FDH_WRITE(fdP, (char *)&V_disk(vp), sizeof(V_disk(vp)))
1929         != sizeof(V_disk(vp))) {
1930         *ec = VSALVAGE;
1931         FDH_REALLYCLOSE(fdP);
1932         return;
1933     }
1934     FDH_CLOSE(fdP);
1935 }
1936
1937 /* VolumeHeaderToDisk
1938  * Allows for storing 64 bit inode numbers in on-disk volume header
1939  * file.
1940  */
1941 /* convert in-memory representation of a volume header to the
1942  * on-disk representation of a volume header */
1943 void
1944 VolumeHeaderToDisk(VolumeDiskHeader_t * dh, VolumeHeader_t * h)
1945 {
1946
1947     memset(dh, 0, sizeof(VolumeDiskHeader_t));
1948     dh->stamp = h->stamp;
1949     dh->id = h->id;
1950     dh->parent = h->parent;
1951
1952 #ifdef AFS_64BIT_IOPS_ENV
1953     dh->volumeInfo_lo = (afs_int32) h->volumeInfo & 0xffffffff;
1954     dh->volumeInfo_hi = (afs_int32) (h->volumeInfo >> 32) & 0xffffffff;
1955     dh->smallVnodeIndex_lo = (afs_int32) h->smallVnodeIndex & 0xffffffff;
1956     dh->smallVnodeIndex_hi =
1957         (afs_int32) (h->smallVnodeIndex >> 32) & 0xffffffff;
1958     dh->largeVnodeIndex_lo = (afs_int32) h->largeVnodeIndex & 0xffffffff;
1959     dh->largeVnodeIndex_hi =
1960         (afs_int32) (h->largeVnodeIndex >> 32) & 0xffffffff;
1961     dh->linkTable_lo = (afs_int32) h->linkTable & 0xffffffff;
1962     dh->linkTable_hi = (afs_int32) (h->linkTable >> 32) & 0xffffffff;
1963 #else
1964     dh->volumeInfo_lo = h->volumeInfo;
1965     dh->smallVnodeIndex_lo = h->smallVnodeIndex;
1966     dh->largeVnodeIndex_lo = h->largeVnodeIndex;
1967     dh->linkTable_lo = h->linkTable;
1968 #endif
1969 }
1970
1971 /* DiskToVolumeHeader
1972  * Converts an on-disk representation of a volume header to
1973  * the in-memory representation of a volume header.
1974  *
1975  * Makes the assumption that AFS has *always* 
1976  * zero'd the volume header file so that high parts of inode
1977  * numbers are 0 in older (SGI EFS) volume header files.
1978  */
1979 void
1980 DiskToVolumeHeader(VolumeHeader_t * h, VolumeDiskHeader_t * dh)
1981 {
1982     memset(h, 0, sizeof(VolumeHeader_t));
1983     h->stamp = dh->stamp;
1984     h->id = dh->id;
1985     h->parent = dh->parent;
1986
1987 #ifdef AFS_64BIT_IOPS_ENV
1988     h->volumeInfo =
1989         (Inode) dh->volumeInfo_lo | ((Inode) dh->volumeInfo_hi << 32);
1990
1991     h->smallVnodeIndex =
1992         (Inode) dh->smallVnodeIndex_lo | ((Inode) dh->
1993                                           smallVnodeIndex_hi << 32);
1994
1995     h->largeVnodeIndex =
1996         (Inode) dh->largeVnodeIndex_lo | ((Inode) dh->
1997                                           largeVnodeIndex_hi << 32);
1998     h->linkTable =
1999         (Inode) dh->linkTable_lo | ((Inode) dh->linkTable_hi << 32);
2000 #else
2001     h->volumeInfo = dh->volumeInfo_lo;
2002     h->smallVnodeIndex = dh->smallVnodeIndex_lo;
2003     h->largeVnodeIndex = dh->largeVnodeIndex_lo;
2004     h->linkTable = dh->linkTable_lo;
2005 #endif
2006 }
2007
2008
2009 /***************************************************/
2010 /* Volume Attachment routines                      */
2011 /***************************************************/
2012
2013 #ifdef AFS_DEMAND_ATTACH_FS
2014 /**
2015  * pre-attach a volume given its path.
2016  *
2017  * @param[out] ec         outbound error code
2018  * @param[in]  partition  partition path string
2019  * @param[in]  name       volume id string
2020  *
2021  * @return volume object pointer
2022  *
2023  * @note A pre-attached volume will only have its partition
2024  *       and hashid fields initialized.  At first call to 
2025  *       VGetVolume, the volume will be fully attached.
2026  *
2027  */
2028 Volume *
2029 VPreAttachVolumeByName(Error * ec, char *partition, char *name)
2030 {
2031     Volume * vp;
2032     VOL_LOCK;
2033     vp = VPreAttachVolumeByName_r(ec, partition, name);
2034     VOL_UNLOCK;
2035     return vp;
2036 }
2037
2038 /**
2039  * pre-attach a volume given its path.
2040  *
2041  * @param[out] ec         outbound error code
2042  * @param[in]  partition  path to vice partition
2043  * @param[in]  name       volume id string
2044  *
2045  * @return volume object pointer
2046  *
2047  * @pre VOL_LOCK held
2048  *
2049  * @internal volume package internal use only.
2050  */
2051 Volume *
2052 VPreAttachVolumeByName_r(Error * ec, char *partition, char *name)
2053 {
2054     return VPreAttachVolumeById_r(ec, 
2055                                   partition,
2056                                   VolumeNumber(name));
2057 }
2058
2059 /**
2060  * pre-attach a volume given its path and numeric volume id.
2061  *
2062  * @param[out] ec          error code return
2063  * @param[in]  partition   path to vice partition
2064  * @param[in]  volumeId    numeric volume id
2065  *
2066  * @return volume object pointer
2067  *
2068  * @pre VOL_LOCK held
2069  *
2070  * @internal volume package internal use only.
2071  */
2072 Volume *
2073 VPreAttachVolumeById_r(Error * ec, 
2074                        char * partition,
2075                        VolId volumeId)
2076 {
2077     Volume *vp;
2078     struct DiskPartition64 *partp;
2079
2080     *ec = 0;
2081
2082     assert(programType == fileServer);
2083
2084     if (!(partp = VGetPartition_r(partition, 0))) {
2085         *ec = VNOVOL;
2086         Log("VPreAttachVolumeById_r:  Error getting partition (%s)\n", partition);
2087         return NULL;
2088     }
2089
2090     vp = VLookupVolume_r(ec, volumeId, NULL);
2091     if (*ec) {
2092         return NULL;
2093     }
2094
2095     return VPreAttachVolumeByVp_r(ec, partp, vp, volumeId);
2096 }
2097
2098 /**
2099  * preattach a volume.
2100  *
2101  * @param[out] ec     outbound error code
2102  * @param[in]  partp  pointer to partition object
2103  * @param[in]  vp     pointer to volume object
2104  * @param[in]  vid    volume id
2105  *
2106  * @return volume object pointer
2107  *
2108  * @pre VOL_LOCK is held.
2109  *
2110  * @warning Returned volume object pointer does not have to
2111  *          equal the pointer passed in as argument vp.  There
2112  *          are potential race conditions which can result in
2113  *          the pointers having different values.  It is up to
2114  *          the caller to make sure that references are handled
2115  *          properly in this case.
2116  *
2117  * @note If there is already a volume object registered with
2118  *       the same volume id, its pointer MUST be passed as 
2119  *       argument vp.  Failure to do so will result in a silent
2120  *       failure to preattach.
2121  *
2122  * @internal volume package internal use only.
2123  */
2124 Volume * 
2125 VPreAttachVolumeByVp_r(Error * ec, 
2126                        struct DiskPartition64 * partp, 
2127                        Volume * vp,
2128                        VolId vid)
2129 {
2130     Volume *nvp = NULL;
2131
2132     *ec = 0;
2133
2134     /* check to see if pre-attach already happened */
2135     if (vp && 
2136         (V_attachState(vp) != VOL_STATE_UNATTACHED) && 
2137         (V_attachState(vp) != VOL_STATE_PREATTACHED) &&
2138         !VIsErrorState(V_attachState(vp))) {
2139         /*
2140          * pre-attach is a no-op in all but the following cases:
2141          *
2142          *   - volume is unattached
2143          *   - volume is in an error state
2144          *   - volume is pre-attached
2145          */
2146         Log("VPreattachVolumeByVp_r: volume %u not in quiescent state\n", vid);
2147         goto done;
2148     } else if (vp) {
2149         /* we're re-attaching a volume; clear out some old state */
2150         memset(&vp->salvage, 0, sizeof(struct VolumeOnlineSalvage));
2151
2152         if (V_partition(vp) != partp) {
2153             /* XXX potential race */
2154             DeleteVolumeFromVByPList_r(vp);
2155         }
2156     } else {
2157         /* if we need to allocate a new Volume struct,
2158          * go ahead and drop the vol glock, otherwise
2159          * do the basic setup synchronised, as it's
2160          * probably not worth dropping the lock */
2161         VOL_UNLOCK;
2162
2163         /* allocate the volume structure */
2164         vp = nvp = (Volume *) malloc(sizeof(Volume));
2165         assert(vp != NULL);
2166         memset(vp, 0, sizeof(Volume));
2167         queue_Init(&vp->vnode_list);
2168         assert(pthread_cond_init(&V_attachCV(vp), NULL) == 0);
2169     }
2170
2171     /* link the volume with its associated vice partition */
2172     vp->device = partp->device;
2173     vp->partition = partp;
2174
2175     vp->hashid = vid;
2176     vp->specialStatus = 0;
2177
2178     /* if we dropped the lock, reacquire the lock,
2179      * check for pre-attach races, and then add
2180      * the volume to the hash table */
2181     if (nvp) {
2182         VOL_LOCK;
2183         nvp = VLookupVolume_r(ec, vid, NULL);
2184         if (*ec) {
2185             free(vp);
2186             vp = NULL;
2187             goto done;
2188         } else if (nvp) { /* race detected */
2189             free(vp);
2190             vp = nvp;
2191             goto done;
2192         } else {
2193           /* hack to make up for VChangeState_r() decrementing 
2194            * the old state counter */
2195           VStats.state_levels[0]++;
2196         }
2197     }
2198
2199     /* put pre-attached volume onto the hash table
2200      * and bring it up to the pre-attached state */
2201     AddVolumeToHashTable(vp, vp->hashid);
2202     AddVolumeToVByPList_r(vp);
2203     VLRU_Init_Node_r(vp);
2204     VChangeState_r(vp, VOL_STATE_PREATTACHED);
2205
2206     if (LogLevel >= 5)
2207         Log("VPreAttachVolumeByVp_r:  volume %u pre-attached\n", vp->hashid);
2208
2209   done:
2210     if (*ec)
2211         return NULL;
2212     else
2213         return vp;
2214 }
2215 #endif /* AFS_DEMAND_ATTACH_FS */
2216
2217 /* Attach an existing volume, given its pathname, and return a
2218    pointer to the volume header information.  The volume also
2219    normally goes online at this time.  An offline volume
2220    must be reattached to make it go online */
2221 Volume *
2222 VAttachVolumeByName(Error * ec, char *partition, char *name, int mode)
2223 {
2224     Volume *retVal;
2225     VOL_LOCK;
2226     retVal = VAttachVolumeByName_r(ec, partition, name, mode);
2227     VOL_UNLOCK;
2228     return retVal;
2229 }
2230
2231 Volume *
2232 VAttachVolumeByName_r(Error * ec, char *partition, char *name, int mode)
2233 {
2234     register Volume *vp = NULL;
2235     struct DiskPartition64 *partp;
2236     char path[64];
2237     int isbusy = 0;
2238     VolId volumeId;
2239 #ifdef AFS_DEMAND_ATTACH_FS
2240     VolumeStats stats_save;
2241     Volume *svp = NULL;
2242 #endif /* AFS_DEMAND_ATTACH_FS */
2243
2244     *ec = 0;
2245    
2246     volumeId = VolumeNumber(name);
2247
2248     if (!(partp = VGetPartition_r(partition, 0))) {
2249         *ec = VNOVOL;
2250         Log("VAttachVolume: Error getting partition (%s)\n", partition);
2251         goto done;
2252     }
2253
2254     if (VRequiresPartLock()) {
2255         assert(VInit == 3);
2256         VLockPartition_r(partition);
2257     } else if (programType == fileServer) {
2258 #ifdef AFS_DEMAND_ATTACH_FS
2259         /* lookup the volume in the hash table */
2260         vp = VLookupVolume_r(ec, volumeId, NULL);
2261         if (*ec) {
2262             return NULL;
2263         }
2264
2265         if (vp) {
2266             /* save any counters that are supposed to
2267              * be monotonically increasing over the
2268              * lifetime of the fileserver */
2269             memcpy(&stats_save, &vp->stats, sizeof(VolumeStats));
2270         } else {
2271             memset(&stats_save, 0, sizeof(VolumeStats));
2272         }
2273
2274         /* if there's something in the hash table, and it's not
2275          * in the pre-attach state, then we may need to detach
2276          * it before proceeding */
2277         if (vp && (V_attachState(vp) != VOL_STATE_PREATTACHED)) {
2278             VCreateReservation_r(vp);
2279             VWaitExclusiveState_r(vp);
2280
2281             /* at this point state must be one of:
2282              *   - UNATTACHED
2283              *   - ATTACHED
2284              *   - SHUTTING_DOWN
2285              *   - GOING_OFFLINE
2286              *   - SALVAGING
2287              *   - ERROR
2288              */
2289
2290             if (vp->specialStatus == VBUSY)
2291                 isbusy = 1;
2292             
2293             /* if it's already attached, see if we can return it */
2294             if (V_attachState(vp) == VOL_STATE_ATTACHED) {
2295                 VGetVolumeByVp_r(ec, vp);
2296                 if (V_inUse(vp) == fileServer) {
2297                     VCancelReservation_r(vp);
2298                     return vp;
2299                 }
2300
2301                 /* otherwise, we need to detach, and attempt to re-attach */
2302                 VDetachVolume_r(ec, vp);
2303                 if (*ec) {
2304                     Log("VAttachVolume: Error detaching old volume instance (%s)\n", name);
2305                 }
2306             } else {
2307                 /* if it isn't fully attached, delete from the hash tables,
2308                    and let the refcounter handle the rest */
2309                 DeleteVolumeFromHashTable(vp);
2310                 DeleteVolumeFromVByPList_r(vp);
2311             }
2312
2313             VCancelReservation_r(vp);
2314             vp = NULL;
2315         }
2316
2317         /* pre-attach volume if it hasn't been done yet */
2318         if (!vp || 
2319             (V_attachState(vp) == VOL_STATE_UNATTACHED) ||
2320             (V_attachState(vp) == VOL_STATE_ERROR)) {
2321             svp = vp;
2322             vp = VPreAttachVolumeByVp_r(ec, partp, vp, volumeId);
2323             if (*ec) {
2324                 return NULL;
2325             }
2326         }
2327
2328         assert(vp != NULL);
2329
2330         /* handle pre-attach races 
2331          *
2332          * multiple threads can race to pre-attach a volume,
2333          * but we can't let them race beyond that
2334          * 
2335          * our solution is to let the first thread to bring
2336          * the volume into an exclusive state win; the other
2337          * threads just wait until it finishes bringing the
2338          * volume online, and then they do a vgetvolumebyvp
2339          */
2340         if (svp && (svp != vp)) {
2341             /* wait for other exclusive ops to finish */
2342             VCreateReservation_r(vp);
2343             VWaitExclusiveState_r(vp);
2344
2345             /* get a heavyweight ref, kill the lightweight ref, and return */
2346             VGetVolumeByVp_r(ec, vp);
2347             VCancelReservation_r(vp);
2348             return vp;
2349         }
2350
2351         /* at this point, we are chosen as the thread to do
2352          * demand attachment for this volume. all other threads
2353          * doing a getvolume on vp->hashid will block until we finish */
2354
2355         /* make sure any old header cache entries are invalidated
2356          * before proceeding */
2357         FreeVolumeHeader(vp);
2358
2359         VChangeState_r(vp, VOL_STATE_ATTACHING);
2360
2361         /* restore any saved counters */
2362         memcpy(&vp->stats, &stats_save, sizeof(VolumeStats));
2363 #else /* AFS_DEMAND_ATTACH_FS */
2364         vp = VGetVolume_r(ec, volumeId);
2365         if (vp) {
2366             if (V_inUse(vp) == fileServer)
2367                 return vp;
2368             if (vp->specialStatus == VBUSY)
2369                 isbusy = 1;
2370             VDetachVolume_r(ec, vp);
2371             if (*ec) {
2372                 Log("VAttachVolume: Error detaching volume (%s)\n", name);
2373             }
2374             vp = NULL;
2375         }
2376 #endif /* AFS_DEMAND_ATTACH_FS */
2377     }
2378
2379     *ec = 0;
2380     strcpy(path, VPartitionPath(partp));
2381
2382     VOL_UNLOCK;
2383
2384     strcat(path, "/");
2385     strcat(path, name);
2386
2387     if (!vp) {
2388       vp = (Volume *) calloc(1, sizeof(Volume));
2389       assert(vp != NULL);
2390       vp->hashid = volumeId;
2391       vp->device = partp->device;
2392       vp->partition = partp;
2393       queue_Init(&vp->vnode_list);
2394 #ifdef AFS_DEMAND_ATTACH_FS
2395       assert(pthread_cond_init(&V_attachCV(vp), NULL) == 0);
2396 #endif /* AFS_DEMAND_ATTACH_FS */
2397     }
2398
2399     /* attach2 is entered without any locks, and returns
2400      * with vol_glock_mutex held */
2401     vp = attach2(ec, volumeId, path, partp, vp, isbusy, mode);
2402
2403     if (VCanUseFSSYNC() && vp) {
2404 #ifdef AFS_DEMAND_ATTACH_FS
2405         if ((mode == V_VOLUPD) || (VolumeWriteable(vp) && (mode == V_CLONE))) {
2406             /* mark volume header as in use so that volser crashes lead to a
2407              * salvage attempt */
2408             VUpdateVolume_r(ec, vp, 0);
2409         }
2410         /* for dafs, we should tell the fileserver, except for V_PEEK
2411          * where we know it is not necessary */
2412         if (mode == V_PEEK) {
2413             vp->needsPutBack = 0;
2414         } else {
2415             vp->needsPutBack = 1;
2416         }
2417 #else /* !AFS_DEMAND_ATTACH_FS */
2418         /* duplicate computation in fssync.c about whether the server
2419          * takes the volume offline or not.  If the volume isn't
2420          * offline, we must not return it when we detach the volume,
2421          * or the server will abort */
2422         if (mode == V_READONLY || mode == V_PEEK
2423             || (!VolumeWriteable(vp) && (mode == V_CLONE || mode == V_DUMP)))
2424             vp->needsPutBack = 0;
2425         else
2426             vp->needsPutBack = 1;
2427 #endif /* !AFS_DEMAND_ATTACH_FS */
2428     }
2429     /* OK, there's a problem here, but one that I don't know how to
2430      * fix right now, and that I don't think should arise often.
2431      * Basically, we should only put back this volume to the server if
2432      * it was given to us by the server, but since we don't have a vp,
2433      * we can't run the VolumeWriteable function to find out as we do
2434      * above when computing vp->needsPutBack.  So we send it back, but
2435      * there's a path in VAttachVolume on the server which may abort
2436      * if this volume doesn't have a header.  Should be pretty rare
2437      * for all of that to happen, but if it does, probably the right
2438      * fix is for the server to allow the return of readonly volumes
2439      * that it doesn't think are really checked out. */
2440 #ifdef FSSYNC_BUILD_CLIENT
2441     if (VCanUseFSSYNC() && vp == NULL &&
2442         mode != V_SECRETLY && mode != V_PEEK) {
2443
2444 #ifdef AFS_DEMAND_ATTACH_FS
2445         /* If we couldn't attach but we scheduled a salvage, we already
2446          * notified the fileserver; don't online it now */
2447         if (*ec != VSALVAGING)
2448 #endif /* AFS_DEMAND_ATTACH_FS */
2449         FSYNC_VolOp(volumeId, partition, FSYNC_VOL_ON, 0, NULL);
2450     } else 
2451 #endif
2452     if (programType == fileServer && vp) {
2453 #ifdef AFS_DEMAND_ATTACH_FS
2454         /* 
2455          * we can get here in cases where we don't "own"
2456          * the volume (e.g. volume owned by a utility).
2457          * short circuit around potential disk header races.
2458          */
2459         if (V_attachState(vp) != VOL_STATE_ATTACHED) {
2460             goto done;
2461         }
2462 #endif
2463         VUpdateVolume_r(ec, vp, 0);
2464         if (*ec) {
2465             Log("VAttachVolume: Error updating volume\n");
2466             if (vp)
2467                 VPutVolume_r(vp);
2468             goto done;
2469         }
2470         if (VolumeWriteable(vp) && V_dontSalvage(vp) == 0) {
2471 #ifndef AFS_DEMAND_ATTACH_FS
2472             /* This is a hack: by temporarily setting the incore
2473              * dontSalvage flag ON, the volume will be put back on the
2474              * Update list (with dontSalvage OFF again).  It will then
2475              * come back in N minutes with DONT_SALVAGE eventually
2476              * set.  This is the way that volumes that have never had
2477              * it set get it set; or that volumes that have been
2478              * offline without DONT SALVAGE having been set also
2479              * eventually get it set */
2480             V_dontSalvage(vp) = DONT_SALVAGE;
2481 #endif /* !AFS_DEMAND_ATTACH_FS */
2482             VAddToVolumeUpdateList_r(ec, vp);
2483             if (*ec) {
2484                 Log("VAttachVolume: Error adding volume to update list\n");
2485                 if (vp)
2486                     VPutVolume_r(vp);
2487                 goto done;
2488             }
2489         }
2490         if (LogLevel)
2491             Log("VOnline:  volume %u (%s) attached and online\n", V_id(vp),
2492                 V_name(vp));
2493     }
2494
2495   done:
2496     if (VRequiresPartLock()) {
2497         VUnlockPartition_r(partition);
2498     }
2499     if (*ec) {
2500 #ifdef AFS_DEMAND_ATTACH_FS
2501         /* attach failed; make sure we're in error state */
2502         if (vp && !VIsErrorState(V_attachState(vp))) {
2503             VChangeState_r(vp, VOL_STATE_ERROR);
2504         }
2505 #endif /* AFS_DEMAND_ATTACH_FS */
2506         return NULL;
2507     } else {
2508         return vp;
2509     }
2510 }
2511
2512 #ifdef AFS_DEMAND_ATTACH_FS
2513 /* VAttachVolumeByVp_r
2514  *
2515  * finish attaching a volume that is
2516  * in a less than fully attached state
2517  */
2518 /* caller MUST hold a ref count on vp */
2519 static Volume *
2520 VAttachVolumeByVp_r(Error * ec, Volume * vp, int mode)
2521 {
2522     char name[VMAXPATHLEN];
2523     int reserve = 0;
2524     struct DiskPartition64 *partp;
2525     char path[64];
2526     int isbusy = 0;
2527     VolId volumeId;
2528     Volume * nvp = NULL;
2529     VolumeStats stats_save;
2530     *ec = 0;
2531
2532     /* volume utility should never call AttachByVp */
2533     assert(programType == fileServer);
2534    
2535     volumeId = vp->hashid;
2536     partp = vp->partition;
2537     VolumeExternalName_r(volumeId, name, sizeof(name));
2538
2539
2540     /* if another thread is performing a blocking op, wait */
2541     VWaitExclusiveState_r(vp);
2542
2543     memcpy(&stats_save, &vp->stats, sizeof(VolumeStats));
2544
2545     /* if it's already attached, see if we can return it */
2546     if (V_attachState(vp) == VOL_STATE_ATTACHED) {
2547         VGetVolumeByVp_r(ec, vp);
2548         if (V_inUse(vp) == fileServer) {
2549             return vp;
2550         } else {
2551             if (vp->specialStatus == VBUSY)
2552                 isbusy = 1;
2553             VDetachVolume_r(ec, vp);
2554             if (*ec) {
2555                 Log("VAttachVolume: Error detaching volume (%s)\n", name);
2556             }
2557             vp = NULL;
2558         }
2559     }
2560
2561     /* pre-attach volume if it hasn't been done yet */
2562     if (!vp || 
2563         (V_attachState(vp) == VOL_STATE_UNATTACHED) ||
2564         (V_attachState(vp) == VOL_STATE_ERROR)) {
2565         nvp = VPreAttachVolumeByVp_r(ec, partp, vp, volumeId);
2566         if (*ec) {
2567             return NULL;
2568         }
2569         if (nvp != vp) {
2570             reserve = 1;
2571             VCreateReservation_r(nvp);
2572             vp = nvp;
2573         }
2574     }
2575     
2576     assert(vp != NULL);
2577     VChangeState_r(vp, VOL_STATE_ATTACHING);
2578
2579     /* restore monotonically increasing stats */
2580     memcpy(&vp->stats, &stats_save, sizeof(VolumeStats));
2581
2582     *ec = 0;
2583
2584     /* compute path to disk header */
2585     strcpy(path, VPartitionPath(partp));
2586
2587     VOL_UNLOCK;
2588
2589     strcat(path, "/");
2590     strcat(path, name);
2591
2592     /* do volume attach
2593      *
2594      * NOTE: attach2 is entered without any locks, and returns
2595      * with vol_glock_mutex held */
2596     vp = attach2(ec, volumeId, path, partp, vp, isbusy, mode);
2597
2598     /*
2599      * the event that an error was encountered, or
2600      * the volume was not brought to an attached state
2601      * for any reason, skip to the end.  We cannot
2602      * safely call VUpdateVolume unless we "own" it.
2603      */
2604     if (*ec || 
2605         (vp == NULL) ||
2606         (V_attachState(vp) != VOL_STATE_ATTACHED)) {
2607         goto done;
2608     }
2609
2610     VUpdateVolume_r(ec, vp, 0);
2611     if (*ec) {
2612         Log("VAttachVolume: Error updating volume %u\n", vp->hashid);
2613         VPutVolume_r(vp);
2614         goto done;
2615     }
2616     if (VolumeWriteable(vp) && V_dontSalvage(vp) == 0) {
2617 #ifndef AFS_DEMAND_ATTACH_FS
2618         /* This is a hack: by temporarily setting the incore
2619          * dontSalvage flag ON, the volume will be put back on the
2620          * Update list (with dontSalvage OFF again).  It will then
2621          * come back in N minutes with DONT_SALVAGE eventually
2622          * set.  This is the way that volumes that have never had
2623          * it set get it set; or that volumes that have been
2624          * offline without DONT SALVAGE having been set also
2625          * eventually get it set */
2626         V_dontSalvage(vp) = DONT_SALVAGE;
2627 #endif /* !AFS_DEMAND_ATTACH_FS */
2628         VAddToVolumeUpdateList_r(ec, vp);
2629         if (*ec) {
2630             Log("VAttachVolume: Error adding volume %u to update list\n", vp->hashid);
2631             if (vp)
2632                 VPutVolume_r(vp);
2633             goto done;
2634         }
2635     }
2636     if (LogLevel)
2637         Log("VOnline:  volume %u (%s) attached and online\n", V_id(vp),
2638             V_name(vp));
2639   done:
2640     if (reserve) {
2641         VCancelReservation_r(nvp);
2642         reserve = 0;
2643     }
2644     if (*ec && (*ec != VOFFLINE) && (*ec != VSALVAGE)) {
2645         if (vp && !VIsErrorState(V_attachState(vp))) {
2646             VChangeState_r(vp, VOL_STATE_ERROR);
2647         }
2648         return NULL;
2649     } else {
2650         return vp;
2651     }
2652 }
2653
2654 /**
2655  * lock a volume on disk (non-blocking).
2656  *
2657  * @param[in] vp  The volume to lock
2658  * @param[in] locktype READ_LOCK or WRITE_LOCK
2659  *
2660  * @return operation status
2661  *  @retval 0 success, lock was obtained
2662  *  @retval EBUSY a conflicting lock was held by another process
2663  *  @retval EIO   error acquiring lock
2664  *
2665  * @pre If we're in the fileserver, vp is in an exclusive state
2666  *
2667  * @pre vp is not already locked
2668  */
2669 static int
2670 VLockVolumeNB(Volume *vp, int locktype)
2671 {
2672     int code;
2673
2674     assert(programType != fileServer || VIsExclusiveState(V_attachState(vp)));
2675     assert(!(V_attachFlags(vp) & VOL_LOCKED));
2676
2677     code = VLockVolumeByIdNB(vp->hashid, vp->partition, locktype);
2678     if (code == 0) {
2679         V_attachFlags(vp) |= VOL_LOCKED;
2680     }
2681
2682     return code;
2683 }
2684
2685 /**
2686  * unlock a volume on disk that was locked with VLockVolumeNB.
2687  *
2688  * @param[in] vp  volume to unlock
2689  *
2690  * @pre If we're in the fileserver, vp is in an exclusive state
2691  *
2692  * @pre vp has already been locked
2693  */
2694 static void
2695 VUnlockVolume(Volume *vp)
2696 {
2697     assert(programType != fileServer || VIsExclusiveState(V_attachState(vp)));
2698     assert((V_attachFlags(vp) & VOL_LOCKED));
2699
2700     VUnlockVolumeById(vp->hashid, vp->partition);
2701
2702     V_attachFlags(vp) &= ~VOL_LOCKED;
2703 }
2704 #endif /* AFS_DEMAND_ATTACH_FS */
2705
2706 /**
2707  * read in a vol header, possibly lock the vol header, and possibly check out
2708  * the vol header from the fileserver, as part of volume attachment.
2709  *
2710  * @param[out] ec     error code
2711  * @param[in] vp      volume pointer object
2712  * @param[in] partp   disk partition object of the attaching partition
2713  * @param[in] mode    attachment mode such as V_VOLUPD, V_DUMP, etc (see
2714  *                    volume.h)
2715  * @param[in] peek    1 to just try to read in the volume header and make sure
2716  *                    we don't try to lock the vol, or check it out from
2717  *                    FSSYNC or anything like that; 0 otherwise, for 'normal'
2718  *                    operation
2719  *
2720  * @note As part of DAFS volume attachment, the volume header may be either
2721  *       read- or write-locked to ensure mutual exclusion of certain volume
2722  *       operations. In some cases in order to determine whether we need to
2723  *       read- or write-lock the header, we need to read in the header to see
2724  *       if the volume is RW or not. So, if we read in the header under a
2725  *       read-lock and determine that we actually need a write-lock on the
2726  *       volume header, this function will drop the read lock, acquire a write
2727  *       lock, and read the header in again.
2728  */
2729 static void
2730 attach_volume_header(Error *ec, Volume *vp, struct DiskPartition64 *partp,
2731                      int mode, int peek)
2732 {
2733     struct VolumeDiskHeader diskHeader;
2734     struct VolumeHeader header;
2735     int code;
2736     int first_try = 1;
2737     int lock_tries = 0, checkout_tries = 0;
2738     int retry;
2739     VolumeId volid = vp->hashid;
2740 #ifdef FSSYNC_BUILD_CLIENT
2741     int checkout, done_checkout = 0;
2742 #endif /* FSSYNC_BUILD_CLIENT */
2743 #ifdef AFS_DEMAND_ATTACH_FS
2744     int locktype = 0, use_locktype = -1;
2745 #endif /* AFS_DEMAND_ATTACH_FS */
2746
2747  retry:
2748     retry = 0;
2749     *ec = 0;
2750
2751     if (lock_tries > VOL_MAX_CHECKOUT_RETRIES) {
2752         Log("VAttachVolume: retried too many times trying to lock header for "
2753             "vol %lu part %s; giving up\n", afs_printable_uint32_lu(volid),
2754             VPartitionPath(partp));
2755         *ec = VNOVOL;
2756         goto done;
2757     }
2758     if (checkout_tries > VOL_MAX_CHECKOUT_RETRIES) {
2759         Log("VAttachVolume: retried too many times trying to checkout "
2760             "vol %lu part %s; giving up\n", afs_printable_uint32_lu(volid),
2761             VPartitionPath(partp));
2762         *ec = VNOVOL;
2763         goto done;
2764     }
2765
2766     if (VReadVolumeDiskHeader(volid, partp, NULL)) {
2767         /* short-circuit the 'volume does not exist' case */
2768         *ec = VNOVOL;
2769         goto done;
2770     }
2771
2772 #ifdef FSSYNC_BUILD_CLIENT
2773     checkout = !done_checkout;
2774     done_checkout = 1;
2775     if (!peek && checkout && VMustCheckoutVolume(mode)) {
2776         SYNC_response res;
2777         memset(&res, 0, sizeof(res));
2778
2779         if (FSYNC_VolOp(volid, VPartitionPath(partp), FSYNC_VOL_NEEDVOLUME, mode, &res)
2780             != SYNC_OK) {
2781
2782             if (res.hdr.reason == FSYNC_SALVAGE) {
2783                 Log("VAttachVolume: file server says volume %lu is salvaging\n",
2784                      afs_printable_uint32_lu(volid));
2785                 *ec = VSALVAGING;
2786             } else {
2787                 Log("VAttachVolume: attach of volume %lu apparently denied by file server\n",
2788                      afs_printable_uint32_lu(volid));
2789                 *ec = VNOVOL;   /* XXXX */
2790             }
2791             goto done;
2792         }
2793     }
2794 #endif
2795
2796 #ifdef AFS_DEMAND_ATTACH_FS
2797     if (use_locktype < 0) {
2798         /* don't know whether vol is RO or RW; assume it's RO and we can retry
2799          * if it turns out to be RW */
2800         locktype = VVolLockType(mode, 0);
2801
2802     } else {
2803         /* a previous try says we should use use_locktype to lock the volume,
2804          * so use that */
2805         locktype = use_locktype;
2806     }
2807
2808     if (!peek && locktype) {
2809         code = VLockVolumeNB(vp, locktype);
2810         if (code) {
2811             if (code == EBUSY) {
2812                 Log("VAttachVolume: another program has vol %lu locked\n",
2813                     afs_printable_uint32_lu(volid));
2814             } else {
2815                 Log("VAttachVolume: error %d trying to lock vol %lu\n",
2816                     code, afs_printable_uint32_lu(volid));
2817             }
2818
2819             *ec = VNOVOL;
2820             goto done;
2821         }
2822     }
2823 #endif /* AFS_DEMAND_ATTACH_FS */
2824
2825     code = VReadVolumeDiskHeader(volid, partp, &diskHeader);
2826     if (code) {
2827         if (code == EIO) {
2828             *ec = VSALVAGE;
2829         } else {
2830             *ec = VNOVOL;
2831         }
2832         goto done;
2833     }
2834
2835     DiskToVolumeHeader(&header, &diskHeader);
2836
2837     IH_INIT(vp->vnodeIndex[vLarge].handle, partp->device, header.parent,
2838             header.largeVnodeIndex);
2839     IH_INIT(vp->vnodeIndex[vSmall].handle, partp->device, header.parent,
2840             header.smallVnodeIndex);
2841     IH_INIT(vp->diskDataHandle, partp->device, header.parent,
2842             header.volumeInfo);
2843     IH_INIT(vp->linkHandle, partp->device, header.parent, header.linkTable);
2844
2845     if (first_try) {
2846         /* only need to do this once */
2847         VOL_LOCK;
2848         GetVolumeHeader(vp);
2849         VOL_UNLOCK;
2850     }
2851
2852 #if defined(AFS_DEMAND_ATTACH_FS) && defined(FSSYNC_BUILD_CLIENT)
2853     /* demand attach changes the V_PEEK mechanism
2854      *
2855      * we can now suck the current disk data structure over
2856      * the fssync interface without going to disk
2857      *
2858      * (technically, we don't need to restrict this feature
2859      *  to demand attach fileservers.  However, I'm trying
2860      *  to limit the number of common code changes)
2861      */
2862     if (VCanUseFSSYNC() && (mode == V_PEEK || peek)) {
2863         SYNC_response res;
2864         res.payload.len = sizeof(VolumeDiskData);
2865         res.payload.buf = &vp->header->diskstuff;
2866
2867         if (FSYNC_VolOp(vp->hashid,
2868                         partp->name,
2869                         FSYNC_VOL_QUERY_HDR,
2870                         FSYNC_WHATEVER,
2871                         &res) == SYNC_OK) {
2872             goto disk_header_loaded;
2873         }
2874     }
2875 #endif /* AFS_DEMAND_ATTACH_FS && FSSYNC_BUILD_CLIENT */
2876     (void)ReadHeader(ec, V_diskDataHandle(vp), (char *)&V_disk(vp),
2877                      sizeof(V_disk(vp)), VOLUMEINFOMAGIC, VOLUMEINFOVERSION);
2878
2879 #ifdef AFS_DEMAND_ATTACH_FS
2880     /* update stats */
2881     VOL_LOCK;
2882     IncUInt64(&VStats.hdr_loads);
2883     IncUInt64(&vp->stats.hdr_loads);
2884     VOL_UNLOCK;
2885 #endif /* AFS_DEMAND_ATTACH_FS */
2886     
2887     if (*ec) {
2888         Log("VAttachVolume: Error reading diskDataHandle header for vol %lu; "
2889             "error=%u\n", afs_printable_uint32_lu(volid), *ec);
2890         goto done;
2891     }
2892
2893 #ifdef AFS_DEMAND_ATTACH_FS
2894 # ifdef FSSYNC_BUILD_CLIENT
2895  disk_header_loaded:
2896 # endif /* FSSYNC_BUILD_CLIENT */
2897
2898     /* if the lock type we actually used to lock the volume is different than
2899      * the lock type we should have used, retry with the lock type we should
2900      * use */
2901     use_locktype = VVolLockType(mode, VolumeWriteable(vp));
2902     if (locktype != use_locktype) {
2903         retry = 1;
2904         lock_tries++;
2905     }
2906 #endif /* AFS_DEMAND_ATTACH_FS */
2907
2908     *ec = 0;
2909
2910  done:
2911 #if defined(AFS_DEMAND_ATTACH_FS) && defined(FSSYNC_BUILD_CLIENT)
2912     if (!peek && *ec == 0 && retry == 0 && VMustCheckoutVolume(mode)) {
2913
2914         code = FSYNC_VerifyCheckout(volid, VPartitionPath(partp), FSYNC_VOL_NEEDVOLUME, mode);
2915
2916         if (code == SYNC_DENIED) {
2917             /* must retry checkout; fileserver no longer thinks we have
2918              * the volume */
2919             retry = 1;
2920             checkout_tries++;
2921             done_checkout = 0;
2922
2923         } else if (code != SYNC_OK) {
2924             *ec = VNOVOL;
2925         }
2926     }
2927 #endif /* AFS_DEMAND_ATTACH_FS && FSSYNC_BUILD_CLIENT */
2928
2929     if (*ec || retry) {
2930         /* either we are going to be called again for a second pass, or we
2931          * encountered an error; clean up in either case */
2932
2933 #ifdef AFS_DEMAND_ATTACH_FS
2934         if ((V_attachFlags(vp) & VOL_LOCKED)) {
2935             VUnlockVolume(vp);
2936         }
2937 #endif /* AFS_DEMAND_ATTACH_FS */
2938         if (vp->linkHandle) {
2939             IH_RELEASE(vp->vnodeIndex[vLarge].handle);
2940             IH_RELEASE(vp->vnodeIndex[vSmall].handle);
2941             IH_RELEASE(vp->diskDataHandle);
2942             IH_RELEASE(vp->linkHandle);
2943         }
2944     }
2945
2946     if (*ec) {
2947         return;
2948     }
2949     if (retry) {
2950         first_try = 0;
2951         goto retry;
2952     }
2953 }
2954
2955 #ifdef AFS_DEMAND_ATTACH_FS
2956 static void
2957 attach_check_vop(Error *ec, VolumeId volid, struct DiskPartition64 *partp,
2958                  Volume *vp)
2959 {
2960     *ec = 0;
2961
2962     if (vp->pending_vol_op) {
2963
2964         VOL_LOCK;
2965
2966         if (vp->pending_vol_op->vol_op_state == FSSYNC_VolOpRunningUnknown) {
2967             int code;
2968             code = VVolOpLeaveOnlineNoHeader_r(vp, vp->pending_vol_op);
2969             if (code == 1) {
2970                 vp->pending_vol_op->vol_op_state = FSSYNC_VolOpRunningOnline;
2971             } else if (code == 0) {
2972                 vp->pending_vol_op->vol_op_state = FSSYNC_VolOpRunningOffline;
2973
2974             } else {
2975                 /* we need the vol header to determine if the volume can be
2976                  * left online for the vop, so... get the header */
2977
2978                 VOL_UNLOCK;
2979
2980                 /* attach header with peek=1 to avoid checking out the volume
2981                  * or locking it; we just want the header info, we're not
2982                  * messing with the volume itself at all */
2983                 attach_volume_header(ec, vp, partp, V_PEEK, 1);
2984                 if (*ec) {
2985                     return;
2986                 }
2987
2988                 VOL_LOCK;
2989
2990                 if (VVolOpLeaveOnline_r(vp, vp->pending_vol_op)) {
2991                     vp->pending_vol_op->vol_op_state = FSSYNC_VolOpRunningOnline;
2992                 } else {
2993                     vp->pending_vol_op->vol_op_state = FSSYNC_VolOpRunningOffline;
2994                 }
2995
2996                 /* make sure we grab a new vol header and re-open stuff on
2997                  * actual attachment; we can't keep the data we grabbed, since
2998                  * it was not done under a lock and thus not safe */
2999                 FreeVolumeHeader(vp);
3000                 VReleaseVolumeHandles_r(vp);
3001             }
3002         }
3003         /* see if the pending volume op requires exclusive access */
3004         switch (vp->pending_vol_op->vol_op_state) {
3005         case FSSYNC_VolOpPending:
3006             /* this should never happen */
3007             assert(vp->pending_vol_op->vol_op_state != FSSYNC_VolOpPending);
3008             break;
3009
3010         case FSSYNC_VolOpRunningUnknown:
3011             /* this should never happen; we resolved 'unknown' above */
3012             assert(vp->pending_vol_op->vol_op_state != FSSYNC_VolOpRunningUnknown);
3013             break;
3014
3015         case FSSYNC_VolOpRunningOffline:
3016             /* mark the volume down */
3017             *ec = VOFFLINE;
3018             VChangeState_r(vp, VOL_STATE_UNATTACHED);
3019
3020             /* do not set V_offlineMessage here; we don't have ownership of
3021              * the volume (and probably do not have the header loaded), so we
3022              * can't alter the disk header */
3023
3024             /* check to see if we should set the specialStatus flag */
3025             if (VVolOpSetVBusy_r(vp, vp->pending_vol_op)) {
3026                 vp->specialStatus = VBUSY;
3027             }
3028             break;
3029
3030         default:
3031             break;
3032         }
3033
3034         VOL_UNLOCK;
3035     }
3036 }
3037 #endif /* AFS_DEMAND_ATTACH_FS */
3038
3039 /**
3040  * volume attachment helper function.
3041  *
3042  * @param[out] ec      error code
3043  * @param[in] volumeId volume ID of the attaching volume
3044  * @param[in] path     full path to the volume header .vol file
3045  * @param[in] partp    disk partition object for the attaching partition
3046  * @param[in] vp       volume object; vp->hashid, vp->device, vp->partition,
3047  *                     vp->vnode_list, and V_attachCV (for DAFS) should already
3048  *                     be initialized
3049  * @param[in] isbusy   1 if vp->specialStatus should be set to VBUSY; that is,
3050  *                     if there is a volume operation running for this volume
3051  *                     that should set the volume to VBUSY during its run. 0
3052  *                     otherwise. (see VVolOpSetVBusy_r)
3053  * @param[in] mode     attachment mode such as V_VOLUPD, V_DUMP, etc (see
3054  *                     volume.h)
3055  *
3056  * @return pointer to the semi-attached volume pointer
3057  *  @retval NULL an error occurred (check value of *ec)
3058  *  @retval vp volume successfully attaching
3059  *
3060  * @pre no locks held
3061  *
3062  * @post VOL_LOCK held
3063  */
3064 static Volume *
3065 attach2(Error * ec, VolId volumeId, char *path, struct DiskPartition64 *partp,
3066         Volume * vp, int isbusy, int mode)
3067 {
3068     /* have we read in the header successfully? */
3069     int read_header = 0;
3070
3071     /* should we FreeVolume(vp) instead of VCheckFree(vp) in the error
3072      * cleanup? */
3073     int forcefree = 0;
3074
3075 #ifdef AFS_DEMAND_ATTACH_FS
3076     /* in the case of an error, to what state should the volume be
3077      * transitioned? */
3078     VolState error_state = VOL_STATE_ERROR;
3079 #endif /* AFS_DEMAND_ATTACH_FS */
3080
3081     *ec = 0;
3082
3083     vp->vnodeIndex[vLarge].handle = NULL;
3084     vp->vnodeIndex[vSmall].handle = NULL;
3085     vp->diskDataHandle = NULL;
3086     vp->linkHandle = NULL;
3087
3088 #ifdef AFS_DEMAND_ATTACH_FS
3089     attach_check_vop(ec, volumeId, partp, vp);
3090     if (!*ec) {
3091         attach_volume_header(ec, vp, partp, mode, 0);
3092     }
3093 #else
3094     attach_volume_header(ec, vp, partp, mode, 0);
3095 #endif /* !AFS_DEMAND_ATTACH_FS */
3096
3097     if (*ec == VNOVOL) {
3098         /* if the volume doesn't exist, skip straight to 'error' so we don't
3099          * request a salvage */
3100         goto error;
3101     }
3102
3103     if (!*ec) {
3104         read_header = 1;
3105
3106         vp->specialStatus = (byte) (isbusy ? VBUSY : 0);
3107         vp->shuttingDown = 0;
3108         vp->goingOffline = 0;
3109         vp->nUsers = 1;
3110 #ifdef AFS_DEMAND_ATTACH_FS
3111         vp->stats.last_attach = FT_ApproxTime();
3112         vp->stats.attaches++;
3113 #endif
3114
3115         VOL_LOCK;
3116         IncUInt64(&VStats.attaches);
3117         vp->cacheCheck = ++VolumeCacheCheck;
3118         /* just in case this ever rolls over */
3119         if (!vp->cacheCheck)
3120             vp->cacheCheck = ++VolumeCacheCheck;
3121         VOL_UNLOCK;
3122
3123 #ifdef AFS_DEMAND_ATTACH_FS
3124         V_attachFlags(vp) |= VOL_HDR_LOADED;
3125         vp->stats.last_hdr_load = vp->stats.last_attach;
3126 #endif /* AFS_DEMAND_ATTACH_FS */
3127     }
3128
3129     if (!*ec) {
3130         struct IndexFileHeader iHead;
3131
3132 #if OPENAFS_VOL_STATS
3133         /*
3134          * We just read in the diskstuff part of the header.  If the detailed
3135          * volume stats area has not yet been initialized, we should bzero the
3136          * area and mark it as initialized.
3137          */
3138         if (!(V_stat_initialized(vp))) {
3139             memset((V_stat_area(vp)), 0, VOL_STATS_BYTES);
3140             V_stat_initialized(vp) = 1;
3141         }
3142 #endif /* OPENAFS_VOL_STATS */
3143
3144         (void)ReadHeader(ec, vp->vnodeIndex[vSmall].handle,
3145                          (char *)&iHead, sizeof(iHead),
3146                          SMALLINDEXMAGIC, SMALLINDEXVERSION);
3147
3148         if (*ec) {
3149             Log("VAttachVolume: Error reading smallVnode vol header %s; error=%u\n", path, *ec);
3150         }
3151     }
3152
3153     if (!*ec) {
3154         struct IndexFileHeader iHead;
3155
3156         (void)ReadHeader(ec, vp->vnodeIndex[vLarge].handle,
3157                          (char *)&iHead, sizeof(iHead),
3158                          LARGEINDEXMAGIC, LARGEINDEXVERSION);
3159
3160         if (*ec) {
3161             Log("VAttachVolume: Error reading largeVnode vol header %s; error=%u\n", path, *ec);
3162         }
3163     }
3164
3165 #ifdef AFS_NAMEI_ENV
3166     if (!*ec) {
3167         struct versionStamp stamp;
3168
3169         (void)ReadHeader(ec, V_linkHandle(vp), (char *)&stamp,
3170                          sizeof(stamp), LINKTABLEMAGIC, LINKTABLEVERSION);
3171
3172         if (*ec) {
3173             Log("VAttachVolume: Error reading namei vol header %s; error=%u\n", path, *ec);
3174         }
3175     }
3176 #endif /* AFS_NAMEI_ENV */
3177
3178 #if defined(AFS_DEMAND_ATTACH_FS)
3179     if (*ec && ((*ec != VOFFLINE) || (V_attachState(vp) != VOL_STATE_UNATTACHED))) {
3180         VOL_LOCK;
3181         if (!VCanScheduleSalvage()) {
3182             Log("VAttachVolume: Error attaching volume %s; volume needs salvage; error=%u\n", path, *ec);
3183         }
3184         VRequestSalvage_r(ec, vp, SALVSYNC_ERROR, VOL_SALVAGE_INVALIDATE_HEADER);
3185         vp->nUsers = 0;
3186
3187         goto error;
3188     } else if (*ec) {
3189         /* volume operation in progress */
3190         VOL_LOCK;
3191         goto error;
3192     }
3193 #else /* AFS_DEMAND_ATTACH_FS */
3194     if (*ec) {
3195         Log("VAttachVolume: Error attaching volume %s; volume needs salvage; error=%u\n", path, *ec);
3196         VOL_LOCK;
3197         goto error;
3198     }
3199 #endif /* AFS_DEMAND_ATTACH_FS */
3200
3201     if (V_needsSalvaged(vp)) {
3202         if (vp->specialStatus)
3203             vp->specialStatus = 0;
3204         VOL_LOCK;
3205 #if defined(AFS_DEMAND_ATTACH_FS)
3206         if (!VCanScheduleSalvage()) {
3207             Log("VAttachVolume: volume salvage flag is ON for %s; volume needs salvage\n", path);
3208         }
3209         VRequestSalvage_r(ec, vp, SALVSYNC_NEEDED, VOL_SALVAGE_INVALIDATE_HEADER);
3210         vp->nUsers = 0;
3211
3212 #else /* AFS_DEMAND_ATTACH_FS */
3213         *ec = VSALVAGE;
3214 #endif /* AFS_DEMAND_ATTACH_FS */
3215
3216         goto error;
3217     }
3218
3219     VOL_LOCK;
3220     vp->nextVnodeUnique = V_uniquifier(vp);
3221
3222     if (VShouldCheckInUse(mode) && V_inUse(vp) && VolumeWriteable(vp)) {
3223         if (!V_needsSalvaged(vp)) {
3224             V_needsSalvaged(vp) = 1;
3225             VUpdateVolume_r(ec, vp, 0);
3226         }
3227 #if defined(AFS_DEMAND_ATTACH_FS)
3228         if (!VCanScheduleSalvage()) {
3229             Log("VAttachVolume: volume %s needs to be salvaged; not attached.\n", path);
3230         }
3231         VRequestSalvage_r(ec, vp, SALVSYNC_NEEDED, VOL_SALVAGE_INVALIDATE_HEADER);
3232         vp->nUsers = 0;
3233
3234 #else /* AFS_DEMAND_ATTACH_FS */
3235         Log("VAttachVolume: volume %s needs to be salvaged; not attached.\n", path);
3236         *ec = VSALVAGE;
3237 #endif /* AFS_DEMAND_ATTACH_FS */
3238
3239         goto error;
3240     }
3241
3242     if (programType == fileServer && V_destroyMe(vp) == DESTROY_ME) {
3243         /* Only check destroyMe if we are the fileserver, since the
3244          * volserver et al sometimes need to work with volumes with
3245          * destroyMe set. Examples are 'temporary' volumes the
3246          * volserver creates, and when we create a volume (destroyMe
3247          * is set on creation; sometimes a separate volserver
3248          * transaction is created to clear destroyMe).
3249          */
3250
3251 #if defined(AFS_DEMAND_ATTACH_FS)
3252         /* schedule a salvage so the volume goes away on disk */
3253         VRequestSalvage_r(ec, vp, SALVSYNC_ERROR, VOL_SALVAGE_INVALIDATE_HEADER);
3254         VChangeState_r(vp, VOL_STATE_ERROR);
3255         vp->nUsers = 0;
3256 #endif /* AFS_DEMAND_ATTACH_FS */
3257         Log("VAttachVolume: volume %s is junk; it should be destroyed at next salvage\n", path);
3258         *ec = VNOVOL;
3259         forcefree = 1;
3260         goto error;
3261     }
3262
3263     vp->vnodeIndex[vSmall].bitmap = vp->vnodeIndex[vLarge].bitmap = NULL;
3264 #ifndef BITMAP_LATER
3265     if (programType == fileServer && VolumeWriteable(vp)) {
3266         int i;
3267         for (i = 0; i < nVNODECLASSES; i++) {
3268             VGetBitmap_r(ec, vp, i);
3269             if (*ec) {
3270 #ifdef AFS_DEMAND_ATTACH_FS
3271                 VRequestSalvage_r(ec, vp, SALVSYNC_ERROR, VOL_SALVAGE_INVALIDATE_HEADER);
3272                 vp->nUsers = 0;
3273 #endif /* AFS_DEMAND_ATTACH_FS */
3274                 Log("VAttachVolume: error getting bitmap for volume (%s)\n",
3275                     path);
3276                 goto error;
3277             }
3278         }
3279     }
3280 #endif /* BITMAP_LATER */
3281
3282     if (VInit >= 2 && V_needsCallback(vp)) {
3283         if (V_BreakVolumeCallbacks) {
3284             Log("VAttachVolume: Volume %lu was changed externally; breaking callbacks\n",
3285                 afs_printable_uint32_lu(V_id(vp)));
3286             V_needsCallback(vp) = 0;
3287             VOL_UNLOCK;
3288             (*V_BreakVolumeCallbacks) (V_id(vp));
3289             VOL_LOCK;
3290
3291             VUpdateVolume_r(ec, vp, 0);
3292         }
3293 #ifdef FSSYNC_BUILD_CLIENT
3294         else if (VCanUseFSSYNC()) {
3295             afs_int32 fsync_code;
3296
3297             V_needsCallback(vp) = 0;
3298             VOL_UNLOCK;
3299             fsync_code = FSYNC_VolOp(V_id(vp), NULL, FSYNC_VOL_BREAKCBKS, FSYNC_WHATEVER, NULL);
3300             VOL_LOCK;
3301
3302             if (fsync_code) {
3303                 V_needsCallback(vp) = 1;
3304                 Log("Error trying to tell the fileserver to break callbacks for "
3305                     "changed volume %lu; error code %ld\n",
3306                     afs_printable_uint32_lu(V_id(vp)),
3307                     afs_printable_int32_ld(fsync_code));
3308             } else {
3309                 VUpdateVolume_r(ec, vp, 0);
3310             }
3311         }
3312 #endif /* FSSYNC_BUILD_CLIENT */
3313
3314         if (*ec) {
3315             Log("VAttachVolume: error %d clearing needsCallback on volume "
3316                 "%lu; needs salvage\n", (int)*ec,
3317                 afs_printable_uint32_lu(V_id(vp)));
3318 #ifdef AFS_DEMAND_ATTACH_FS
3319             VRequestSalvage_r(ec, vp, SALVSYNC_ERROR, VOL_SALVAGE_INVALIDATE_HEADER);
3320             vp->nUsers = 0;
3321 #else /* !AFS_DEMAND_ATTACH_FS */
3322             *ec = VSALVAGE;
3323 #endif /* !AFS_DEMAND_ATTACh_FS */
3324             goto error;
3325         }
3326     }
3327
3328     if (programType == fileServer) {
3329         if (vp->specialStatus)
3330             vp->specialStatus = 0;
3331         if (V_blessed(vp) && V_inService(vp) && !V_needsSalvaged(vp)) {
3332             V_inUse(vp) = fileServer;
3333             V_offlineMessage(vp)[0] = '\0';
3334         }
3335         if (!V_inUse(vp)) {
3336             *ec = VNOVOL;
3337 #ifdef AFS_DEMAND_ATTACH_FS
3338             /* Put the vol into PREATTACHED state, so if someone tries to
3339              * access it again, we try to attach, see that we're not blessed,
3340              * and give a VNOVOL error again. Putting it into UNATTACHED state
3341              * would result in a VOFFLINE error instead. */
3342             error_state = VOL_STATE_PREATTACHED;
3343 #endif /* AFS_DEMAND_ATTACH_FS */
3344
3345             /* mimic e.g. GetVolume errors */
3346             if (!V_blessed(vp)) {
3347                 Log("Volume %lu offline: not blessed\n", afs_printable_uint32_lu(V_id(vp)));
3348                 FreeVolumeHeader(vp);
3349             } else if (!V_inService(vp)) {
3350                 Log("Volume %lu offline: not in service\n", afs_printable_uint32_lu(V_id(vp)));
3351                 FreeVolumeHeader(vp);
3352             } else {
3353                 Log("Volume %lu offline: needs salvage\n", afs_printable_uint32_lu(V_id(vp)));
3354                 *ec = VSALVAGE;
3355 #ifdef AFS_DEMAND_ATTACH_FS
3356                 error_state = VOL_STATE_ERROR;
3357                 /* see if we can recover */
3358                 VRequestSalvage_r(ec, vp, SALVSYNC_NEEDED, VOL_SALVAGE_INVALIDATE_HEADER);
3359 #endif
3360             }
3361 #ifdef AFS_DEMAND_ATTACH_FS
3362             vp->nUsers = 0;
3363 #endif
3364             goto error;
3365         }
3366     } else {
3367 #ifdef AFS_DEMAND_ATTACH_FS
3368         if ((mode != V_PEEK) && (mode != V_SECRETLY))
3369             V_inUse(vp) = programType;
3370 #endif /* AFS_DEMAND_ATTACH_FS */
3371         V_checkoutMode(vp) = mode;
3372     }
3373
3374     AddVolumeToHashTable(vp, V_id(vp));
3375 #ifdef AFS_DEMAND_ATTACH_FS
3376     if (VCanUnlockAttached() && (V_attachFlags(vp) & VOL_LOCKED)) {
3377         VUnlockVolume(vp);
3378     }
3379     if ((programType != fileServer) ||
3380         (V_inUse(vp) == fileServer)) {
3381         AddVolumeToVByPList_r(vp);
3382         VLRU_Add_r(vp);
3383         VChangeState_r(vp, VOL_STATE_ATTACHED);
3384     } else {
3385         VChangeState_r(vp, VOL_STATE_UNATTACHED);
3386     }
3387 #endif
3388
3389     return vp;
3390
3391  error:
3392 #ifdef AFS_DEMAND_ATTACH_FS
3393     if (!VIsErrorState(V_attachState(vp))) {
3394         VChangeState_r(vp, error_state);
3395     }
3396 #endif /* AFS_DEMAND_ATTACH_FS */
3397
3398     if (read_header) {
3399         VReleaseVolumeHandles_r(vp);
3400     }
3401
3402 #ifdef AFS_DEMAND_ATTACH_FS
3403     VCheckSalvage(vp);
3404     if (forcefree) {
3405         FreeVolume(vp);
3406     } else {
3407         VCheckFree(vp);
3408     }
3409 #else /* !AFS_DEMAND_ATTACH_FS */
3410     FreeVolume(vp);
3411 #endif /* !AFS_DEMAND_ATTACH_FS */
3412     return NULL;
3413 }
3414
3415 /* Attach an existing volume.
3416    The volume also normally goes online at this time.
3417    An offline volume must be reattached to make it go online.
3418  */
3419
3420 Volume *
3421 VAttachVolume(Error * ec, VolumeId volumeId, int mode)
3422 {
3423     Volume *retVal;
3424     VOL_LOCK;
3425     retVal = VAttachVolume_r(ec, volumeId, mode);
3426     VOL_UNLOCK;
3427     return retVal;
3428 }
3429
3430 Volume *
3431 VAttachVolume_r(Error * ec, VolumeId volumeId, int mode)
3432 {
3433     char *part, *name;
3434     VGetVolumePath(ec, volumeId, &part, &name);
3435     if (*ec) {
3436         register Volume *vp;
3437         Error error;
3438         vp = VGetVolume_r(&error, volumeId);
3439         if (vp) {
3440             assert(V_inUse(vp) == 0);
3441             VDetachVolume_r(ec, vp);
3442         }
3443         return NULL;
3444     }
3445     return VAttachVolumeByName_r(ec, part, name, mode);
3446 }
3447
3448 /* Increment a reference count to a volume, sans context swaps.  Requires
3449  * possibly reading the volume header in from the disk, since there's
3450  * an invariant in the volume package that nUsers>0 ==> vp->header is valid.
3451  *
3452  * N.B. This call can fail if we can't read in the header!!  In this case
3453  * we still guarantee we won't context swap, but the ref count won't be
3454  * incremented (otherwise we'd violate the invariant).
3455  */
3456 /* NOTE: with the demand attach fileserver extensions, the global lock
3457  * is dropped within VHold */
3458 #ifdef AFS_DEMAND_ATTACH_FS
3459 static int
3460 VHold_r(register Volume * vp)
3461 {
3462     Error error;
3463
3464     VCreateReservation_r(vp);
3465     VWaitExclusiveState_r(vp);
3466
3467     LoadVolumeHeader(&error, vp);
3468     if (error) {
3469         VCancelReservation_r(vp);
3470         return error;
3471     }
3472     vp->nUsers++;
3473     VCancelReservation_r(vp);
3474     return 0;
3475 }
3476 #else /* AFS_DEMAND_ATTACH_FS */
3477 static int
3478 VHold_r(register Volume * vp)
3479 {
3480     Error error;
3481
3482     LoadVolumeHeader(&error, vp);
3483     if (error)
3484         return error;
3485     vp->nUsers++;
3486     return 0;
3487 }
3488 #endif /* AFS_DEMAND_ATTACH_FS */
3489
3490 #if 0
3491 static int
3492 VHold(register Volume * vp)
3493 {
3494     int retVal;
3495     VOL_LOCK;
3496     retVal = VHold_r(vp);
3497     VOL_UNLOCK;
3498     return retVal;
3499 }
3500 #endif
3501
3502
3503 /***************************************************/
3504 /* get and put volume routines                     */
3505 /***************************************************/
3506
3507 /**
3508  * put back a heavyweight reference to a volume object.
3509  *
3510  * @param[in] vp  volume object pointer
3511  *
3512  * @pre VOL_LOCK held
3513  *
3514  * @post heavyweight volume reference put back.
3515  *       depending on state, volume may have been taken offline,
3516  *       detached, salvaged, freed, etc.
3517  *
3518  * @internal volume package internal use only
3519  */
3520 void
3521 VPutVolume_r(register Volume * vp)
3522 {
3523     assert(--vp->nUsers >= 0);
3524     if (vp->nUsers == 0) {
3525         VCheckOffline(vp);
3526         ReleaseVolumeHeader(vp->header);
3527 #ifdef AFS_DEMAND_ATTACH_FS
3528         if (!VCheckDetach(vp)) {
3529             VCheckSalvage(vp);
3530             VCheckFree(vp);
3531         }
3532 #else /* AFS_DEMAND_ATTACH_FS */
3533         VCheckDetach(vp);
3534 #endif /* AFS_DEMAND_ATTACH_FS */
3535     }
3536 }
3537
3538 void
3539 VPutVolume(register Volume * vp)
3540 {
3541     VOL_LOCK;
3542     VPutVolume_r(vp);
3543     VOL_UNLOCK;
3544 }
3545
3546
3547 /* Get a pointer to an attached volume.  The pointer is returned regardless
3548    of whether or not the volume is in service or on/off line.  An error
3549    code, however, is returned with an indication of the volume's status */
3550 Volume *
3551 VGetVolume(Error * ec, Error * client_ec, VolId volumeId)
3552 {
3553     Volume *retVal;
3554     VOL_LOCK;
3555     retVal = GetVolume(ec, client_ec, volumeId, NULL, 0);
3556     VOL_UNLOCK;
3557     return retVal;
3558 }
3559
3560 /* same as VGetVolume, but if a volume is waiting to go offline, we return
3561  * that it is actually offline, instead of waiting for it to go offline */
3562 Volume *
3563 VGetVolumeNoWait(Error * ec, Error * client_ec, VolId volumeId)
3564 {
3565     Volume *retVal;
3566     VOL_LOCK;
3567     retVal = GetVolume(ec, client_ec, volumeId, NULL, 1);
3568     VOL_UNLOCK;
3569     return retVal;
3570 }
3571
3572 Volume *
3573 VGetVolume_r(Error * ec, VolId volumeId)
3574 {
3575     return GetVolume(ec, NULL, volumeId, NULL, 0);
3576 }
3577
3578 /* try to get a volume we've previously looked up */
3579 /* for demand attach fs, caller MUST NOT hold a ref count on vp */
3580 Volume * 
3581 VGetVolumeByVp_r(Error * ec, Volume * vp)
3582 {
3583     return GetVolume(ec, NULL, vp->hashid, vp, 0);
3584 }
3585
3586 /**
3587  * private interface for getting a volume handle
3588  *
3589  * @param[out] ec         error code (0 if no error)
3590  * @param[out] client_ec  wire error code to be given to clients
3591  * @param[in]  volumeId   ID of the volume we want
3592  * @param[in]  hint       optional hint for hash lookups, or NULL
3593  * @param[in]  nowait     0 to wait for a 'goingOffline' volume to go offline
3594  *                        before returning, 1 to return immediately
3595  *
3596  * @return a volume handle for the specified volume
3597  *  @retval NULL an error occurred, or the volume is in such a state that
3598  *               we cannot load a header or return any volume struct
3599  *
3600  * @note for DAFS, caller must NOT hold a ref count on 'hint'
3601  */
3602 static Volume *
3603 GetVolume(Error * ec, Error * client_ec, VolId volumeId, Volume * hint, int nowait)
3604 {
3605     Volume *vp = hint;
3606     /* pull this profiling/debugging code out of regular builds */
3607 #ifdef notdef
3608 #define VGET_CTR_INC(x) x++
3609     unsigned short V0 = 0, V1 = 0, V2 = 0, V3 = 0, V5 = 0, V6 =
3610         0, V7 = 0, V8 = 0, V9 = 0;
3611     unsigned short V10 = 0, V11 = 0, V12 = 0, V13 = 0, V14 = 0, V15 = 0;
3612 #else
3613 #define VGET_CTR_INC(x)
3614 #endif
3615 #ifdef AFS_DEMAND_ATTACH_FS
3616     Volume *avp, * rvp = hint;
3617 #endif
3618
3619     /* 
3620      * if VInit is zero, the volume package dynamic
3621      * data structures have not been initialized yet,
3622      * and we must immediately return an error
3623      */
3624     if (VInit == 0) {
3625         vp = NULL;
3626         *ec = VOFFLINE;
3627         if (client_ec) {
3628             *client_ec = VOFFLINE;
3629         }
3630         goto not_inited;
3631     }
3632
3633 #ifdef AFS_DEMAND_ATTACH_FS
3634     if (rvp) {
3635         VCreateReservation_r(rvp);
3636     }
3637 #endif /* AFS_DEMAND_ATTACH_FS */
3638
3639     for (;;) {
3640         *ec = 0;
3641         if (client_ec)
3642             *client_ec = 0;
3643         VGET_CTR_INC(V0);
3644
3645         vp = VLookupVolume_r(ec, volumeId, vp);
3646         if (*ec) {
3647             vp = NULL;
3648             break;
3649         }
3650
3651 #ifdef AFS_DEMAND_ATTACH_FS
3652         if (rvp && (rvp != vp)) {
3653             /* break reservation on old vp */
3654             VCancelReservation_r(rvp);
3655             rvp = NULL;
3656         }
3657 #endif /* AFS_DEMAND_ATTACH_FS */
3658
3659         if (!vp) {
3660             VGET_CTR_INC(V1);
3661             if (VInit < 2) {
3662                 VGET_CTR_INC(V2);
3663                 /* Until we have reached an initialization level of 2
3664                  * we don't know whether this volume exists or not.
3665                  * We can't sleep and retry later because before a volume
3666                  * is attached, the caller tries to get it first.  Just
3667                  * return VOFFLINE and the caller can choose whether to
3668                  * retry the command or not. */
3669                 *ec = VOFFLINE;
3670                 break;
3671             }
3672
3673             *ec = VNOVOL;
3674             break;
3675         }
3676
3677         VGET_CTR_INC(V3);
3678         IncUInt64(&VStats.hdr_gets);
3679         
3680 #ifdef AFS_DEMAND_ATTACH_FS
3681         /* block if someone else is performing an exclusive op on this volume */
3682         if (rvp != vp) {
3683             rvp = vp;
3684             VCreateReservation_r(rvp);
3685         }
3686         VWaitExclusiveState_r(vp);
3687
3688         /* short circuit with VNOVOL in the following circumstances:
3689          *
3690          *   - VOL_STATE_ERROR
3691          *   - VOL_STATE_SHUTTING_DOWN
3692          */
3693         if ((V_attachState(vp) == VOL_STATE_ERROR) ||
3694             (V_attachState(vp) == VOL_STATE_SHUTTING_DOWN) ||
3695             (V_attachState(vp) == VOL_STATE_GOING_OFFLINE)) {
3696             *ec = VNOVOL;
3697             vp = NULL;
3698             break;
3699         }
3700
3701         /*
3702          * short circuit with VOFFLINE in the following circumstances:
3703          *
3704          *   - VOL_STATE_UNATTACHED
3705          */
3706        if (V_attachState(vp) == VOL_STATE_UNATTACHED) {
3707            if (vp->specialStatus) {
3708                *ec = vp->specialStatus;
3709            } else {
3710                *ec = VOFFLINE;
3711            }
3712            vp = NULL;
3713            break;
3714        }
3715
3716         /* allowable states:
3717          *   - PREATTACHED
3718          *   - ATTACHED
3719          *   - SALVAGING
3720          */
3721
3722         if (vp->salvage.requested) {
3723             VUpdateSalvagePriority_r(vp);
3724         }
3725
3726         if (V_attachState(vp) == VOL_STATE_PREATTACHED) {
3727             avp = VAttachVolumeByVp_r(ec, vp, 0);
3728             if (avp) {
3729                 if (vp != avp) {
3730                     /* VAttachVolumeByVp_r can return a pointer
3731                      * != the vp passed to it under certain
3732                      * conditions; make sure we don't leak
3733                      * reservations if that happens */
3734                     vp = avp;
3735                     VCancelReservation_r(rvp);
3736                     rvp = avp;
3737                     VCreateReservation_r(rvp);
3738                 }
3739                 VPutVolume_r(avp);
3740             }
3741             if (*ec) {
3742                 int endloop = 0;
3743                 switch (*ec) {
3744                 case VSALVAGING:
3745                     break;
3746                 case VOFFLINE:
3747                     if (!vp->pending_vol_op) {
3748                         endloop = 1;
3749                     }
3750                     break;
3751                 default:
3752                     *ec = VNOVOL;
3753                     endloop = 1;
3754                 }
3755                 if (endloop) {
3756                     vp = NULL;
3757                     break;
3758                 }
3759             }
3760         }
3761
3762         if ((V_attachState(vp) == VOL_STATE_SALVAGING) ||
3763             (*ec == VSALVAGING)) {
3764             if (client_ec) {
3765                 /* see CheckVnode() in afsfileprocs.c for an explanation
3766                  * of this error code logic */
3767                 afs_uint32 now = FT_ApproxTime();
3768                 if ((vp->stats.last_salvage + (10 * 60)) >= now) {
3769                     *client_ec = VBUSY;
3770                 } else {
3771                     *client_ec = VRESTARTING;
3772                 }
3773             }
3774             *ec = VSALVAGING;
3775             vp = NULL;
3776             break;
3777         }
3778 #endif
3779
3780 #ifdef AFS_DEMAND_ATTACH_FS
3781         /*
3782          * this test MUST happen after VAttachVolymeByVp, so vol_op_state is
3783          * not VolOpRunningUnknown (attach2 would have converted it to Online
3784          * or Offline)
3785          */
3786         
3787          /* only valid before/during demand attachment */
3788          assert(!vp->pending_vol_op || vp->pending_vol_op->vol_op_state != FSSYNC_VolOpRunningUnknown);
3789         
3790          /* deny getvolume due to running mutually exclusive vol op */
3791          if (vp->pending_vol_op && vp->pending_vol_op->vol_op_state==FSSYNC_VolOpRunningOffline) {