src/vol/volume.c

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