src/vol/volume.h

   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) 2006-2008 Sine Nomine Associates
  10  */
  11
  12 /*
  13         System:         VICE-TWO
  14         Module:         volume.h
  15         Institution:    The Information Technology Center, Carnegie-Mellon University
  16
  17  */
  18
  19 #ifndef __volume_h
  20 #define __volume_h  1
  21
  22 #include <afs/afssyscalls.h>
  23 #include "voldefs.h"
  24 #include "ihandle.h"
  25 #define VolumeWriteable(vp)             (V_type(vp)==readwriteVolume)
  26 #define VolumeWriteable2(vol)           (vol.type == readwriteVolume)
  27 typedef bit32 FileOffset;       /* Offset in this file */
  28 #define Date afs_uint32
  29 #include "daemon_com.h"
  30 #include "fssync.h"
  31
  32 #if 0
  33 /** turn this on if you suspect a volume package locking bug */
  34 #define VOL_LOCK_DEBUG 1
  35 #endif
  36
  37 #ifdef VOL_LOCK_DEBUG
  38 #define VOL_LOCK_ASSERT_HELD \
  39     assert(vol_glock_holder == pthread_self())
  40 #define VOL_LOCK_ASSERT_UNHELD \
  41     assert(vol_glock_holder == 0)
  42 #define _VOL_LOCK_SET_HELD \
  43     vol_glock_holder = pthread_self()
  44 #define _VOL_LOCK_SET_UNHELD \
  45     vol_glock_holder = 0
  46 #define VOL_LOCK_DBG_CV_WAIT_END \
  47     do { \
  48         VOL_LOCK_ASSERT_UNHELD; \
  49         _VOL_LOCK_SET_HELD; \
  50     } while(0)
  51 #define VOL_LOCK_DBG_CV_WAIT_BEGIN \
  52     do { \
  53          VOL_LOCK_ASSERT_HELD; \
  54          _VOL_LOCK_SET_UNHELD; \
  55     } while(0)
  56 #else
  57 #define VOL_LOCK_ASSERT_HELD
  58 #define VOL_LOCK_ASSERT_UNHELD
  59 #define VOL_LOCK_DBG_CV_WAIT_BEGIN
  60 #define VOL_LOCK_DBG_CV_WAIT_END
  61 #endif
  62
  63
  64 #ifdef AFS_PTHREAD_ENV
  65 #include <assert.h>
  66 #include <pthread.h>
  67 extern pthread_mutex_t vol_glock_mutex;
  68 extern pthread_mutex_t vol_trans_mutex;
  69 extern pthread_cond_t vol_put_volume_cond;
  70 extern pthread_cond_t vol_sleep_cond;
  71 extern int vol_attach_threads;
  72 #ifdef VOL_LOCK_DEBUG
  73 extern pthread_t vol_glock_holder;
  74 #define VOL_LOCK \
  75     do { \
  76         assert(pthread_mutex_lock(&vol_glock_mutex) == 0); \
  77         assert(vol_glock_holder == 0); \
  78         vol_glock_holder = pthread_self(); \
  79     } while (0)
  80 #define VOL_UNLOCK \
  81     do { \
  82         VOL_LOCK_ASSERT_HELD; \
  83         vol_glock_holder = 0; \
  84         assert(pthread_mutex_unlock(&vol_glock_mutex) == 0); \
  85     } while (0)
  86 #define VOL_CV_WAIT(cv) \
  87     do { \
  88         VOL_LOCK_DBG_CV_WAIT_BEGIN; \
  89         assert(pthread_cond_wait((cv), &vol_glock_mutex) == 0); \
  90         VOL_LOCK_DBG_CV_WAIT_END; \
  91     } while (0)
  92 #else /* !VOL_LOCK_DEBUG */
  93 #define VOL_LOCK \
  94     assert(pthread_mutex_lock(&vol_glock_mutex) == 0)
  95 #define VOL_UNLOCK \
  96     assert(pthread_mutex_unlock(&vol_glock_mutex) == 0)
  97 #define VOL_CV_WAIT(cv) assert(pthread_cond_wait((cv), &vol_glock_mutex) == 0)
  98 #endif /* !VOL_LOCK_DEBUG */
  99 #define VSALVSYNC_LOCK \
 100     assert(pthread_mutex_lock(&vol_salvsync_mutex) == 0)
 101 #define VSALVSYNC_UNLOCK \
 102     assert(pthread_mutex_unlock(&vol_salvsync_mutex) == 0)
 103 #define VTRANS_LOCK \
 104     assert(pthread_mutex_lock(&vol_trans_mutex) == 0)
 105 #define VTRANS_UNLOCK \
 106     assert(pthread_mutex_unlock(&vol_trans_mutex) == 0)
 107 #else /* AFS_PTHREAD_ENV */
 108 #define VOL_LOCK
 109 #define VOL_UNLOCK
 110 #define VSALVSYNC_LOCK
 111 #define VSALVSYNC_UNLOCK
 112 #define VTRANS_LOCK
 113 #define VTRANS_UNLOCK
 114 #endif /* AFS_PTHREAD_ENV */
 115
 116 /**
 117  * volume package program type enumeration.
 118  */
 119 typedef enum {
 120     fileServer          = 1,    /**< the fileserver process */
 121     volumeUtility       = 2,    /**< volserver, or a
 122                                  *   single volume salvager (non-dafs) */
 123     salvager            = 3,    /**< standalone whole-partition salvager */
 124     salvageServer       = 4,    /**< dafs online salvager */
 125     debugUtility        = 5     /**< fssync-debug or similar utility */
 126 } ProgramType;
 127 extern ProgramType programType; /* The type of program using the package */
 128
 129 /* Some initialization parameters for the volume package */
 130 /* Add new initialization parameters here */
 131 extern int (*V_BreakVolumeCallbacks) ();
 132 extern int (*vol_PollProc) ();
 133 #define DOPOLL  ((vol_PollProc)? (*vol_PollProc)() : 0)
 134
 135 #ifdef AFS_DEMAND_ATTACH_FS
 136 /**
 137  * variable error return code based upon programType and DAFS presence
 138  */
 139 #define DAFS_VSALVAGE   ((programType == fileServer) ? VSALVAGING : VSALVAGE)
 140 #else
 141 #define DAFS_VSALVAGE   (VSALVAGE)
 142 #endif
 143
 144 struct versionStamp {           /* Version stamp for critical volume files */
 145     bit32 magic;                /* Magic number */
 146     bit32 version;              /* Version number of this file, or software
 147                                  * that created this file */
 148 };
 149
 150 #ifdef AFS_DEMAND_ATTACH_FS
 151 /**
 152  * demand attach volume state enumeration.
 153  *
 154  * @note values must be contiguous in order for VIsValidState() to work correctly
 155  */
 156 typedef enum {
 157     VOL_STATE_UNATTACHED        = 0,    /**< volume is unattached */
 158     VOL_STATE_PREATTACHED       = 1,    /**< volume has been pre-attached */
 159     VOL_STATE_ATTACHING         = 2,    /**< volume is transitioning to fully attached */
 160     VOL_STATE_ATTACHED          = 3,    /**< volume has been fully attached */
 161     VOL_STATE_UPDATING          = 4,    /**< volume is updating on-disk structures */
 162     VOL_STATE_GET_BITMAP        = 5,    /**< volume is getting bitmap entries */
 163     VOL_STATE_HDR_LOADING       = 6,    /**< volume is loading disk header */
 164     VOL_STATE_HDR_ATTACHING     = 7,    /**< volume is getting a header from the LRU */
 165     VOL_STATE_SHUTTING_DOWN     = 8,    /**< volume is shutting down */
 166     VOL_STATE_GOING_OFFLINE     = 9,    /**< volume is going offline */
 167     VOL_STATE_OFFLINING         = 10,   /**< volume is transitioning to offline */
 168     VOL_STATE_DETACHING         = 11,   /**< volume is transitioning to detached */
 169     VOL_STATE_SALVSYNC_REQ      = 12,   /**< volume is blocked on a salvsync request */
 170     VOL_STATE_SALVAGING         = 13,   /**< volume is being salvaged */
 171     VOL_STATE_ERROR             = 14,   /**< volume is in an error state */
 172     VOL_STATE_VNODE_ALLOC       = 15,   /**< volume is busy allocating a new vnode */
 173     VOL_STATE_VNODE_GET         = 16,   /**< volume is busy getting vnode disk data */
 174     VOL_STATE_VNODE_CLOSE       = 17,   /**< volume is busy closing vnodes */
 175     VOL_STATE_VNODE_RELEASE     = 18,   /**< volume is busy releasing vnodes */
 176     VOL_STATE_VLRU_ADD          = 19,   /**< volume is busy being added to a VLRU queue */
 177     /* please add new states directly above this line */
 178     VOL_STATE_FREED             = 20,   /**< debugging aid */
 179     VOL_STATE_COUNT             = 21,   /**< total number of valid states */
 180 } VolState;
 181
 182 /**
 183  * V_attachFlags bits.
 184  */
 185 enum VolFlags {
 186     VOL_HDR_ATTACHED      = 0x1,     /**< volume header is attached to Volume struct */
 187     VOL_HDR_LOADED        = 0x2,     /**< volume header contents are valid */
 188     VOL_HDR_IN_LRU        = 0x4,     /**< volume header is in LRU */
 189     VOL_IN_HASH           = 0x8,     /**< volume is in hash table */
 190     VOL_ON_VBYP_LIST      = 0x10,    /**< volume is on VByP list */
 191     VOL_IS_BUSY           = 0x20,    /**< volume is not to be free()d */
 192     VOL_ON_VLRU           = 0x40,    /**< volume is on the VLRU */
 193     VOL_HDR_DONTSALV      = 0x80,    /**< volume header DONTSALVAGE flag is set */
 194 };
 195
 196 /* VPrintExtendedCacheStats flags */
 197 #define VOL_STATS_PER_CHAIN   0x1  /**< compute simple per-chain stats */
 198 #define VOL_STATS_PER_CHAIN2  0x2  /**< compute per-chain stats that require scanning
 199                                     *   every element of the chain */
 200
 201 /* VLRU_SetOptions options */
 202 #define VLRU_SET_THRESH       1
 203 #define VLRU_SET_INTERVAL     2
 204 #define VLRU_SET_MAX          3
 205 #define VLRU_SET_ENABLED      4
 206
 207 /**
 208  * VLRU queue names.
 209  */
 210 typedef enum {
 211     VLRU_QUEUE_NEW        = 0,  /**< LRU queue for new volumes */
 212     VLRU_QUEUE_MID        = 1,  /**< survivor generation */
 213     VLRU_QUEUE_OLD        = 2,  /**< old generation */
 214     VLRU_QUEUE_CANDIDATE  = 3,  /**< soft detach candidate pool */
 215     VLRU_QUEUE_HELD       = 4,  /*   volumes which are not allowed
 216                                  *   to be soft detached */
 217     VLRU_QUEUE_INVALID    = 5,  /**< invalid queue id */
 218 } VLRUQueueName;
 219
 220 /* default scanner timing parameters */
 221 #define VLRU_DEFAULT_OFFLINE_THRESH (60*60*2) /* 2 hours */
 222 #define VLRU_DEFAULT_OFFLINE_INTERVAL (60*2) /* 2 minutes */
 223 #define VLRU_DEFAULT_OFFLINE_MAX 8 /* 8 volumes */
 224
 225
 226 /**
 227  * DAFS thread-specific options structure
 228  */
 229 typedef struct VThreadOptions {
 230      int disallow_salvsync;     /**< whether or not salvsync calls are allowed
 231                                  *   on this thread (deadlock prevention). */
 232 } VThreadOptions_t;
 233 extern pthread_key_t VThread_key;
 234 extern VThreadOptions_t VThread_defaults;
 235
 236 #endif /* AFS_DEMAND_ATTACH_FS */
 237
 238
 239 /* Magic numbers and version stamps for each type of file */
 240 #define VOLUMEHEADERMAGIC       ((bit32)0x88a1bb3c)
 241 #define VOLUMEINFOMAGIC         ((bit32)0x78a1b2c5)
 242 #define SMALLINDEXMAGIC         0x99776655
 243 #define LARGEINDEXMAGIC         0x88664433
 244 #define MOUNTMAGIC              0x9a8b7c6d
 245 #define ACLMAGIC                0x88877712
 246 #define LINKTABLEMAGIC          0x99877712
 247
 248 #define VOLUMEHEADERVERSION     1
 249 #define VOLUMEINFOVERSION       1
 250 #define SMALLINDEXVERSION       1
 251 #define LARGEINDEXVERSION       1
 252 #define MOUNTVERSION            1
 253 #define ACLVERSION              1
 254 #define LINKTABLEVERSION        1
 255
 256 /*
 257  * Define whether we are keeping detailed statistics on volume dealings.
 258  */
 259 #define OPENAFS_VOL_STATS       1
 260
 261 #if OPENAFS_VOL_STATS
 262 /*
 263  * Define various indices and counts used in keeping volume-level statistics.
 264  */
 265 #define VOL_STATS_NUM_RWINFO_FIELDS 4
 266
 267 #define VOL_STATS_SAME_NET      0       /*Within same site (total) */
 268 #define VOL_STATS_SAME_NET_AUTH 1       /*Within same site (authenticated);
 269                                          * (must be 1 more than above) */
 270 #define VOL_STATS_DIFF_NET      2       /*From external site (total) */
 271 #define VOL_STATS_DIFF_NET_AUTH 3       /*From external site (authenticated)
 272                                          * (must be 1 more than above) */
 273
 274 #define VOL_STATS_NUM_TIME_RANGES 6
 275
 276 #define VOL_STATS_TIME_CAP_0        60  /*60 seconds */
 277 #define VOL_STATS_TIME_CAP_1       600  /*10 minutes, in seconds */
 278 #define VOL_STATS_TIME_CAP_2      3600  /*1 hour, in seconds */
 279 #define VOL_STATS_TIME_CAP_3     86400  /*1 day, in seconds */
 280 #define VOL_STATS_TIME_CAP_4    604800  /*1 week, in seconds */
 281
 282 #define VOL_STATS_NUM_TIME_FIELDS 6
 283
 284 #define VOL_STATS_TIME_IDX_0    0       /*0 secs to 60 secs */
 285 #define VOL_STATS_TIME_IDX_1    1       /*1 min to 10 mins */
 286 #define VOL_STATS_TIME_IDX_2    2       /*10 mins to 60 mins */
 287 #define VOL_STATS_TIME_IDX_3    3       /*1 hr to 24 hrs */
 288 #define VOL_STATS_TIME_IDX_4    4       /*1 day to 7 days */
 289 #define VOL_STATS_TIME_IDX_5    5       /*Greater than 1 week */
 290 #endif /* OPENAFS_VOL_STATS */
 291
 292 /* Volume header.  This is the contents of the named file representing
 293  * the volume.  Read-only by the file server!
 294  */
 295 typedef struct VolumeHeader {
 296     struct versionStamp stamp;  /* Must be first field */
 297     VolumeId id;                /* Volume number */
 298     VolumeId parent;            /* Read-write volume number (or this volume
 299                                  * number if this is a read-write volume) */
 300     Inode volumeInfo;
 301     Inode smallVnodeIndex;
 302     Inode largeVnodeIndex;
 303     Inode volumeAcl;
 304     Inode volumeMountTable;
 305     Inode linkTable;
 306 } VolumeHeader_t;
 307
 308
 309 typedef struct VolumeDiskHeader {
 310     struct versionStamp stamp;  /* Must be first field */
 311     VolumeId id;                /* Volume number */
 312     VolumeId parent;            /* Read-write volume number (or this volume
 313                                  * number if this is a read-write volume) */
 314     afs_int32 volumeInfo_lo;
 315     afs_int32 smallVnodeIndex_lo;
 316     afs_int32 largeVnodeIndex_lo;
 317     afs_int32 volumeAcl_lo;
 318     afs_int32 volumeMountTable_lo;
 319     afs_int32 volumeInfo_hi;
 320     afs_int32 smallVnodeIndex_hi;
 321     afs_int32 largeVnodeIndex_hi;
 322     afs_int32 volumeAcl_hi;
 323     afs_int32 volumeMountTable_hi;
 324     afs_int32 linkTable_lo;
 325     afs_int32 linkTable_hi;
 326     /* If you add fields, add them before here and reduce the size of  array */
 327     bit32 reserved[3];
 328 } VolumeDiskHeader_t;
 329
 330 /* A vnode index file header */
 331 struct IndexFileHeader {
 332     struct versionStamp stamp;
 333 };
 334
 335
 336 /******************************************************************************/
 337 /* Volume Data which is stored on disk and can also be maintained in memory.  */
 338 /******************************************************************************/
 339 typedef struct VolumeDiskData {
 340     struct versionStamp stamp;  /* Must be first field */
 341     VolumeId id;                /* Volume id--unique over all systems */
 342 #define VNAMESIZE 32            /* including 0 byte */
 343     char name[VNAMESIZE];       /* Unofficial name for the volume */
 344     byte inUse;                 /* Volume is being used (perhaps it is online),
 345                                  * or the system crashed while it was used */
 346     byte inService;             /* Volume in service, not necessarily on line
 347                                  * This bit is set by an operator/system
 348                                  * programmer.  Manually taking a volume offline
 349                                  * always clears the inService bit. Taking
 350                                  * it out of service also takes it offline */
 351     byte blessed;               /* Volume is administratively blessed with
 352                                  * the ability to go on line.  Set by a system
 353                                  * administrator. Clearing this bit will
 354                                  * take the volume offline */
 355     byte needsSalvaged;         /* Volume needs salvaged--an unrecoverable
 356                                  * error occured to the volume.  Note:  a volume
 357                                  * may still require salvage even if this
 358                                  * flag isn't set--e.g. if a system crash
 359                                  * occurred while the volume was on line. */
 360     bit32 uniquifier;           /* Next vnode uniquifier for this volume */
 361     int type;                   /* */
 362     VolId parentId;             /* Id of parent, if type==readonly */
 363     VolId cloneId;              /* Latest read-only clone, if type==readwrite,
 364                                  * 0 if the volume has never been cloned.  Note: the
 365                                  * indicated volume does not necessarily exist (it
 366                                  * may have been deleted since cloning). */
 367     VolId backupId;             /* Latest backup copy of this read write volume */
 368     VolId restoredFromId;       /* The id in the dump this volume was restored from--used simply
 369                                  * to make sure that an incremental dump is not restored on top
 370                                  * of something inappropriate:  Note:  this field itself is NEVER
 371                                  * dumped!!! */
 372     byte needsCallback;         /* Set by the salvager if anything was changed
 373                                  * about the volume.  Note:  this is not set by
 374                                  * clone/makebackups when setting the copy-on-write
 375                                  * flag in directories; this flag is not seen by
 376                                  * the clients. */
 377 #define DESTROY_ME      0xD3
 378     byte destroyMe;             /* If this is set to DESTROY_ME, then the salvager should destroy
 379                                  * this volume; it is bogus (left over from an aborted  volume move,
 380                                  * for example).  Note:  if this flag is on, then inService should
 381                                  * be OFF--only the salvager checks this flag */
 382 #ifdef ALPHA_DUX40_ENV
 383 #define DONT_SALVAGE    0xE6
 384 #else                           /* ALPHA_DUX40_ENV */
 385 #define DONT_SALVAGE    0xE5
 386 #endif                          /* ALPHA_DUX40_ENV */
 387     byte dontSalvage;           /* If this is on, then don't bother salvaging this volume */
 388     byte reserveb3;
 389
 390     bit32 reserved1[6];
 391
 392
 393     /* Administrative stuff */
 394     int maxquota;               /* Quota maximum, 1K blocks */
 395     int minquota;               /* Quota minimum, 1K blocks */
 396     int maxfiles;               /* Maximum number of files (i.e. inodes) */
 397     bit32 accountNumber;        /* Uninterpreted account number */
 398     bit32 owner;                /* The person administratively responsible
 399                                  * for this volume */
 400     int reserved2[8];           /* Other administrative constraints */
 401
 402     /* Resource usage & statistics */
 403     int filecount;              /* Actual number of files */
 404     int diskused;               /* Actual disk space used, 1K blocks */
 405     int dayUse;                 /* Metric for today's usage of this volume so far */
 406     int weekUse[7];             /* Usage of the volume for the last week.
 407                                  * weekUse[0] is for most recent complete 24 hour period
 408                                  * of measurement; week[6] is 7 days ago */
 409     Date dayUseDate;            /* Date the dayUse statistics refer to; the week use stats
 410                                  * are the preceding 7 days */
 411     unsigned int volUpdateCounter; /*incremented at every update of volume*/
 412     int reserved3[10];          /* Other stats here */
 413
 414     /* Server supplied dates */
 415     Date creationDate;          /* Creation date for a read/write
 416                                  * volume; cloning date for original copy of
 417                                  * a readonly volume (replicated volumes have
 418                                  * the same creation date) */
 419     Date accessDate;            /* Last access time by a user, large granularity */
 420     Date updateDate;            /* Last modification by user */
 421     Date expirationDate;        /* 0 if it never expires */
 422     Date backupDate;            /* last time a backup clone was taken */
 423
 424     /* Time that this copy of this volume was made.  NEVER backed up.  This field is only
 425      * set when the copy is created */
 426     Date copyDate;
 427
 428 #if OPENAFS_VOL_STATS
 429     bit32 stat_initialized;     /*Are the stat fields below set up? */
 430     bit32 reserved4[7];
 431 #else
 432     bit32 reserved4[8];
 433 #endif                          /* OPENAFS_VOL_STATS */
 434
 435     /* messages */
 436 #define VMSGSIZE 128
 437     char offlineMessage[VMSGSIZE];      /* Why the volume is offline */
 438 #if OPENAFS_VOL_STATS
 439 #define VOL_STATS_BYTES 128
 440     /*
 441      * Keep per-volume aggregate statistics on type and distance of access,
 442      * along with authorship info.
 443      */
 444     bit32 stat_reads[VOL_STATS_NUM_RWINFO_FIELDS];
 445     bit32 stat_writes[VOL_STATS_NUM_RWINFO_FIELDS];
 446     bit32 stat_fileSameAuthor[VOL_STATS_NUM_TIME_FIELDS];
 447     bit32 stat_fileDiffAuthor[VOL_STATS_NUM_TIME_FIELDS];
 448     bit32 stat_dirSameAuthor[VOL_STATS_NUM_TIME_FIELDS];
 449     bit32 stat_dirDiffAuthor[VOL_STATS_NUM_TIME_FIELDS];
 450 #else
 451     char motd[VMSGSIZE];        /* Volume "message of the day" */
 452 #endif                          /* OPENAFS_VOL_STATS */
 453
 454 } VolumeDiskData;
 455
 456
 457 /**************************************/
 458 /* Memory resident volume information */
 459 /**************************************/
 460
 461 /**
 462  * global volume package stats.
 463  */
 464 typedef struct VolPkgStats {
 465 #ifdef AFS_DEMAND_ATTACH_FS
 466     /*
 467      * demand attach fs
 468      * extended volume package statistics
 469      */
 470
 471     /* levels */
 472     afs_uint32 state_levels[VOL_STATE_COUNT]; /**< volume state transition counters */
 473
 474     /* counters */
 475     afs_uint64 hash_looks;           /**< number of hash chain element traversals */
 476     afs_uint64 hash_reorders;        /**< number of hash chain reorders */
 477     afs_uint64 salvages;             /**< online salvages since fileserver start */
 478     afs_uint64 vol_ops;              /**< volume operations since fileserver start */
 479 #endif /* AFS_DEMAND_ATTACH_FS */
 480
 481     afs_uint64 hdr_loads;            /**< header loads from disk */
 482     afs_uint64 hdr_gets;             /**< header pulls out of LRU */
 483     afs_uint64 attaches;             /**< volume attaches since fileserver start */
 484     afs_uint64 soft_detaches;        /**< soft detach ops since fileserver start */
 485
 486     /* configuration parameters */
 487     afs_uint32 hdr_cache_size;       /**< size of volume header cache */
 488 } VolPkgStats;
 489 extern VolPkgStats VStats;
 490
 491 /*
 492  * volume header cache supporting structures
 493  */
 494 struct volume_hdr_LRU_stats {
 495     afs_uint32 free;
 496     afs_uint32 used;
 497     afs_uint32 attached;
 498 };
 499
 500 struct volume_hdr_LRU_t {
 501     struct rx_queue lru;
 502     struct volume_hdr_LRU_stats stats;
 503 };
 504 extern struct volume_hdr_LRU_t volume_hdr_LRU;
 505
 506 /*
 507  * volume hash chain supporting structures
 508  */
 509 typedef struct VolumeHashChainHead {
 510     struct rx_queue queue;
 511     int len;
 512     /* someday we could put a per-chain lock here... */
 513 #ifdef AFS_DEMAND_ATTACH_FS
 514     int busy;
 515     int cacheCheck;
 516
 517     /* per-chain statistics */
 518     afs_uint64 looks;
 519     afs_uint64 gets;
 520     afs_uint64 reorders;
 521
 522     pthread_cond_t chain_busy_cv;
 523 #endif /* AFS_DEMAND_ATTACH_FS */
 524 } VolumeHashChainHead;
 525
 526 typedef struct VolumeHashTable {
 527     int Size;
 528     int Mask;
 529     VolumeHashChainHead * Table;
 530 } VolumeHashTable_t;
 531 extern VolumeHashTable_t VolumeHashTable;
 532
 533 struct VolumeHashChainStats {
 534     afs_int32 table_size;
 535     afs_int32 chain_len;
 536 #ifdef AFS_DEMAND_ATTACH_FS
 537     afs_int32 chain_cacheCheck;
 538     afs_int32 chain_busy;
 539     afs_uint64 chain_looks;
 540     afs_uint64 chain_gets;
 541     afs_uint64 chain_reorders;
 542 #endif
 543 };
 544
 545
 546 #ifdef AFS_DEMAND_ATTACH_FS
 547 /**
 548  * DAFS extended per-volume statistics.
 549  *
 550  * @note this data lives across the entire
 551  *       lifetime of the fileserver process
 552  */
 553 typedef struct VolumeStats {
 554     /* counters */
 555     afs_uint64 hash_lookups;         /**< hash table lookups */
 556     afs_uint64 hash_short_circuits;  /**< short circuited hash lookups (due to cacheCheck) */
 557     afs_uint64 hdr_loads;            /**< header loads from disk */
 558     afs_uint64 hdr_gets;             /**< header pulls out of LRU */
 559     afs_uint16 attaches;             /**< attaches of this volume since fileserver start */
 560     afs_uint16 soft_detaches;        /**< soft detaches of this volume */
 561     afs_uint16 salvages;             /**< online salvages since fileserver start */
 562     afs_uint16 vol_ops;              /**< volume operations since fileserver start */
 563
 564     /* timestamps */
 565     afs_uint32 last_attach;      /**< unix timestamp of last VAttach */
 566     afs_uint32 last_get;         /**< unix timestamp of last VGet/VHold */
 567     afs_uint32 last_promote;     /**< unix timestamp of last VLRU promote/demote */
 568     afs_uint32 last_hdr_get;     /**< unix timestamp of last GetVolumeHeader() */
 569     afs_uint32 last_hdr_load;    /**< unix timestamp of last LoadVolumeHeader() */
 570     afs_uint32 last_salvage;     /**< unix timestamp of last initiation of an online salvage */
 571     afs_uint32 last_salvage_req; /**< unix timestamp of last SALVSYNC request */
 572     afs_uint32 last_vol_op;      /**< unix timestamp of last volume operation */
 573 } VolumeStats;
 574
 575 /**
 576  * DAFS online salvager state.
 577  */
 578 typedef struct VolumeOnlineSalvage {
 579     afs_uint32 prio;            /**< number of VGetVolume's since salvage requested */
 580     int reason;                 /**< reason for requesting online salvage */
 581     byte requested;             /**< flag specifying that salvage should be scheduled */
 582     byte scheduled;             /**< flag specifying whether online salvage scheduled */
 583     byte reserved[2];           /**< padding */
 584 } VolumeOnlineSalvage;
 585
 586 /**
 587  * DAFS Volume LRU state.
 588  */
 589 typedef struct VolumeVLRUState {
 590     struct rx_queue lru;        /**< VLRU queue for this generation */
 591     VLRUQueueName idx;          /**< VLRU generation index */
 592 } VolumeVLRUState;
 593 #endif /* AFS_DEMAND_ATTACH_FS */
 594
 595 typedef struct Volume {
 596     struct rx_queue q;          /* Volume hash chain pointers */
 597     VolumeId hashid;            /* Volume number -- for hash table lookup */
 598     struct volHeader *header;   /* Cached disk data */
 599     Device device;              /* Unix device for the volume */
 600     struct DiskPartition64
 601      *partition;                /* Information about the Unix partition */
 602     struct vnodeIndex {
 603         IHandle_t *handle;      /* Unix inode holding this index */
 604         byte *bitmap;           /* Index bitmap */
 605         afs_uint32 bitmapSize;  /* length of bitmap, in bytes */
 606         afs_uint32 bitmapOffset;        /* Which byte address of the first long to
 607                                          * start search from in bitmap */
 608     } vnodeIndex[nVNODECLASSES];
 609     IHandle_t *linkHandle;
 610     Unique nextVnodeUnique;     /* Derived originally from volume uniquifier.
 611                                  * This is the actual next version number to
 612                                  * assign; the uniquifier is bumped by 200 and
 613                                  * and written to disk every 200 file creates
 614                                  * If the volume is shutdown gracefully, the
 615                                  * uniquifier should be rewritten with the
 616                                  * value nextVnodeVersion */
 617     IHandle_t *diskDataHandle;  /* Unix inode holding general volume info */
 618     bit16 vnodeHashOffset;      /* Computed by HashOffset function in vnode.h.
 619                                  * Assigned to the volume when initialized.
 620                                  * Added to vnode number for hash table index */
 621     byte shuttingDown;          /* This volume is going to be detached */
 622     byte goingOffline;          /* This volume is going offline */
 623     bit32 cacheCheck;           /* Online sequence number to be used to invalidate vnode cache entries
 624                                  * that stayed around while a volume was offline */
 625     short nUsers;               /* Number of users of this volume header */
 626     byte needsPutBack;          /* For a volume utility, this flag is set if we need
 627                                  * to give the volume back when we detach it.  The server has
 628                                  * certain modes where it doesn't detach the volume, and
 629                                  * if we give it back spuriously, the server aborts.  This field
 630                                  * is meaningless on the file server */
 631     byte specialStatus;         /* An error code to return on VGetVolume: the
 632                                  * volume is unavailable for the reason quoted,
 633                                  * currently VBUSY or VMOVED */
 634     afs_uint32 checkoutMode;    /* for volume utilities, mode number for current checkout */
 635     afs_uint32 updateTime;      /* Time that this volume was put on the updated
 636                                  * volume list--the list of volumes that will be
 637                                  * salvaged should the file server crash */
 638     struct rx_queue vnode_list; /**< linked list of cached vnodes for this volume */
 639 #ifdef AFS_DEMAND_ATTACH_FS
 640     VolState attach_state;      /* what stage of attachment has been completed */
 641     afs_uint32 attach_flags;    /* flags related to attachment state */
 642     pthread_cond_t attach_cv;   /* state change condition variable */
 643     short nWaiters;             /* volume package internal ref count */
 644     int chainCacheCheck;        /* Volume hash chain cache check */
 645     struct rx_queue vol_list;   /* per-partition volume list (VByPList) */
 646
 647     VolumeOnlineSalvage salvage;  /* online salvager state */
 648     VolumeStats stats;            /* per-volume statistics */
 649     VolumeVLRUState vlru;         /* state specific to the VLRU */
 650     FSSYNC_VolOp_info * pending_vol_op;  /* fssync command info for any pending vol ops */
 651 #endif /* AFS_DEMAND_ATTACH_FS */
 652 } Volume;
 653
 654 struct volHeader {
 655     struct rx_queue lru;
 656     VolumeDiskData diskstuff;   /* General volume info read from disk */
 657     Volume *back;               /* back pointer to current volume structure */
 658 };
 659
 660 /* These macros are used to export fields within the volume header.  This was added
 661    to facilitate changing the actual representation */
 662
 663 #define V_device(vp)            ((vp)->device)
 664 #define V_partition(vp)         ((vp)->partition)
 665 #define V_diskDataHandle(vp)    ((vp)->diskDataHandle)
 666 #define V_vnodeIndex(vp)        ((vp)->vnodeIndex)
 667 #define V_nextVnodeUnique(vp)   ((vp)->nextVnodeUnique)
 668 #define V_linkHandle(vp)        ((vp)->linkHandle)
 669 #define V_checkoutMode(vp)      ((vp)->checkoutMode)
 670 #ifdef AFS_DEMAND_ATTACH_FS
 671 #define V_attachState(vp)       ((vp)->attach_state)
 672 #define V_attachFlags(vp)       ((vp)->attach_flags)
 673 #define V_attachCV(vp)          ((vp)->attach_cv)
 674 #endif /* AFS_DEMAND_ATTACH_FS */
 675
 676 /* N.B. V_id must be this, rather than vp->id, or some programs will break, probably */
 677 #define V_stamp(vp)             ((vp)->header->diskstuff.stamp)
 678 #define V_id(vp)                ((vp)->header->diskstuff.id)
 679 #define V_name(vp)              ((vp)->header->diskstuff.name)
 680 #define V_inUse(vp)             ((vp)->header->diskstuff.inUse)
 681 #define V_inService(vp)         ((vp)->header->diskstuff.inService)
 682 #define V_blessed(vp)           ((vp)->header->diskstuff.blessed)
 683 #define V_needsSalvaged(vp)     ((vp)->header->diskstuff.needsSalvaged)
 684 #define V_uniquifier(vp)        ((vp)->header->diskstuff.uniquifier)
 685 #define V_type(vp)              ((vp)->header->diskstuff.type)
 686 #define V_parentId(vp)          ((vp)->header->diskstuff.parentId)
 687 #define V_cloneId(vp)           ((vp)->header->diskstuff.cloneId)
 688 #define V_backupId(vp)          ((vp)->header->diskstuff.backupId)
 689 #define V_restoredFromId(vp)    ((vp)->header->diskstuff.restoredFromId)
 690 #define V_needsCallback(vp)     ((vp)->header->diskstuff.needsCallback)
 691 #define V_destroyMe(vp)         ((vp)->header->diskstuff.destroyMe)
 692 #define V_dontSalvage(vp)       ((vp)->header->diskstuff.dontSalvage)
 693 #define V_maxquota(vp)          ((vp)->header->diskstuff.maxquota)
 694 #define V_minquota(vp)          ((vp)->header->diskstuff.minquota)
 695 #define V_maxfiles(vp)          ((vp)->header->diskstuff.maxfiles)
 696 #define V_accountNumber(vp)     ((vp)->header->diskstuff.accountNumber)
 697 #define V_owner(vp)             ((vp)->header->diskstuff.owner)
 698 #define V_filecount(vp)         ((vp)->header->diskstuff.filecount)
 699 #define V_diskused(vp)          ((vp)->header->diskstuff.diskused)
 700 #define V_dayUse(vp)            ((vp)->header->diskstuff.dayUse)
 701 #define V_weekUse(vp)           ((vp)->header->diskstuff.weekUse)
 702 #define V_dayUseDate(vp)        ((vp)->header->diskstuff.dayUseDate)
 703 #define V_creationDate(vp)      ((vp)->header->diskstuff.creationDate)
 704 #define V_accessDate(vp)        ((vp)->header->diskstuff.accessDate)
 705 #define V_updateDate(vp)        ((vp)->header->diskstuff.updateDate)
 706 #define V_expirationDate(vp)    ((vp)->header->diskstuff.expirationDate)
 707 #define V_backupDate(vp)        ((vp)->header->diskstuff.backupDate)
 708 #define V_copyDate(vp)          ((vp)->header->diskstuff.copyDate)
 709 #define V_offlineMessage(vp)    ((vp)->header->diskstuff.offlineMessage)
 710 #define V_disk(vp)              ((vp)->header->diskstuff)
 711 #define V_motd(vp)              ((vp)->header->diskstuff.motd)
 712 #if OPENAFS_VOL_STATS
 713 #define V_stat_initialized(vp)  ((vp)->header->diskstuff.stat_initialized)
 714 #define V_stat_area(vp)         (((vp)->header->diskstuff.stat_reads))
 715 #define V_stat_reads(vp, idx)   (((vp)->header->diskstuff.stat_reads)[idx])
 716 #define V_stat_writes(vp, idx)  (((vp)->header->diskstuff.stat_writes)[idx])
 717 #define V_stat_fileSameAuthor(vp, idx) (((vp)->header->diskstuff.stat_fileSameAuthor)[idx])
 718 #define V_stat_fileDiffAuthor(vp, idx) (((vp)->header->diskstuff.stat_fileDiffAuthor)[idx])
 719 #define V_stat_dirSameAuthor(vp, idx)  (((vp)->header->diskstuff.stat_dirSameAuthor)[idx])
 720 #define V_stat_dirDiffAuthor(vp, idx)  (((vp)->header->diskstuff.stat_dirDiffAuthor)[idx])
 721 #endif /* OPENAFS_VOL_STATS */
 722 #define V_volUpCounter(vp)              ((vp)->header->diskstuff.volUpdateCounter)
 723
 724 /* File offset computations.  The offset values in the volume header are
 725    computed with these macros -- when the file is written only!! */
 726 #define VOLUME_MOUNT_TABLE_OFFSET(Volume)       (sizeof (VolumeDiskData))
 727 #define VOLUME_BITMAP_OFFSET(Volume)    \
 728         (sizeof (VolumeDiskData) + (Volume)->disk.mountTableSize)
 729
 730
 731 extern char *VSalvageMessage;   /* Canonical message when a volume is forced
 732                                  * offline */
 733 extern Volume *VGetVolume(Error * ec, Error * client_ec, VolId volumeId);
 734 extern Volume *VGetVolume_r(Error * ec, VolId volumeId);
 735 extern void VPutVolume(Volume *);
 736 extern void VPutVolume_r(Volume *);
 737 extern void VOffline(Volume * vp, char *message);
 738 extern void VOffline_r(Volume * vp, char *message);
 739 extern int VConnectFS(void);
 740 extern int VConnectFS_r(void);
 741 extern void VDisconnectFS(void);
 742 extern void VDisconnectFS_r(void);
 743 extern int VChildProcReconnectFS(void);
 744 extern Volume *VAttachVolume(Error * ec, VolumeId volumeId, int mode);
 745 extern Volume *VAttachVolume_r(Error * ec, VolumeId volumeId, int mode);
 746 extern Volume *VCreateVolume(Error * ec, char *partname, VolId volumeId,
 747                              VolId parentId);
 748 extern Volume *VCreateVolume_r(Error * ec, char *partname, VolId volumeId,
 749                                VolId parentId);
 750 extern VnodeId VAllocBitmapEntry(Error * ec, Volume * vp,
 751                                  struct vnodeIndex *index);
 752 extern VnodeId VAllocBitmapEntry_r(Error * ec, Volume * vp,
 753                                    struct vnodeIndex *index, int flags);
 754 extern void VFreeBitMapEntry(Error * ec, register struct vnodeIndex *index,
 755                              unsigned bitNumber);
 756 extern void VFreeBitMapEntry_r(Error * ec, register struct vnodeIndex *index,
 757                                unsigned bitNumber);
 758 extern int VolumeNumber(char *name);
 759 extern char *VolumeExternalName(VolumeId volumeId);
 760 extern Volume *VAttachVolumeByName(Error * ec, char *partition, char *name,
 761                                    int mode);
 762 extern Volume *VAttachVolumeByName_r(Error * ec, char *partition, char *name,
 763                                      int mode);
 764 extern void VShutdown(void);
 765 extern void VUpdateVolume(Error * ec, Volume * vp);
 766 extern void VUpdateVolume_r(Error * ec, Volume * vp, int flags);
 767 extern void VAddToVolumeUpdateList(Error * ec, Volume * vp);
 768 extern void VAddToVolumeUpdateList_r(Error * ec, Volume * vp);
 769 extern void VDetachVolume(Error * ec, Volume * vp);
 770 extern void VDetachVolume_r(Error * ec, Volume * vp);
 771 extern void VForceOffline(Volume * vp);
 772 extern void VForceOffline_r(Volume * vp, int flags);
 773 extern void VBumpVolumeUsage(register Volume * vp);
 774 extern void VBumpVolumeUsage_r(register Volume * vp);
 775 extern void VSetDiskUsage(void);
 776 extern void VPrintCacheStats(void);
 777 extern void VReleaseVnodeFiles_r(Volume * vp);
 778 extern void VCloseVnodeFiles_r(Volume * vp);
 779 extern struct DiskPartition64 *VGetPartition(char *name, int abortp);
 780 extern struct DiskPartition64 *VGetPartition_r(char *name, int abortp);
 781 extern int VInitVolumePackage(ProgramType pt, afs_uint32 nLargeVnodes,
 782                               afs_uint32 nSmallVnodes, int connect, afs_uint32 volcache);
 783 extern void DiskToVolumeHeader(VolumeHeader_t * h, VolumeDiskHeader_t * dh);
 784 extern void VolumeHeaderToDisk(VolumeDiskHeader_t * dh, VolumeHeader_t * h);
 785 extern void VTakeOffline_r(register Volume * vp);
 786 extern void VTakeOffline(register Volume * vp);
 787 extern Volume * VLookupVolume_r(Error * ec, VolId volumeId, Volume * hint);
 788 extern void VGetVolumePath(Error * ec, VolId volumeId, char **partitionp,
 789                            char **namep);
 790 #ifdef AFS_DEMAND_ATTACH_FS
 791 extern Volume *VPreAttachVolumeByName(Error * ec, char *partition, char *name);
 792 extern Volume *VPreAttachVolumeByName_r(Error * ec, char *partition, char *name);
 793 extern Volume *VPreAttachVolumeById_r(Error * ec, char * partition,
 794                                       VolId volumeId);
 795 extern Volume *VPreAttachVolumeByVp_r(Error * ec, struct DiskPartition64 * partp,
 796                                       Volume * vp, VolId volume_id);
 797 extern Volume *VGetVolumeByVp_r(Error * ec, Volume * vp);
 798 extern int VShutdownByPartition_r(struct DiskPartition64 * dp);
 799 extern int VShutdownVolume_r(Volume * vp);
 800 extern int VConnectSALV(void);
 801 extern int VConnectSALV_r(void);
 802 extern int VReconnectSALV(void);
 803 extern int VReconnectSALV_r(void);
 804 extern int VDisconnectSALV(void);
 805 extern int VDisconnectSALV_r(void);
 806 extern void VPrintExtendedCacheStats(int flags);
 807 extern void VPrintExtendedCacheStats_r(int flags);
 808 extern void VLRU_SetOptions(int option, afs_uint32 val);
 809 extern int VSetVolHashSize(int logsize);
 810 extern int VRequestSalvage_r(Error * ec, Volume * vp, int reason, int flags);
 811 extern int VRegisterVolOp_r(Volume * vp, FSSYNC_VolOp_info * vopinfo);
 812 extern int VDeregisterVolOp_r(Volume * vp);
 813 extern void VCancelReservation_r(Volume * vp);
 814 #endif /* AFS_DEMAND_ATTACH_FS */
 815 extern int VVolOpLeaveOnline_r(Volume * vp, FSSYNC_VolOp_info * vopinfo);
 816 extern int VVolOpSetVBusy_r(Volume * vp, FSSYNC_VolOp_info * vopinfo);
 817
 818
 819 /* Naive formula relating number of file size to number of 1K blocks in file */
 820 /* Note:  we charge 1 block for 0 length files so the user can't store
 821    an inifite number of them; for most files, we give him the inode, vnode,
 822    and indirect block overhead, for FREE! */
 823 #define nBlocks(bytes) ((afs_sfsize_t)((bytes) == 0? 1: (((afs_sfsize_t)(bytes))+1023)/1024))
 824
 825 /* Client process id -- file server sends a Check volumes signal back to the client at this pid */
 826 #define CLIENTPID       "/vice/vol/clientpid"
 827
 828 /* Modes of attachment, for VAttachVolume[ByName] to convey to the file server */
 829 #define V_READONLY 1            /* Absolutely no updates will be done to the volume */
 830 #define V_CLONE    2            /* Cloning the volume:  if it is read/write, then directory
 831                                  * version numbers will change.  Header will be updated.  If
 832                                  * the volume is read-only, the file server may continue to
 833                                  * server it; it may also continue to server it in read/write
 834                                  * mode if the writes are deferred */
 835 #define V_VOLUPD   3            /* General update or volume purge is possible.  Volume must
 836                                  * go offline */
 837 #define V_DUMP     4            /* A dump of the volume is requested; the volume can be served
 838                                  * read-only during this time */
 839 #define V_SECRETLY 5            /* Secret attach of the volume.  This is used to attach a volume
 840                                  * which the file server doesn't know about--and which it shouldn't
 841                                  * know about yet, since the volume has just been created and
 842                                  * is somewhat bogus.  Required to make sure that a file server
 843                                  * never knows about more than one copy of the same volume--when
 844                                  * a volume is moved from one partition to another on a single
 845                                  * server */
 846 #define V_PEEK     6            /* "Peek" at the volume without telling the fileserver.  This is
 847                                  * similar to V_SECRETLY, but read-only.  It is used in cases where
 848                                  * not impacting fileserver performance is more important than
 849                                  * getting the most recent data. */
 850
 851
 852
 853 /* VUpdateVolume_r flags */
 854 #define VOL_UPDATE_WAIT          0x1  /* for demand attach, wait for other exclusive ops to end */
 855 #define VOL_UPDATE_NOFORCEOFF    0x2  /* don't force offline on failure. this is to prevent
 856                                        * infinite recursion between vupdate and vforceoff */
 857
 858 /* VForceOffline_r flags */
 859 #define VOL_FORCEOFF_NOUPDATE    0x1  /* don't force update on forceoff. this is to prevent
 860                                        * infinite recursion between vupdate and vforceoff */
 861
 862 /* VSyncVolume_r flags */
 863 #define VOL_SYNC_WAIT            0x1  /* for demand attach, wait for other exclusive ops to end */
 864
 865 /* VAllocBitmapEntry_r flags */
 866 #define VOL_ALLOC_BITMAP_WAIT    0x1  /* for demand attach, wait for other exclusive ops to end */
 867
 868 /* VRequestSalvage_r flags */
 869 #define VOL_SALVAGE_INVALIDATE_HEADER 0x1 /* for demand attach fs, invalidate volume header cache */
 870
 871
 872 #if     defined(NEARINODE_HINT)
 873 #define V_pref(vp,nearInode)  nearInodeHash(V_id(vp),(nearInode)); (nearInode) %= V_partition(vp)->f_files
 874 #else
 875 #define V_pref(vp,nearInode)   nearInode = 0
 876 #endif /* NEARINODE_HINT */
 877
 878 #endif /* __volume_h */