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