src/WINNT/afsd/cm_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
  10 #include <afsconfig.h>
  11 #include <afs/param.h>
  12 #include <afs/stds.h>
  13
  14 #include <roken.h>
  15
  16 #include <windows.h>
  17 #include <winsock2.h>
  18 #include <nb30.h>
  19 #include <string.h>
  20 #include <strsafe.h>
  21 #include <malloc.h>
  22 #include "afsd.h"
  23 #include "cm_getaddrs.h"
  24 #include <osi.h>
  25 #include <rx/rx.h>
  26
  27 osi_rwlock_t cm_volumeLock;
  28
  29 long
  30 cm_ValidateVolume(void)
  31 {
  32     cm_volume_t * volp;
  33     afs_uint32 count;
  34
  35     for (volp = cm_data.allVolumesp, count = 0; volp; volp=volp->allNextp, count++) {
  36
  37         if ( volp < (cm_volume_t *)cm_data.volumeBaseAddress ||
  38              volp >= (cm_volume_t *)cm_data.cellBaseAddress) {
  39             afsi_log("cm_ValidateVolume failure: out of range cm_volume_t pointers");
  40             fprintf(stderr, "cm_ValidateVolume failure: out of range cm_volume_t pointers\n");
  41             return -10;
  42         }
  43
  44         if ( volp->magic != CM_VOLUME_MAGIC ) {
  45             afsi_log("cm_ValidateVolume failure: volp->magic != CM_VOLUME_MAGIC");
  46             fprintf(stderr, "cm_ValidateVolume failure: volp->magic != CM_VOLUME_MAGIC\n");
  47             return -1;
  48         }
  49
  50         if ( volp->cellp < (cm_cell_t *)cm_data.cellBaseAddress ||
  51              volp->cellp >= (cm_cell_t *)cm_data.aclBaseAddress) {
  52             afsi_log("cm_ValidateVolume failure: out of range cm_cell_t pointers");
  53             fprintf(stderr, "cm_ValidateVolume failure: out of range cm_cell_t pointers\n");
  54             return -11;
  55         }
  56
  57         if ( volp->cellp && volp->cellp->magic != CM_CELL_MAGIC ) {
  58             afsi_log("cm_ValidateVolume failure: volp->cellp->magic != CM_CELL_MAGIC");
  59             fprintf(stderr, "cm_ValidateVolume failure: volp->cellp->magic != CM_CELL_MAGIC\n");
  60             return -2;
  61         }
  62
  63         if ( volp->allNextp) {
  64             if ( volp->allNextp < (cm_volume_t *)cm_data.volumeBaseAddress ||
  65                  volp->allNextp >= (cm_volume_t *)cm_data.cellBaseAddress) {
  66                 afsi_log("cm_ValidateVolume failure: out of range cm_volume_t pointers");
  67                 fprintf(stderr, "cm_ValidateVolume failure: out of range cm_volume_t pointers\n");
  68                 return -12;
  69             }
  70
  71             if ( volp->allNextp->magic != CM_VOLUME_MAGIC ) {
  72                 afsi_log("cm_ValidateVolume failure: volp->allNextp->magic != CM_VOLUME_MAGIC");
  73                 fprintf(stderr, "cm_ValidateVolume failure: volp->allNextp->magic != CM_VOLUME_MAGIC\n");
  74                 return -3;
  75             }
  76         }
  77
  78         if ( count != 0 && volp == cm_data.allVolumesp ||
  79              count > cm_data.maxVolumes ) {
  80             afsi_log("cm_ValidateVolume failure: cm_data.allVolumep loop detected");
  81             fprintf(stderr, "cm_ValidateVolume failure: cm_data.allVolumep loop detected\n");
  82             return -4;
  83         }
  84     }
  85
  86     if ( count != cm_data.currentVolumes ) {
  87         afsi_log("cm_ValidateVolume failure: count != cm_data.currentVolumes");
  88         fprintf(stderr, "cm_ValidateVolume failure: count != cm_data.currentVolumes\n");
  89         return -5;
  90     }
  91
  92     return 0;
  93 }
  94
  95 long
  96 cm_ShutdownVolume(void)
  97 {
  98     cm_volume_t * volp;
  99
 100     for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
 101         afs_uint32 volType;
 102         for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
 103             if (volp->vol[volType].ID)
 104                 cm_VolumeStatusNotification(volp, volp->vol[volType].ID, volp->vol[volType].state, vl_alldown);
 105         }
 106         volp->cbExpiresRO = 0;
 107         volp->cbIssuedRO = 0;
 108         volp->cbServerpRO = NULL;
 109         volp->volumeSizeRO = 0;
 110         _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_RO_SIZE_VALID);
 111
 112         lock_FinalizeRWLock(&volp->rw);
 113     }
 114
 115     cm_getaddrsShutdown();
 116
 117     return 0;
 118 }
 119
 120 void cm_InitVolume(int newFile, long maxVols)
 121 {
 122     static osi_once_t once;
 123
 124     if (osi_Once(&once)) {
 125         lock_InitializeRWLock(&cm_volumeLock, "cm global volume lock", LOCK_HIERARCHY_VOLUME_GLOBAL);
 126
 127         if ( newFile ) {
 128             cm_data.allVolumesp = NULL;
 129             cm_data.currentVolumes = 0;
 130             cm_data.maxVolumes = maxVols;
 131             memset(cm_data.volumeNameHashTablep, 0, sizeof(cm_volume_t *) * cm_data.volumeHashTableSize);
 132             memset(cm_data.volumeRWIDHashTablep, 0, sizeof(cm_volume_t *) * cm_data.volumeHashTableSize);
 133             memset(cm_data.volumeROIDHashTablep, 0, sizeof(cm_volume_t *) * cm_data.volumeHashTableSize);
 134             memset(cm_data.volumeBKIDHashTablep, 0, sizeof(cm_volume_t *) * cm_data.volumeHashTableSize);
 135             cm_data.volumeLRUFirstp = cm_data.volumeLRULastp = NULL;
 136         } else {
 137             cm_volume_t * volp;
 138
 139             for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
 140                 afs_uint32 volType;
 141
 142                 lock_InitializeRWLock(&volp->rw, "cm_volume_t rwlock", LOCK_HIERARCHY_VOLUME);
 143                 _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_RESET);
 144                 _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_UPDATING_VL);
 145                 volp->lastUpdateTime = 0;
 146                 for (volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
 147                     volp->vol[volType].state = vl_unknown;
 148                     volp->vol[volType].serversp = NULL;
 149                     if (volp->vol[volType].ID)
 150                         cm_VolumeStatusNotification(volp, volp->vol[volType].ID, vl_unknown, volp->vol[volType].state);
 151                 }
 152                 volp->cbExpiresRO = 0;
 153                 volp->cbIssuedRO = 0;
 154                 volp->cbServerpRO = NULL;
 155                 volp->volumeSizeRO = 0;
 156                 _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_RO_SIZE_VALID);
 157             }
 158         }
 159
 160         cm_getaddrsInit();
 161
 162         osi_EndOnce(&once);
 163     }
 164 }
 165
 166
 167 /* returns true if the id is a decimal integer, in which case we interpret it
 168  * as an id.  make the cache manager much simpler.
 169  * Stolen from src/volser/vlprocs.c */
 170 int
 171 cm_VolNameIsID(char *aname)
 172 {
 173     int tc;
 174     while (tc = *aname++) {
 175         if (tc > '9' || tc < '0')
 176             return 0;
 177     }
 178     return 1;
 179 }
 180
 181
 182 /*
 183  * Update a volume.  Caller holds a write lock on the volume (volp->rw).
 184  *
 185  *
 186  *  shadow / openafs / jhutz@CS.CMU.EDU {ANDREW.CMU.EDU}  01:38    (JHutz)
 187  *    Yes, we support multihomed fileservers.
 188  *    Since before we got the code from IBM.
 189  *    But to find out about multiple addresses on a multihomed server, you need
 190  *    to use VL_GetEntryByNameU and VL_GetAddrsU.  If you use
 191  *    VL_GetEntryByNameO or VL_GetEntryByNameN, the vlserver just gives you one
 192  *    address per server.
 193  *  shadow / openafs / jhutz@CS.CMU.EDU {ANDREW.CMU.EDU}  01:39    (JHutz)
 194  *    see src/afs/afs_volume.c, paying particular attention to
 195  *    afs_NewVolumeByName, afs_SetupVolume, and InstallUVolumeEntry
 196  *  shadow / openafs / jaltman {ANDREW.CMU.EDU}  01:40    (Jeffrey Altman)
 197  *    thanks.  The windows client calls the 0 versions.
 198  *  shadow / openafs / jhutz@CS.CMU.EDU {ANDREW.CMU.EDU}  01:51    (JHutz)
 199  *    Oh.  Ew.
 200  *    By not using the N versions, you only get up to 8 sites instead of 13.
 201  *    By not using the U versions, you don't get to know about multihomed serve
 202  *  shadow / openafs / jhutz@CS.CMU.EDU {ANDREW.CMU.EDU}  01:52    (JHutz)
 203  *    Of course, you probably want to support the older versions for backward
 204  *    compatibility.  If you do that, you need to call the newest interface
 205  *    first, and fall back to successively older versions if you get
 206  *    RXGEN_OPCODE.
 207  */
 208 static long
 209 cm_GetEntryByName( struct cm_cell *cellp, const char *name,
 210                    struct vldbentry *vldbEntryp,
 211                    struct nvldbentry *nvldbEntryp,
 212                    struct uvldbentry *uvldbEntryp,
 213                    int *methodp,
 214                    cm_user_t *userp,
 215                    cm_req_t *reqp
 216                    )
 217 {
 218     long code;
 219     cm_conn_t *connp;
 220     struct rx_connection * rxconnp;
 221
 222     osi_Log2(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s",
 223               osi_LogSaveString(afsd_logp,cellp->name),
 224               osi_LogSaveString(afsd_logp,name));
 225     do {
 226
 227         code = cm_ConnByMServers(cellp->vlServersp, FALSE, userp, reqp, &connp);
 228         if (code)
 229             continue;
 230
 231         rxconnp = cm_GetRxConn(connp);
 232         code = VL_GetEntryByNameU(rxconnp, name, uvldbEntryp);
 233         *methodp = 2;
 234         if ( code == RXGEN_OPCODE )
 235         {
 236             code = VL_GetEntryByNameN(rxconnp, name, nvldbEntryp);
 237             *methodp = 1;
 238         }
 239         if ( code == RXGEN_OPCODE ) {
 240             code = VL_GetEntryByNameO(rxconnp, name, vldbEntryp);
 241             *methodp = 0;
 242         }
 243         rx_PutConnection(rxconnp);
 244     } while (cm_Analyze(connp, userp, reqp, NULL, cellp, 0, NULL, NULL, &cellp->vlServersp, NULL, code));
 245     code = cm_MapVLRPCError(code, reqp);
 246     if ( code )
 247         osi_Log3(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s FAILURE, code 0x%x",
 248                   osi_LogSaveString(afsd_logp,cellp->name),
 249                   osi_LogSaveString(afsd_logp,name), code);
 250     else
 251         osi_Log2(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s SUCCESS",
 252                   osi_LogSaveString(afsd_logp,cellp->name),
 253                   osi_LogSaveString(afsd_logp,name));
 254     return code;
 255 }
 256
 257 static long
 258 cm_GetEntryByID( struct cm_cell *cellp, afs_uint32 id,
 259                  struct vldbentry *vldbEntryp,
 260                  struct nvldbentry *nvldbEntryp,
 261                  struct uvldbentry *uvldbEntryp,
 262                  int *methodp,
 263                  cm_user_t *userp,
 264                  cm_req_t *reqp
 265                  )
 266 {
 267     char name[64];
 268
 269     StringCbPrintf(name, sizeof(name), "%u", id);
 270
 271     return cm_GetEntryByName(cellp, name, vldbEntryp, nvldbEntryp, uvldbEntryp, methodp, userp, reqp);
 272 }
 273
 274 long cm_UpdateVolumeLocation(struct cm_cell *cellp, cm_user_t *userp, cm_req_t *reqp,
 275                      cm_volume_t *volp)
 276 {
 277     int i;
 278     afs_uint32 j;
 279     cm_serverRef_t *tsrp;
 280     cm_server_t *tsp;
 281     struct sockaddr_in tsockAddr;
 282     long tflags;
 283     u_long tempAddr;
 284     struct vldbentry vldbEntry;
 285     struct nvldbentry nvldbEntry;
 286     struct uvldbentry uvldbEntry;
 287     int method = -1;
 288     int ROcount = 0;
 289     int isMixed = 0;
 290     long code;
 291     enum volstatus rwNewstate = vl_online;
 292     enum volstatus roNewstate = vl_online;
 293     enum volstatus bkNewstate = vl_online;
 294 #ifdef AFS_FREELANCE_CLIENT
 295     int freelance = 0;
 296 #endif
 297     afs_uint32 volType;
 298     time_t now;
 299
 300     lock_AssertWrite(&volp->rw);
 301
 302     /*
 303      * If the last volume update was in the last five
 304      * minutes and it did not exist, then avoid the RPC
 305      * and return No Such Volume immediately.
 306      */
 307     now = time(NULL);
 308     if ((volp->flags & CM_VOLUMEFLAG_NOEXIST) &&
 309         (now < volp->lastUpdateTime + 600))
 310     {
 311         return CM_ERROR_NOSUCHVOLUME;
 312     }
 313
 314 #ifdef AFS_FREELANCE_CLIENT
 315     if (cellp->cellID == AFS_FAKE_ROOT_CELL_ID)
 316     {
 317         freelance = 1;
 318         memset(&vldbEntry, 0, sizeof(vldbEntry));
 319         vldbEntry.flags |= VLF_RWEXISTS;
 320         vldbEntry.volumeId[0] = AFS_FAKE_ROOT_VOL_ID;
 321         code = 0;
 322         method = 0;
 323     } else
 324 #endif
 325     {
 326         while (volp->flags & CM_VOLUMEFLAG_UPDATING_VL) {
 327             osi_Log3(afsd_logp, "cm_UpdateVolumeLocation sleeping name %s:%s flags 0x%x",
 328                      volp->cellp->name, volp->namep, volp->flags);
 329             osi_SleepW((LONG_PTR) &volp->flags, &volp->rw);
 330             lock_ObtainWrite(&volp->rw);
 331             osi_Log3(afsd_logp, "cm_UpdateVolumeLocation awake name %s:%s flags 0x%x",
 332                      volp->cellp->name, volp->namep, volp->flags);
 333             if (!(volp->flags & CM_VOLUMEFLAG_RESET)) {
 334                 osi_Log3(afsd_logp, "cm_UpdateVolumeLocation nothing to do, waking others name %s:%s flags 0x%x",
 335                          volp->cellp->name, volp->namep, volp->flags);
 336                 osi_Wakeup((LONG_PTR) &volp->flags);
 337                 return 0;
 338             }
 339             now = time(NULL);
 340         }
 341
 342         /* Do not query again if the last update attempt failed in the last 60 seconds */
 343         if ((volp->flags & CM_VOLUMEFLAG_RESET) && (volp->lastUpdateTime > now - 60))
 344         {
 345             osi_Log3(afsd_logp, "cm_UpdateVolumeLocation unsuccessful update in last 60 seconds -- name %s:%s flags 0x%x",
 346                       volp->cellp->name, volp->namep, volp->flags);
 347             return(CM_ERROR_ALLDOWN);
 348         }
 349
 350         _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_UPDATING_VL);
 351
 352         /* Do not hold the volume lock across the RPC calls */
 353         lock_ReleaseWrite(&volp->rw);
 354
 355         if (cellp->flags & CM_CELLFLAG_VLSERVER_INVALID) {
 356             cellp = cm_UpdateCell(cellp, 0);
 357             if (cellp == NULL) {
 358                 lock_ObtainWrite(&volp->rw);
 359                 _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_UPDATING_VL);
 360                 return(CM_ERROR_NOSUCHCELL);
 361             }
 362         }
 363
 364         /* now we have volume structure locked and held; make RPC to fill it */
 365         code = cm_GetEntryByName(cellp, volp->namep, &vldbEntry, &nvldbEntry,
 366                                  &uvldbEntry,
 367                                  &method, userp, reqp);
 368
 369         /* We can end up here with code == CM_ERROR_NOSUCHVOLUME if the base volume name
 370          * does not exist and is not a numeric string but there might exist a .readonly volume.
 371          * If the base name doesn't exist we will not care about the .backup that might be left
 372          * behind since there should be no method to access it.
 373          */
 374         if (code == CM_ERROR_NOSUCHVOLUME &&
 375              _atoi64(volp->namep) == 0 &&
 376              volp->vol[RWVOL].ID == 0 &&
 377              strlen(volp->namep) < (VL_MAXNAMELEN - 9)) {
 378             char name[VL_MAXNAMELEN];
 379
 380             snprintf(name, VL_MAXNAMELEN, "%s.readonly", volp->namep);
 381
 382             /* now we have volume structure locked and held; make RPC to fill it */
 383             code = cm_GetEntryByName(cellp, name, &vldbEntry, &nvldbEntry,
 384                                      &uvldbEntry,
 385                                      &method, userp, reqp);
 386         }
 387
 388         /*
 389          * What if there was a volume rename?  The volume name no longer exists but the
 390          * volume id might.  Try to refresh the volume location information based one
 391          * of the readwrite or readonly volume id.
 392          */
 393         if (code == CM_ERROR_NOSUCHVOLUME) {
 394             if (volp->vol[RWVOL].ID != 0) {
 395                 code = cm_GetEntryByID(cellp, volp->vol[RWVOL].ID, &vldbEntry, &nvldbEntry,
 396                                        &uvldbEntry,
 397                                        &method, userp, reqp);
 398             } else if (volp->vol[ROVOL].ID != 0) {
 399                 code = cm_GetEntryByID(cellp, volp->vol[ROVOL].ID, &vldbEntry, &nvldbEntry,
 400                                        &uvldbEntry,
 401                                        &method, userp, reqp);
 402             }
 403         }
 404         lock_ObtainWrite(&volp->rw);
 405     }
 406
 407     if (code == 0) {
 408         afs_int32 flags;
 409         afs_int32 nServers;
 410         afs_int32 rwID;
 411         afs_int32 roID;
 412         afs_int32 bkID;
 413         afs_int32 serverNumber[NMAXNSERVERS];
 414         afs_int32 serverUnique[NMAXNSERVERS];
 415         afs_int32 serverFlags[NMAXNSERVERS];
 416         afsUUID   serverUUID[NMAXNSERVERS];
 417         afs_int32 rwServers_alldown = 1;
 418         afs_int32 roServers_alldown = 1;
 419         afs_int32 bkServers_alldown = 1;
 420         char      name[VL_MAXNAMELEN];
 421
 422 #ifdef AFS_FREELANCE_CLIENT
 423         if (freelance)
 424             rwServers_alldown = 0;
 425 #endif
 426
 427         /* clear out old bindings */
 428         for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
 429             if (volp->vol[volType].serversp)
 430                 cm_FreeServerList(&volp->vol[volType].serversp, CM_FREESERVERLIST_DELETE);
 431         }
 432
 433         memset(serverUUID, 0, sizeof(serverUUID));
 434         memset(serverUnique, 0, sizeof(serverUnique));
 435
 436         switch ( method ) {
 437         case 0:
 438             flags = vldbEntry.flags;
 439             nServers = vldbEntry.nServers;
 440             rwID = vldbEntry.volumeId[0];
 441             roID = vldbEntry.volumeId[1];
 442             bkID = vldbEntry.volumeId[2];
 443             for ( i=0; i<nServers; i++ ) {
 444                 serverFlags[i] = vldbEntry.serverFlags[i];
 445                 serverNumber[i] = vldbEntry.serverNumber[i];
 446             }
 447             strncpy(name, vldbEntry.name, VL_MAXNAMELEN);
 448             name[VL_MAXNAMELEN - 1] = '\0';
 449             break;
 450         case 1:
 451             flags = nvldbEntry.flags;
 452             nServers = nvldbEntry.nServers;
 453             rwID = nvldbEntry.volumeId[0];
 454             roID = nvldbEntry.volumeId[1];
 455             bkID = nvldbEntry.volumeId[2];
 456             for ( i=0; i<nServers; i++ ) {
 457                 serverFlags[i] = nvldbEntry.serverFlags[i];
 458                 serverNumber[i] = nvldbEntry.serverNumber[i];
 459             }
 460             strncpy(name, nvldbEntry.name, VL_MAXNAMELEN);
 461             name[VL_MAXNAMELEN - 1] = '\0';
 462             break;
 463         case 2:
 464             flags = uvldbEntry.flags;
 465             nServers = uvldbEntry.nServers;
 466             rwID = uvldbEntry.volumeId[0];
 467             roID = uvldbEntry.volumeId[1];
 468             bkID = uvldbEntry.volumeId[2];
 469             for ( i=0, j=0; code == 0 && i<nServers && j<NMAXNSERVERS; i++ ) {
 470                 if ( !(uvldbEntry.serverFlags[i] & VLSF_UUID) ) {
 471                     serverFlags[j] = uvldbEntry.serverFlags[i];
 472                     serverNumber[j] = uvldbEntry.serverNumber[i].time_low;
 473                     j++;
 474                 } else {
 475                     code = cm_GetAddrsU(cellp, userp, reqp,
 476                                         &uvldbEntry.serverNumber[i],
 477                                         uvldbEntry.serverUnique[i],
 478                                         uvldbEntry.serverFlags[i], &j,
 479                                         serverFlags, serverNumber,
 480                                         serverUUID, serverUnique);
 481                     if (code == CM_ERROR_RETRY)
 482                         continue;
 483                 }
 484             }
 485             nServers = j;                                       /* update the server count */
 486             strncpy(name, uvldbEntry.name, VL_MAXNAMELEN);
 487             name[VL_MAXNAMELEN - 1] = '\0';
 488             break;
 489         }
 490
 491         /* decode the response */
 492         lock_ObtainWrite(&cm_volumeLock);
 493         if (!cm_VolNameIsID(volp->namep)) {
 494             size_t    len;
 495
 496             len = strlen(name);
 497
 498             if (len >= 8 && strcmp(name + len - 7, ".backup") == 0) {
 499                 name[len - 7] = '\0';
 500             } else if (len >= 10 && strcmp(name + len - 9, ".readonly") == 0) {
 501                 name[len - 9] = '\0';
 502             }
 503
 504             osi_Log2(afsd_logp, "cm_UpdateVolume name %s -> %s",
 505                      osi_LogSaveString(afsd_logp,volp->namep), osi_LogSaveString(afsd_logp,name));
 506
 507             if (volp->qflags & CM_VOLUME_QFLAG_IN_HASH)
 508                 cm_RemoveVolumeFromNameHashTable(volp);
 509
 510             strcpy(volp->namep, name);
 511
 512             cm_AddVolumeToNameHashTable(volp);
 513         }
 514
 515         if (flags & VLF_DFSFILESET) {
 516             _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_DFS_VOLUME);
 517             osi_Log1(afsd_logp, "cm_UpdateVolume Volume Group '%s' is a DFS File Set.  Correct behavior is not implemented.",
 518                      osi_LogSaveString(afsd_logp, volp->namep));
 519         }
 520
 521         if (flags & VLF_RWEXISTS) {
 522             if (volp->vol[RWVOL].ID != rwID) {
 523                 if (volp->vol[RWVOL].qflags & CM_VOLUME_QFLAG_IN_HASH)
 524                     cm_RemoveVolumeFromIDHashTable(volp, RWVOL);
 525                 volp->vol[RWVOL].ID = rwID;
 526                 cm_AddVolumeToIDHashTable(volp, RWVOL);
 527             }
 528         } else {
 529             if (volp->vol[RWVOL].qflags & CM_VOLUME_QFLAG_IN_HASH)
 530                 cm_RemoveVolumeFromIDHashTable(volp, RWVOL);
 531             volp->vol[RWVOL].ID = 0;
 532         }
 533         if (flags & VLF_ROEXISTS) {
 534             if (volp->vol[ROVOL].ID != roID) {
 535                 if (volp->vol[ROVOL].qflags & CM_VOLUME_QFLAG_IN_HASH)
 536                     cm_RemoveVolumeFromIDHashTable(volp, ROVOL);
 537                 volp->vol[ROVOL].ID = roID;
 538                 cm_AddVolumeToIDHashTable(volp, ROVOL);
 539             }
 540         } else {
 541             if (volp->vol[ROVOL].qflags & CM_VOLUME_QFLAG_IN_HASH)
 542                 cm_RemoveVolumeFromIDHashTable(volp, ROVOL);
 543             volp->vol[ROVOL].ID = 0;
 544         }
 545         if (flags & VLF_BACKEXISTS) {
 546             if (volp->vol[BACKVOL].ID != bkID) {
 547                 if (volp->vol[BACKVOL].qflags & CM_VOLUME_QFLAG_IN_HASH)
 548                     cm_RemoveVolumeFromIDHashTable(volp, BACKVOL);
 549                 volp->vol[BACKVOL].ID = bkID;
 550                 cm_AddVolumeToIDHashTable(volp, BACKVOL);
 551             }
 552         } else {
 553             if (volp->vol[BACKVOL].qflags & CM_VOLUME_QFLAG_IN_HASH)
 554                 cm_RemoveVolumeFromIDHashTable(volp, BACKVOL);
 555             volp->vol[BACKVOL].ID = 0;
 556         }
 557         lock_ReleaseWrite(&cm_volumeLock);
 558
 559         /* See if the replica sites are mixed versions */
 560         for (i=0; i<nServers; i++) {
 561             if (serverFlags[i] & VLSF_NEWREPSITE) {
 562                 isMixed = 1;
 563                 break;
 564             }
 565         }
 566
 567         for (i=0; i<nServers; i++) {
 568             /* create a server entry */
 569             tflags = serverFlags[i];
 570             if (tflags & VLSF_DONTUSE)
 571                 continue;
 572             tsockAddr.sin_port = htons(7000);
 573             tsockAddr.sin_family = AF_INET;
 574             tempAddr = htonl(serverNumber[i]);
 575             tsockAddr.sin_addr.s_addr = tempAddr;
 576             tsp = cm_FindServer(&tsockAddr, CM_SERVER_FILE, FALSE);
 577             if (tsp && (method == 2) && (tsp->flags & CM_SERVERFLAG_UUID)) {
 578                 /*
 579                  * Check to see if the uuid of the server we know at this address
 580                  * matches the uuid of the server we are being told about by the
 581                  * vlserver.  If not, ...?
 582                  */
 583                 if (!afs_uuid_equal(&serverUUID[i], &tsp->uuid)) {
 584                     struct uuid_fmtbuf uuid1, uuid2;
 585                     char hoststr[16];
 586                     afsUUID_to_string(&serverUUID[i], &uuid1);
 587                     afsUUID_to_string(&tsp->uuid, &uuid2);
 588                     afs_inet_ntoa_r(serverNumber[i], hoststr);
 589
 590                     osi_Log3(afsd_logp, "cm_UpdateVolumeLocation UUIDs do not match! %s != %s (%s)",
 591                               osi_LogSaveString(afsd_logp, uuid1.buffer),
 592                               osi_LogSaveString(afsd_logp, uuid2.buffer),
 593                               osi_LogSaveString(afsd_logp, hoststr));
 594                 }
 595             }
 596             if (!tsp) {
 597                 /*
 598                  * cm_NewServer will probe the file server which in turn will
 599                  * update the state on the volume group object.  Do not probe
 600                  * in this thread.  It will block the thread and can result in
 601                  * a recursive call to cm_UpdateVolumeLocation().
 602                  */
 603                 lock_ReleaseWrite(&volp->rw);
 604                 tsp = cm_NewServer(&tsockAddr, CM_SERVER_FILE, cellp, &serverUUID[i], CM_FLAG_NOPROBE);
 605                 lock_ObtainWrite(&volp->rw);
 606             }
 607             osi_assertx(tsp != NULL, "null cm_server_t");
 608
 609             /*
 610              * if this server was created by fs setserverprefs
 611              * then it won't have either a cell assignment or
 612              * a server uuid.
 613              */
 614             if ( !tsp->cellp )
 615                 tsp->cellp = cellp;
 616             if ( (method == 2) && !(tsp->flags & CM_SERVERFLAG_UUID) &&
 617                  !afs_uuid_is_nil(&serverUUID[i])) {
 618                 tsp->uuid = serverUUID[i];
 619                 _InterlockedOr(&tsp->flags, CM_SERVERFLAG_UUID);
 620             }
 621
 622             /* and add it to the list(s). */
 623             /*
 624              * Each call to cm_NewServerRef() increments the
 625              * ref count of tsp.  These reference will be dropped,
 626              * if and when the volume is reset; see reset code
 627              * earlier in this function.
 628              */
 629             if ((tflags & VLSF_RWVOL) && (flags & VLF_RWEXISTS)) {
 630                 tsrp = cm_NewServerRef(tsp, rwID);
 631                 cm_InsertServerList(&volp->vol[RWVOL].serversp, tsrp);
 632                 if (!(tsp->flags & CM_SERVERFLAG_DOWN))
 633                     rwServers_alldown = 0;
 634             }
 635             /*
 636              * If there are mixed versions of RO releases on the replica
 637              * sites, skip the servers with the out of date versions.
 638              */
 639             if ((tflags & VLSF_ROVOL) && (flags & VLF_ROEXISTS) &&
 640                 (!isMixed || (tflags & VLSF_NEWREPSITE))) {
 641                 tsrp = cm_NewServerRef(tsp, roID);
 642                 cm_InsertServerList(&volp->vol[ROVOL].serversp, tsrp);
 643                 ROcount++;
 644
 645                 if (!(tsp->flags & CM_SERVERFLAG_DOWN))
 646                     roServers_alldown = 0;
 647             }
 648             /* We don't use VLSF_BACKVOL !?! */
 649             /* Because only the backup on the server holding the RW
 650              * volume can be valid.  This check prevents errors if a
 651              * RW is moved but the old backup is not removed.
 652              */
 653             if ((tflags & VLSF_RWVOL) && (flags & VLF_BACKEXISTS)) {
 654                 tsrp = cm_NewServerRef(tsp, bkID);
 655                 cm_InsertServerList(&volp->vol[BACKVOL].serversp, tsrp);
 656
 657                 if (!(tsp->flags & CM_SERVERFLAG_DOWN))
 658                     bkServers_alldown = 0;
 659             }
 660             /* Drop the reference obtained by cm_FindServer() */
 661             cm_PutServer(tsp);
 662         }
 663
 664         /*
 665          * Randomize RO list
 666          *
 667          * If the first n servers have the same rank, then we
 668          * randomly pick one among them and move it to the beginning.
 669          * We don't bother to re-order the whole list because
 670          * the rest of the list is used only if the first server is
 671          * down.  We only do this for the RO list; we assume the other
 672          * lists are length 1.
 673          */
 674         if (ROcount > 1) {
 675             cm_RandomizeServer(&volp->vol[ROVOL].serversp);
 676             _InterlockedOr(&volp->vol[ROVOL].flags, CM_VOL_STATE_FLAG_REPLICATED);
 677         }
 678         else {
 679             _InterlockedAnd(&volp->vol[ROVOL].flags, ~CM_VOL_STATE_FLAG_REPLICATED);
 680         }
 681
 682         rwNewstate = rwServers_alldown ? vl_alldown : vl_online;
 683         roNewstate = roServers_alldown ? vl_alldown : vl_online;
 684         bkNewstate = bkServers_alldown ? vl_alldown : vl_online;
 685
 686         _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_NOEXIST);
 687     } else if (code == CM_ERROR_NOSUCHVOLUME || code == VL_NOENT || code == VL_BADNAME) {
 688         _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_NOEXIST);
 689     } else {
 690         rwNewstate = roNewstate = bkNewstate = vl_alldown;
 691
 692         /*
 693          * we are updating lastUpdateTime but didn't get an answer
 694          * so clear the no exist flag.
 695          */
 696         _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_NOEXIST);
 697     }
 698
 699     if (volp->vol[RWVOL].state != rwNewstate) {
 700         if (volp->vol[RWVOL].ID)
 701             cm_VolumeStatusNotification(volp, volp->vol[RWVOL].ID, volp->vol[RWVOL].state, rwNewstate);
 702         volp->vol[RWVOL].state = rwNewstate;
 703     }
 704     if (volp->vol[ROVOL].state != roNewstate) {
 705         if (volp->vol[ROVOL].ID)
 706             cm_VolumeStatusNotification(volp, volp->vol[ROVOL].ID, volp->vol[ROVOL].state, roNewstate);
 707         volp->vol[ROVOL].state = roNewstate;
 708     }
 709     if (volp->vol[BACKVOL].state != bkNewstate) {
 710         if (volp->vol[BACKVOL].ID)
 711             cm_VolumeStatusNotification(volp, volp->vol[BACKVOL].ID, volp->vol[BACKVOL].state, bkNewstate);
 712         volp->vol[BACKVOL].state = bkNewstate;
 713     }
 714
 715     if (code == 0 || (volp->flags & CM_VOLUMEFLAG_NOEXIST))
 716         volp->lastUpdateTime = time(NULL);
 717
 718     if (isMixed)
 719         _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_RO_MIXED);
 720     else
 721         _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_RO_MIXED);
 722
 723     if (code == 0)
 724         _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_RESET);
 725
 726     _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_UPDATING_VL);
 727     osi_Log4(afsd_logp, "cm_UpdateVolumeLocation done, waking others name %s:%s flags 0x%x code 0x%x",
 728              osi_LogSaveString(afsd_logp,volp->cellp->name),
 729              osi_LogSaveString(afsd_logp,volp->namep), volp->flags, code);
 730     osi_Wakeup((LONG_PTR) &volp->flags);
 731
 732     return code;
 733 }
 734
 735 /* Requires read or write lock on cm_volumeLock */
 736 void cm_GetVolume(cm_volume_t *volp)
 737 {
 738     InterlockedIncrement(&volp->refCount);
 739 }
 740
 741 cm_volume_t *cm_GetVolumeByFID(cm_fid_t *fidp)
 742 {
 743     cm_volume_t *volp;
 744     afs_uint32 hash;
 745
 746     lock_ObtainRead(&cm_volumeLock);
 747     hash = CM_VOLUME_ID_HASH(fidp->volume);
 748     /* The volumeID can be any one of the three types.  So we must
 749      * search the hash table for all three types until we find it.
 750      * We will search in the order of RO, RW, BK.
 751      */
 752     for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = volp->vol[ROVOL].nextp) {
 753         if ( fidp->cell == volp->cellp->cellID && fidp->volume == volp->vol[ROVOL].ID )
 754             break;
 755     }
 756     if (!volp) {
 757         /* try RW volumes */
 758         for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = volp->vol[RWVOL].nextp) {
 759             if ( fidp->cell == volp->cellp->cellID && fidp->volume == volp->vol[RWVOL].ID )
 760                 break;
 761         }
 762     }
 763     if (!volp) {
 764         /* try BK volumes */
 765         for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = volp->vol[BACKVOL].nextp) {
 766             if ( fidp->cell == volp->cellp->cellID && fidp->volume == volp->vol[BACKVOL].ID )
 767                 break;
 768         }
 769     }
 770
 771     /* hold the volume if we found it */
 772     if (volp)
 773         cm_GetVolume(volp);
 774
 775     lock_ReleaseRead(&cm_volumeLock);
 776     return volp;
 777 }
 778
 779 cm_volume_t *cm_FindVolumeByFID(cm_fid_t *fidp, cm_user_t *userp, cm_req_t *reqp)
 780 {
 781     cm_volume_t *volp = NULL;
 782     cm_cell_t   *cellp;
 783     long         code;
 784
 785     cellp = cm_FindCellByID(fidp->cell, CM_FLAG_NOPROBE);
 786     if (!cellp) {
 787         return NULL;
 788     }
 789
 790     code = cm_FindVolumeByID(cellp, fidp->volume, userp, reqp, CM_GETVOL_FLAG_CREATE, &volp);
 791     if (code)
 792         return NULL;
 793
 794     return volp;
 795 }
 796
 797 long cm_FindVolumeByID(cm_cell_t *cellp, afs_uint32 volumeID, cm_user_t *userp,
 798                       cm_req_t *reqp, afs_uint32 flags, cm_volume_t **outVolpp)
 799 {
 800     cm_volume_t *volp;
 801 #ifdef SEARCH_ALL_VOLUMES
 802     cm_volume_t *volp2;
 803 #endif
 804     char volNameString[VL_MAXNAMELEN];
 805     afs_uint32 hash;
 806     long code = 0;
 807
 808     lock_ObtainRead(&cm_volumeLock);
 809 #ifdef SEARCH_ALL_VOLUMES
 810     for(volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
 811         if (cellp == volp->cellp &&
 812              ((unsigned) volumeID == volp->vol[RWVOL].ID ||
 813                (unsigned) volumeID == volp->vol[ROVOL].ID ||
 814                (unsigned) volumeID == volp->vol[BACKVOL].ID))
 815             break;
 816     }
 817
 818     volp2 = volp;
 819 #endif /* SEARCH_ALL_VOLUMES */
 820
 821     hash = CM_VOLUME_ID_HASH(volumeID);
 822     /* The volumeID can be any one of the three types.  So we must
 823      * search the hash table for all three types until we find it.
 824      * We will search in the order of RO, RW, BK.
 825      */
 826     for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = volp->vol[ROVOL].nextp) {
 827         if ( cellp == volp->cellp && volumeID == volp->vol[ROVOL].ID )
 828             break;
 829     }
 830     if (!volp) {
 831         /* try RW volumes */
 832         for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = volp->vol[RWVOL].nextp) {
 833             if ( cellp == volp->cellp && volumeID == volp->vol[RWVOL].ID )
 834                 break;
 835         }
 836     }
 837     if (!volp) {
 838         /* try BK volumes */
 839         for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = volp->vol[BACKVOL].nextp) {
 840             if ( cellp == volp->cellp && volumeID == volp->vol[BACKVOL].ID )
 841                 break;
 842         }
 843     }
 844
 845 #ifdef SEARCH_ALL_VOLUMES
 846     osi_assertx(volp == volp2, "unexpected cm_vol_t");
 847 #endif
 848
 849     /* hold the volume if we found it */
 850     if (volp)
 851         cm_GetVolume(volp);
 852
 853     lock_ReleaseRead(&cm_volumeLock);
 854
 855     /* return it held */
 856     if (volp) {
 857         lock_ObtainWrite(&volp->rw);
 858
 859         code = 0;
 860         if ((volp->flags & CM_VOLUMEFLAG_RESET) && !(flags & CM_GETVOL_FLAG_NO_RESET)) {
 861             code = cm_UpdateVolumeLocation(cellp, userp, reqp, volp);
 862         }
 863         lock_ReleaseWrite(&volp->rw);
 864         if (code == 0) {
 865             *outVolpp = volp;
 866
 867             if (!(flags & CM_GETVOL_FLAG_NO_LRU_UPDATE)) {
 868                 lock_ObtainWrite(&cm_volumeLock);
 869                 cm_AdjustVolumeLRU(volp);
 870                 lock_ReleaseWrite(&cm_volumeLock);
 871             }
 872         } else {
 873             lock_ObtainRead(&cm_volumeLock);
 874             cm_PutVolume(volp);
 875             lock_ReleaseRead(&cm_volumeLock);
 876         }
 877         return code;
 878     }
 879
 880     /* otherwise, we didn't find it so consult the VLDB */
 881     sprintf(volNameString, "%u", volumeID);
 882     code = cm_FindVolumeByName(cellp, volNameString, userp, reqp,
 883                               flags | CM_GETVOL_FLAG_IGNORE_LINKED_CELL, outVolpp);
 884
 885     if (code == CM_ERROR_NOSUCHVOLUME && cellp->linkedName[0] &&
 886         !(flags & CM_GETVOL_FLAG_IGNORE_LINKED_CELL)) {
 887         cm_cell_t *linkedCellp = cm_GetCell(cellp->linkedName, flags);
 888
 889         if (linkedCellp)
 890             code = cm_FindVolumeByID(linkedCellp, volumeID, userp, reqp,
 891                                      flags | CM_GETVOL_FLAG_IGNORE_LINKED_CELL,
 892                                      outVolpp);
 893     }
 894     return code;
 895 }
 896
 897
 898 long cm_FindVolumeByName(struct cm_cell *cellp, char *volumeNamep,
 899                         struct cm_user *userp, struct cm_req *reqp,
 900                         afs_uint32 flags, cm_volume_t **outVolpp)
 901 {
 902     cm_volume_t *volp;
 903 #ifdef SEARCH_ALL_VOLUMES
 904     cm_volume_t *volp2;
 905 #endif
 906     long        code = 0;
 907     char        name[VL_MAXNAMELEN];
 908     size_t      len;
 909     int         type;
 910     afs_uint32  hash;
 911
 912     strncpy(name, volumeNamep, VL_MAXNAMELEN);
 913     name[VL_MAXNAMELEN-1] = '\0';
 914     len = strlen(name);
 915
 916     if (len >= 8 && strcmp(name + len - 7, ".backup") == 0) {
 917         type = BACKVOL;
 918         name[len - 7] = '\0';
 919     } else if (len >= 10 && strcmp(name + len - 9, ".readonly") == 0) {
 920         type = ROVOL;
 921         name[len - 9] = '\0';
 922     } else {
 923         type = RWVOL;
 924     }
 925
 926     lock_ObtainRead(&cm_volumeLock);
 927 #ifdef SEARCH_ALL_VOLUMES
 928     for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
 929         if (cellp == volp->cellp && strcmp(name, volp->namep) == 0) {
 930             break;
 931         }
 932     }
 933     volp2 = volp;
 934 #endif /* SEARCH_ALL_VOLUMES */
 935
 936     hash = CM_VOLUME_NAME_HASH(name);
 937     for (volp = cm_data.volumeNameHashTablep[hash]; volp; volp = volp->nameNextp) {
 938         if (cellp == volp->cellp && strcmp(name, volp->namep) == 0)
 939             break;
 940     }
 941
 942 #ifdef SEARCH_ALL_VOLUMES
 943     osi_assertx(volp2 == volp, "unexpected cm_vol_t");
 944 #endif
 945
 946     if (!volp && (flags & CM_GETVOL_FLAG_CREATE)) {
 947         afs_uint32 volType;
 948         /* otherwise, get from VLDB */
 949
 950         /*
 951          * Change to a write lock so that we have exclusive use of
 952          * the first cm_volume_t with a refCount of 0 so that we
 953          * have time to increment it.
 954          */
 955         lock_ConvertRToW(&cm_volumeLock);
 956
 957         /*
 958          * While the lock was converted it may have been dropped
 959          * Search again now that we are exclusive.
 960          */
 961         for (volp = cm_data.volumeNameHashTablep[hash]; volp; volp = volp->nameNextp) {
 962             if (cellp == volp->cellp && strcmp(name, volp->namep) == 0)
 963                 break;
 964         }
 965
 966         if (volp) {
 967             cm_GetVolume(volp);
 968             lock_ReleaseWrite(&cm_volumeLock);
 969             lock_ObtainWrite(&volp->rw);
 970         } else {
 971             if ( cm_data.currentVolumes >= cm_data.maxVolumes ) {
 972 #ifdef RECYCLE_FROM_ALL_VOLUMES_LIST
 973                 for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
 974                     if ( volp->refCount == 0 ) {
 975                         /* There is one we can re-use */
 976                         break;
 977                     }
 978                 }
 979 #else
 980                 for ( volp = cm_data.volumeLRULastp;
 981                       volp;
 982                       volp = (cm_volume_t *) osi_QPrev(&volp->q))
 983                 {
 984                     if ( volp->refCount == 0 ) {
 985                         /* There is one we can re-use */
 986                         break;
 987                     }
 988                 }
 989 #endif
 990                 if (!volp)
 991                     osi_panic("Exceeded Max Volumes", __FILE__, __LINE__);
 992
 993                 osi_Log2(afsd_logp, "Recycling Volume %s:%s",
 994                          volp->cellp->name, volp->namep);
 995
 996                 /* The volp is removed from the LRU queue in order to
 997                  * prevent two threads from attempting to recycle the
 998                  * same object.  This volp must be re-inserted back into
 999                  * the LRU queue before this function exits.
1000                  */
1001                 if (volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE)
1002                     cm_RemoveVolumeFromLRU(volp);
1003                 if (volp->qflags & CM_VOLUME_QFLAG_IN_HASH)
1004                     cm_RemoveVolumeFromNameHashTable(volp);
1005
1006                 for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
1007                     if (volp->vol[volType].qflags & CM_VOLUME_QFLAG_IN_HASH)
1008                         cm_RemoveVolumeFromIDHashTable(volp, volType);
1009                     if (volp->vol[volType].ID)
1010                         cm_VolumeStatusNotification(volp, volp->vol[volType].ID, volp->vol[volType].state, vl_unknown);
1011                     volp->vol[volType].ID = 0;
1012                     cm_SetFid(&volp->vol[volType].dotdotFid, 0, 0, 0, 0);
1013                 }
1014             } else {
1015                 volp = &cm_data.volumeBaseAddress[InterlockedIncrement(&cm_data.currentVolumes) - 1];
1016                 memset(volp, 0, sizeof(cm_volume_t));
1017                 volp->magic = CM_VOLUME_MAGIC;
1018                 volp->allNextp = cm_data.allVolumesp;
1019                 cm_data.allVolumesp = volp;
1020                 lock_InitializeRWLock(&volp->rw, "cm_volume_t rwlock", LOCK_HIERARCHY_VOLUME);
1021             }
1022             /*
1023              * no one else can find this object and we have not dropped
1024              * cm_volumeLock in any case.  The object is either new or
1025              * recycled.  Initialize its new values and put it into the
1026              * name hash table before dropping cm_volumeLock which makes
1027              * it visible to competing threads.
1028              */
1029             volp->cellp = cellp;
1030             strncpy(volp->namep, name, VL_MAXNAMELEN);
1031             volp->namep[VL_MAXNAMELEN-1] = '\0';
1032             volp->flags = CM_VOLUMEFLAG_RESET;
1033             volp->lastUpdateTime = 0;
1034
1035             for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
1036                 volp->vol[volType].state = vl_unknown;
1037                 volp->vol[volType].nextp = NULL;
1038                 volp->vol[volType].flags = 0;
1039             }
1040             volp->cbExpiresRO = 0;
1041             volp->cbIssuedRO = 0;
1042             volp->cbServerpRO = NULL;
1043             volp->creationDateRO = 0;
1044             cm_AddVolumeToNameHashTable(volp);
1045             cm_GetVolume(volp);
1046             lock_ReleaseWrite(&cm_volumeLock);
1047             lock_ObtainWrite(&volp->rw);
1048             for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
1049                 cm_FreeServerList(&volp->vol[volType].serversp, CM_FREESERVERLIST_DELETE);
1050             }
1051         }
1052     }
1053     else if (volp) {
1054         cm_GetVolume(volp);
1055         lock_ReleaseRead(&cm_volumeLock);
1056         lock_ObtainWrite(&volp->rw);
1057     } else {
1058         lock_ReleaseRead(&cm_volumeLock);
1059         return CM_ERROR_NOSUCHVOLUME;
1060     }
1061
1062     /* if we get here we are holding the mutex */
1063     if ((volp->flags & CM_VOLUMEFLAG_RESET) && !(flags & CM_GETVOL_FLAG_NO_RESET)) {
1064         code = cm_UpdateVolumeLocation(cellp, userp, reqp, volp);
1065     }
1066     lock_ReleaseWrite(&volp->rw);
1067
1068     if (code == 0 && (type == BACKVOL && volp->vol[BACKVOL].ID == 0 ||
1069                       type == ROVOL && volp->vol[ROVOL].ID == 0))
1070         code = CM_ERROR_NOSUCHVOLUME;
1071
1072     if (code == 0) {
1073         *outVolpp = volp;
1074
1075         lock_ObtainWrite(&cm_volumeLock);
1076         if (!(volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE) ||
1077              (flags & CM_GETVOL_FLAG_NO_LRU_UPDATE))
1078             cm_AdjustVolumeLRU(volp);
1079         lock_ReleaseWrite(&cm_volumeLock);
1080     } else {
1081         /*
1082          * do not return it to the caller but do insert it in the LRU
1083          * otherwise it will be lost
1084          */
1085         lock_ObtainWrite(&cm_volumeLock);
1086         if (!(volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE) ||
1087              (flags & CM_GETVOL_FLAG_NO_LRU_UPDATE))
1088             cm_AdjustVolumeLRU(volp);
1089         cm_PutVolume(volp);
1090         lock_ReleaseWrite(&cm_volumeLock);
1091     }
1092
1093     if (code == CM_ERROR_NOSUCHVOLUME && cellp->linkedName[0] &&
1094         !(flags & CM_GETVOL_FLAG_IGNORE_LINKED_CELL)) {
1095         cm_cell_t *linkedCellp = cm_GetCell(cellp->linkedName, flags);
1096
1097         if (linkedCellp)
1098             code = cm_FindVolumeByName(linkedCellp, volumeNamep, userp, reqp,
1099                                        flags | CM_GETVOL_FLAG_IGNORE_LINKED_CELL,
1100                                        outVolpp);
1101     }
1102     return code;
1103 }
1104
1105 /*
1106  * Only call this function in response to a VNOVOL or VMOVED error
1107  * from a file server.  Do not call it in response to CM_ERROR_NOSUCHVOLUME
1108  * as that can lead to recursive calls.
1109  */
1110 long cm_ForceUpdateVolume(cm_fid_t *fidp, cm_user_t *userp, cm_req_t *reqp)
1111 {
1112     cm_cell_t *cellp;
1113     cm_volume_t *volp;
1114 #ifdef SEARCH_ALL_VOLUMES
1115     cm_volume_t *volp2;
1116 #endif
1117     afs_uint32  hash;
1118     long code;
1119
1120     if (!fidp)
1121         return CM_ERROR_INVAL;
1122
1123     cellp = cm_FindCellByID(fidp->cell, 0);
1124     if (!cellp)
1125         return CM_ERROR_NOSUCHCELL;
1126
1127     /* search for the volume */
1128     lock_ObtainRead(&cm_volumeLock);
1129 #ifdef SEARCH_ALL_VOLUMES
1130     for(volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
1131         if (cellp == volp->cellp &&
1132              (fidp->volume == volp->vol[RWVOL].ID ||
1133                fidp->volume == volp->vol[ROVOL].ID ||
1134                fidp->volume == volp->vol[BACKVOL].ID))
1135             break;
1136     }
1137 #endif /* SEARCH_ALL_VOLUMES */
1138
1139     hash = CM_VOLUME_ID_HASH(fidp->volume);
1140     /* The volumeID can be any one of the three types.  So we must
1141      * search the hash table for all three types until we find it.
1142      * We will search in the order of RO, RW, BK.
1143      */
1144     for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = volp->vol[ROVOL].nextp) {
1145         if ( cellp == volp->cellp && fidp->volume == volp->vol[ROVOL].ID )
1146             break;
1147     }
1148     if (!volp) {
1149         /* try RW volumes */
1150         for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = volp->vol[RWVOL].nextp) {
1151             if ( cellp == volp->cellp && fidp->volume == volp->vol[RWVOL].ID )
1152                 break;
1153         }
1154     }
1155     if (!volp) {
1156         /* try BK volumes */
1157         for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = volp->vol[BACKVOL].nextp) {
1158             if ( cellp == volp->cellp && fidp->volume == volp->vol[BACKVOL].ID )
1159                 break;
1160         }
1161     }
1162
1163 #ifdef SEARCH_ALL_VOLUMES
1164     osi_assertx(volp == volp2, "unexpected cm_vol_t");
1165 #endif
1166     /* hold the volume if we found it */
1167     if (volp)
1168         cm_GetVolume(volp);
1169
1170     lock_ReleaseRead(&cm_volumeLock);
1171
1172     if (!volp)
1173         return CM_ERROR_NOSUCHVOLUME;
1174
1175     /* update it */
1176     cm_data.mountRootGen = time(NULL);
1177     lock_ObtainWrite(&volp->rw);
1178     _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_RESET);
1179     volp->lastUpdateTime = 0;
1180
1181     code = cm_UpdateVolumeLocation(cellp, userp, reqp, volp);
1182     lock_ReleaseWrite(&volp->rw);
1183
1184     lock_ObtainRead(&cm_volumeLock);
1185     cm_PutVolume(volp);
1186     lock_ReleaseRead(&cm_volumeLock);
1187
1188     return code;
1189 }
1190
1191 /* find the appropriate servers from a volume */
1192 cm_serverRef_t **cm_GetVolServers(cm_volume_t *volp, afs_uint32 volid, cm_user_t *userp, cm_req_t *reqp, afs_uint32 *replicated)
1193 {
1194     cm_serverRef_t **serverspp;
1195     cm_serverRef_t *current;
1196     int firstTry = 1;
1197     cm_vol_state_t *volstatep = NULL;
1198
1199   start:
1200     volstatep = cm_VolumeStateByID(volp, volid);
1201
1202     lock_ObtainWrite(&cm_serverLock);
1203     if (volstatep) {
1204         if (replicated)
1205             *replicated = (volstatep->flags & CM_VOL_STATE_FLAG_REPLICATED);
1206         serverspp = &volstatep->serversp;
1207     } else {
1208         lock_ReleaseWrite(&cm_serverLock);
1209         if (firstTry) {
1210             afs_int32 code;
1211             firstTry = 0;
1212             lock_ObtainWrite(&volp->rw);
1213             _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_RESET);
1214             volp->lastUpdateTime = 0;
1215             code = cm_UpdateVolumeLocation(volp->cellp, userp, reqp, volp);
1216             lock_ReleaseWrite(&volp->rw);
1217             if (code == 0)
1218                 goto start;
1219         }
1220         return NULL;
1221     }
1222
1223     /*
1224      * Increment the refCount on deleted items as well.
1225      * They will be freed by cm_FreeServerList when they get to zero
1226      */
1227     for (current = *serverspp; current; current = current->next)
1228         cm_GetServerRef(current, TRUE);
1229
1230     lock_ReleaseWrite(&cm_serverLock);
1231
1232     return serverspp;
1233 }
1234
1235 void cm_PutVolume(cm_volume_t *volp)
1236 {
1237     afs_int32 refCount = InterlockedDecrement(&volp->refCount);
1238     osi_assertx(refCount >= 0, "cm_volume_t refCount underflow has occurred");
1239 }
1240
1241 /* return the read-only volume, if there is one, or the read-write volume if
1242  * not.
1243  */
1244 long cm_GetROVolumeID(cm_volume_t *volp)
1245 {
1246     long id;
1247
1248     lock_ObtainRead(&volp->rw);
1249     if (volp->vol[ROVOL].ID && !cm_IsServerListEmpty(volp->vol[ROVOL].serversp))
1250         id = volp->vol[ROVOL].ID;
1251     else
1252         id = volp->vol[RWVOL].ID;
1253     lock_ReleaseRead(&volp->rw);
1254
1255     return id;
1256 }
1257
1258 void cm_RefreshVolumes(int lifetime)
1259 {
1260     cm_volume_t *volp;
1261     afs_int32 refCount;
1262     time_t now;
1263
1264     now = time(NULL);
1265
1266     /* force mount point target updates */
1267     if (cm_data.mountRootGen + lifetime <= now)
1268         cm_data.mountRootGen = now;
1269
1270     /*
1271      * force a re-loading of volume data from the vldb
1272      * if the lifetime for the cached data has expired
1273      */
1274     lock_ObtainRead(&cm_volumeLock);
1275     for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
1276         cm_GetVolume(volp);
1277         lock_ReleaseRead(&cm_volumeLock);
1278
1279         if (!(volp->flags & CM_VOLUMEFLAG_RESET) ||
1280             (volp->flags & CM_VOLUMEFLAG_NOEXIST)) {
1281             lock_ObtainWrite(&volp->rw);
1282             if (volp->flags & CM_VOLUMEFLAG_NOEXIST) {
1283                 _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_NOEXIST);
1284             }
1285
1286             if (volp->flags & CM_VOLUMEFLAG_RO_MIXED) {
1287                 if (volp->lastUpdateTime + 300 <= now) {
1288                     _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_RESET);
1289                     volp->lastUpdateTime = 0;
1290                 }
1291             } else {
1292                 if (volp->lastUpdateTime + lifetime <= now) {
1293                     _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_RESET);
1294                     volp->lastUpdateTime = 0;
1295                 }
1296             }
1297             lock_ReleaseWrite(&volp->rw);
1298         }
1299
1300         lock_ObtainRead(&cm_volumeLock);
1301         cm_PutVolume(volp);
1302     }
1303     lock_ReleaseRead(&cm_volumeLock);
1304 }
1305
1306 void
1307 cm_CheckOfflineVolumeState(cm_volume_t *volp, cm_vol_state_t *statep, afs_uint32 volID,
1308                            afs_uint32 *onlinep, afs_uint32 *volumeUpdatedp)
1309 {
1310     cm_conn_t *connp;
1311     long code;
1312     AFSFetchVolumeStatus volStat;
1313     char *Name;
1314     char *OfflineMsg;
1315     char *MOTD;
1316     cm_req_t req;
1317     struct rx_connection * rxconnp;
1318     char volName[32];
1319     afs_uint32 volType;
1320     char offLineMsg[256];
1321     char motd[256];
1322     long alldown, alldeleted;
1323     cm_serverRef_t *serversp;
1324     cm_fid_t vfid;
1325     cm_scache_t *vscp = NULL;
1326
1327     Name = volName;
1328     OfflineMsg = offLineMsg;
1329     MOTD = motd;
1330
1331     volType = cm_VolumeType(volp, volID);
1332
1333     if (statep->ID != 0 && (!volID || volID == statep->ID)) {
1334         /* create fid for volume root so that VNOVOL and VMOVED errors can be processed */
1335         cm_SetFid(&vfid, volp->cellp->cellID, statep->ID, 1, 1);
1336
1337         if (!statep->serversp && !(*volumeUpdatedp)) {
1338             cm_InitReq(&req);
1339             code = cm_UpdateVolumeLocation(volp->cellp, cm_rootUserp, &req, volp);
1340             *volumeUpdatedp = 1;
1341         }
1342
1343         lock_ObtainRead(&cm_serverLock);
1344         if (statep->serversp) {
1345             alldown = 1;
1346             alldeleted = 1;
1347             for (serversp = statep->serversp; serversp; serversp = serversp->next) {
1348                 if (serversp->status == srv_deleted)
1349                     continue;
1350
1351                 alldeleted = 0;
1352
1353                 if (!(serversp->server->flags & CM_SERVERFLAG_DOWN))
1354                     alldown = 0;
1355
1356                 if (serversp->status == srv_busy || serversp->status == srv_offline)
1357                     serversp->status = srv_not_busy;
1358             }
1359             lock_ReleaseRead(&cm_serverLock);
1360
1361             if (alldeleted && !(*volumeUpdatedp)) {
1362                 cm_InitReq(&req);
1363                 code = cm_UpdateVolumeLocation(volp->cellp, cm_rootUserp, &req, volp);
1364                 *volumeUpdatedp = 1;
1365             }
1366
1367             if (statep->state == vl_busy || statep->state == vl_offline || statep->state == vl_unknown ||
1368                 (!alldown && statep->state == vl_alldown)) {
1369                 cm_InitReq(&req);
1370                 req.flags |= CM_REQ_OFFLINE_VOL_CHK;
1371                 lock_ReleaseWrite(&volp->rw);
1372
1373                 code = cm_GetSCache(&vfid, NULL, &vscp, cm_rootUserp, &req);
1374                 if (code = 0) {
1375                     do {
1376                         code = cm_ConnFromVolume(volp, statep->ID, cm_rootUserp, &req, &connp);
1377                         if (code)
1378                            continue;
1379
1380                         rxconnp = cm_GetRxConn(connp);
1381                         code = RXAFS_GetVolumeStatus(rxconnp, statep->ID,
1382                                                      &volStat, &Name, &OfflineMsg, &MOTD);
1383                         rx_PutConnection(rxconnp);
1384                     } while (cm_Analyze(connp, cm_rootUserp, &req, &vfid, NULL, 0, NULL, NULL, NULL, NULL, code));
1385                     code = cm_MapRPCError(code, &req);
1386
1387                     if (code == 0 && volType == ROVOL)
1388                     {
1389                         lock_ObtainWrite(&volp->rw);
1390                         volp->volumeSizeRO = volStat.BlocksInUse * 1024;
1391                         _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_RO_SIZE_VALID);
1392                         lock_ReleaseWrite(&volp->rw);
1393                     }
1394
1395                     cm_ReleaseSCache(vscp);
1396                 }
1397                 lock_ObtainWrite(&volp->rw);
1398                 if (code == 0 && volStat.Online) {
1399                     cm_VolumeStatusNotification(volp, statep->ID, statep->state, vl_online);
1400                     statep->state = vl_online;
1401                     *onlinep = 1;
1402                 } else if (code == CM_ERROR_NOACCESS) {
1403                     cm_VolumeStatusNotification(volp, statep->ID, statep->state, vl_unknown);
1404                     statep->state = vl_unknown;
1405                     *onlinep = 1;
1406                 }
1407             } else if (alldown && statep->state != vl_alldown) {
1408                 cm_VolumeStatusNotification(volp, statep->ID, statep->state, vl_alldown);
1409                 statep->state = vl_alldown;
1410             }
1411         } else {
1412             lock_ReleaseRead(&cm_serverLock);
1413             if (statep->state != vl_alldown) {
1414                 cm_VolumeStatusNotification(volp, statep->ID, statep->state, vl_alldown);
1415                 statep->state = vl_alldown;
1416             }
1417         }
1418     }
1419 }
1420
1421 /* The return code is 0 if the volume is not online and
1422  * 1 if the volume is online
1423  */
1424 long
1425 cm_CheckOfflineVolume(cm_volume_t *volp, afs_uint32 volID)
1426 {
1427     long code;
1428     cm_req_t req;
1429     afs_uint32 online = 0;
1430     afs_uint32 volumeUpdated = 0;
1431
1432     lock_ObtainWrite(&volp->rw);
1433
1434     if (volp->flags & CM_VOLUMEFLAG_RESET) {
1435         cm_InitReq(&req);
1436         code = cm_UpdateVolumeLocation(volp->cellp, cm_rootUserp, &req, volp);
1437         volumeUpdated = 1;
1438     }
1439
1440     cm_CheckOfflineVolumeState(volp, &volp->vol[RWVOL], volID, &online, &volumeUpdated);
1441     cm_CheckOfflineVolumeState(volp, &volp->vol[ROVOL], volID, &online, &volumeUpdated);
1442     cm_CheckOfflineVolumeState(volp, &volp->vol[BACKVOL], volID, &online, &volumeUpdated);
1443
1444     lock_ReleaseWrite(&volp->rw);
1445     return online;
1446 }
1447
1448
1449 /*
1450  * called from the Daemon thread.
1451  * when checking the offline status, check those of the most recently used volumes first.
1452  */
1453 void cm_CheckOfflineVolumes(void)
1454 {
1455     cm_volume_t *volp;
1456     afs_int32 refCount;
1457     extern int daemon_ShutdownFlag;
1458     extern int powerStateSuspended;
1459
1460     lock_ObtainRead(&cm_volumeLock);
1461     for (volp = cm_data.volumeLRULastp;
1462          volp && !daemon_ShutdownFlag && !powerStateSuspended;
1463          volp=(cm_volume_t *) osi_QPrev(&volp->q)) {
1464         /*
1465          * Skip volume entries that did not exist last time
1466          * the vldb was queried.  For those entries wait until
1467          * the next actual request is received for the volume
1468          * before checking its state.
1469          */
1470         if ((volp->qflags & CM_VOLUME_QFLAG_IN_HASH) &&
1471             !(volp->flags & CM_VOLUMEFLAG_NOEXIST)) {
1472             cm_GetVolume(volp);
1473             lock_ReleaseRead(&cm_volumeLock);
1474             cm_CheckOfflineVolume(volp, 0);
1475             lock_ObtainRead(&cm_volumeLock);
1476             cm_PutVolume(volp);
1477         }
1478     }
1479     lock_ReleaseRead(&cm_volumeLock);
1480 }
1481
1482
1483 static void
1484 cm_UpdateVolumeStatusInt(cm_volume_t *volp, struct cm_vol_state *statep)
1485 {
1486     enum volstatus newStatus;
1487     cm_serverRef_t *tsrp;
1488     cm_server_t *tsp;
1489     int someBusy = 0, someOffline = 0, allOffline = 1, allBusy = 1, allDown = 1;
1490     char addr[16];
1491
1492     if (!volp || !statep) {
1493 #ifdef DEBUG
1494         DebugBreak();
1495 #endif
1496         return;
1497     }
1498
1499     lock_ObtainWrite(&cm_serverLock);
1500     for (tsrp = statep->serversp; tsrp; tsrp=tsrp->next) {
1501         tsp = tsrp->server;
1502         sprintf(addr, "%d.%d.%d.%d",
1503                  ((tsp->addr.sin_addr.s_addr & 0xff)),
1504                  ((tsp->addr.sin_addr.s_addr & 0xff00)>> 8),
1505                  ((tsp->addr.sin_addr.s_addr & 0xff0000)>> 16),
1506                  ((tsp->addr.sin_addr.s_addr & 0xff000000)>> 24));
1507
1508         if (tsrp->status == srv_deleted) {
1509             osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s deleted",
1510                      statep->ID, osi_LogSaveString(afsd_logp,addr));
1511             continue;
1512         }
1513         if (tsp) {
1514             cm_GetServerNoLock(tsp);
1515             if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
1516                 allDown = 0;
1517                 if (tsrp->status == srv_busy) {
1518                     osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s busy",
1519                               statep->ID, osi_LogSaveString(afsd_logp,addr));
1520                     allOffline = 0;
1521                     someBusy = 1;
1522                 } else if (tsrp->status == srv_offline) {
1523                     osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s offline",
1524                               statep->ID, osi_LogSaveString(afsd_logp,addr));
1525                     allBusy = 0;
1526                     someOffline = 1;
1527                 } else {
1528                     osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s online",
1529                               statep->ID, osi_LogSaveString(afsd_logp,addr));
1530                     allOffline = 0;
1531                     allBusy = 0;
1532                 }
1533             } else {
1534                 osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s down",
1535                           statep->ID, osi_LogSaveString(afsd_logp,addr));
1536             }
1537             cm_PutServerNoLock(tsp);
1538         }
1539     }
1540     lock_ReleaseWrite(&cm_serverLock);
1541
1542     osi_Log5(afsd_logp, "cm_UpdateVolumeStatusInt allDown %d allBusy %d someBusy %d someOffline %d allOffline %d",
1543              allDown, allBusy, someBusy, someOffline, allOffline);
1544
1545     if (allDown)
1546         newStatus = vl_alldown;
1547     else if (allBusy || (someBusy && someOffline))
1548         newStatus = vl_busy;
1549     else if (allOffline)
1550         newStatus = vl_offline;
1551     else
1552         newStatus = vl_online;
1553
1554     if (statep->ID && statep->state != newStatus)
1555         cm_VolumeStatusNotification(volp, statep->ID, statep->state, newStatus);
1556
1557     statep->state = newStatus;
1558 }
1559
1560 void
1561 cm_UpdateVolumeStatus(cm_volume_t *volp, afs_uint32 volID)
1562 {
1563
1564     if (volp->vol[RWVOL].ID == volID) {
1565         cm_UpdateVolumeStatusInt(volp, &volp->vol[RWVOL]);
1566     } else if (volp->vol[ROVOL].ID == volID) {
1567         cm_UpdateVolumeStatusInt(volp, &volp->vol[ROVOL]);
1568     } else if (volp->vol[BACKVOL].ID == volID) {
1569         cm_UpdateVolumeStatusInt(volp, &volp->vol[BACKVOL]);
1570     } else {
1571         /*
1572          * If we are called with volID == 0 then something has gone wrong.
1573          * Most likely a race occurred in the server volume list maintenance.
1574          * Since we don't know which volume's status should be updated,
1575          * just update all of them that are known to exist.  Better to be
1576          * correct than fast.
1577          */
1578         afs_uint32 volType;
1579         for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
1580             if (volp->vol[volType].ID != 0)
1581                 cm_UpdateVolumeStatusInt(volp, &volp->vol[volType]);
1582         }
1583     }
1584 }
1585
1586 /*
1587 ** Finds all volumes that reside on this server and reorders their
1588 ** RO list according to the changed rank of server.
1589 */
1590 void cm_ChangeRankVolume(cm_server_t *tsp)
1591 {
1592     int                 code;
1593     cm_volume_t*        volp;
1594     afs_int32 refCount;
1595
1596     /* find volumes which might have RO copy on server*/
1597     lock_ObtainRead(&cm_volumeLock);
1598     for(volp = cm_data.allVolumesp; volp; volp=volp->allNextp)
1599     {
1600         code = 1 ;      /* assume that list is unchanged */
1601         cm_GetVolume(volp);
1602         lock_ReleaseRead(&cm_volumeLock);
1603         lock_ObtainWrite(&volp->rw);
1604
1605         if ((tsp->cellp==volp->cellp) && (volp->vol[ROVOL].serversp))
1606             code =cm_ChangeRankServer(&volp->vol[ROVOL].serversp, tsp);
1607
1608         /* this volume list was changed */
1609         if ( !code )
1610             cm_RandomizeServer(&volp->vol[ROVOL].serversp);
1611
1612         lock_ReleaseWrite(&volp->rw);
1613         lock_ObtainRead(&cm_volumeLock);
1614         cm_PutVolume(volp);
1615     }
1616     lock_ReleaseRead(&cm_volumeLock);
1617 }
1618
1619 /* dump all volumes that have reference count > 0 to a file.
1620  * cookie is used to identify this batch for easy parsing,
1621  * and it a string provided by a caller
1622  */
1623 int cm_DumpVolumes(FILE *outputFile, char *cookie, int lock)
1624 {
1625     int zilch;
1626     cm_volume_t *volp;
1627     char output[1024];
1628
1629     if (lock) {
1630         lock_ObtainRead(&cm_scacheLock);
1631         lock_ObtainRead(&cm_volumeLock);
1632     }
1633
1634     sprintf(output, "%s - dumping volumes - cm_data.currentVolumes=%d, cm_data.maxVolumes=%d\r\n",
1635             cookie, cm_data.currentVolumes, cm_data.maxVolumes);
1636     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1637
1638     for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp)
1639     {
1640         time_t t;
1641         char *srvStr = NULL;
1642         afs_uint32 srvStrRpc = TRUE;
1643         char *cbt = NULL;
1644         char *cdrot = NULL;
1645
1646         if (volp->cbServerpRO) {
1647             if (!((volp->cbServerpRO->flags & CM_SERVERFLAG_UUID) &&
1648                 UuidToString((UUID *)&volp->cbServerpRO->uuid, &srvStr) == RPC_S_OK)) {
1649                 srvStr = malloc(16);
1650                 if (srvStr != NULL)
1651                     afs_inet_ntoa_r(volp->cbServerpRO->addr.sin_addr.s_addr, srvStr);
1652                 srvStrRpc = FALSE;
1653             }
1654         }
1655         if (volp->cbExpiresRO) {
1656             t = volp->cbExpiresRO;
1657             cbt = ctime(&t);
1658             if (cbt) {
1659                 cbt = strdup(cbt);
1660                 cbt[strlen(cbt)-1] = '\0';
1661             }
1662         }
1663         if (volp->creationDateRO) {
1664             t = volp->creationDateRO;
1665             cdrot = ctime(&t);
1666             if (cdrot) {
1667                 cdrot = strdup(cdrot);
1668                 cdrot[strlen(cdrot)-1] = '\0';
1669             }
1670         }
1671
1672         sprintf(output,
1673                 "%s - volp=0x%p cell=%s name=%s rwID=%u roID=%u bkID=%u flags=0x%x:%x "
1674                 "cbServerpRO='%s' cbExpiresRO='%s' creationDateRO='%s' refCount=%u\r\n",
1675                  cookie, volp, volp->cellp->name, volp->namep, volp->vol[RWVOL].ID,
1676                  volp->vol[ROVOL].ID, volp->vol[BACKVOL].ID, volp->flags, volp->qflags,
1677                  srvStr ? srvStr : "<none>", cbt ? cbt : "<none>", cdrot ? cdrot : "<none>",
1678                  volp->refCount);
1679         WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1680
1681         if (srvStr) {
1682             if (srvStrRpc)
1683                 RpcStringFree(&srvStr);
1684             else
1685                 free(srvStr);
1686         }
1687         if (cbt)
1688             free(cbt);
1689         if (cdrot)
1690             free(cdrot);
1691     }
1692     sprintf(output, "%s - Done dumping volumes.\r\n", cookie);
1693     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1694
1695     if (lock) {
1696         lock_ReleaseRead(&cm_volumeLock);
1697         lock_ReleaseRead(&cm_scacheLock);
1698     }
1699     return (0);
1700 }
1701
1702
1703 /*
1704  * String hash function used by SDBM project.
1705  * It was chosen because it is fast and provides
1706  * decent coverage.
1707  */
1708 afs_uint32 SDBMHash(const char * str)
1709 {
1710     afs_uint32 hash = 0;
1711     size_t i, len;
1712
1713     if (str == NULL)
1714         return 0;
1715
1716     for(i = 0, len = strlen(str); i < len; i++)
1717     {
1718         hash = str[i] + (hash << 6) + (hash << 16) - hash;
1719     }
1720
1721     return (hash & 0x7FFFFFFF);
1722 }
1723
1724 /* call with volume write-locked and mutex held */
1725 void cm_AddVolumeToNameHashTable(cm_volume_t *volp)
1726 {
1727     int i;
1728
1729     if (volp->qflags & CM_VOLUME_QFLAG_IN_HASH)
1730         return;
1731
1732     i = CM_VOLUME_NAME_HASH(volp->namep);
1733
1734     volp->nameNextp = cm_data.volumeNameHashTablep[i];
1735     cm_data.volumeNameHashTablep[i] = volp;
1736     _InterlockedOr(&volp->qflags, CM_VOLUME_QFLAG_IN_HASH);
1737 }
1738
1739 /* call with volume write-locked and mutex held */
1740 void cm_RemoveVolumeFromNameHashTable(cm_volume_t *volp)
1741 {
1742     cm_volume_t **lvolpp;
1743     cm_volume_t *tvolp;
1744     int i;
1745
1746     if (volp->qflags & CM_VOLUME_QFLAG_IN_HASH) {
1747         /* hash it out first */
1748         i = CM_VOLUME_NAME_HASH(volp->namep);
1749         for (lvolpp = &cm_data.volumeNameHashTablep[i], tvolp = cm_data.volumeNameHashTablep[i];
1750              tvolp;
1751              lvolpp = &tvolp->nameNextp, tvolp = tvolp->nameNextp) {
1752             if (tvolp == volp) {
1753                 *lvolpp = volp->nameNextp;
1754                 _InterlockedAnd(&volp->qflags, ~CM_VOLUME_QFLAG_IN_HASH);
1755                 volp->nameNextp = NULL;
1756                 break;
1757             }
1758         }
1759     }
1760 }
1761
1762 /* call with volume write-locked and mutex held */
1763 void cm_AddVolumeToIDHashTable(cm_volume_t *volp, afs_uint32 volType)
1764 {
1765     int i;
1766     struct cm_vol_state * statep;
1767
1768     statep = cm_VolumeStateByType(volp, volType);
1769
1770     if (statep->qflags & CM_VOLUME_QFLAG_IN_HASH)
1771         return;
1772
1773     i = CM_VOLUME_ID_HASH(statep->ID);
1774
1775     switch (volType) {
1776     case RWVOL:
1777         statep->nextp = cm_data.volumeRWIDHashTablep[i];
1778         cm_data.volumeRWIDHashTablep[i] = volp;
1779         break;
1780     case ROVOL:
1781         statep->nextp = cm_data.volumeROIDHashTablep[i];
1782         cm_data.volumeROIDHashTablep[i] = volp;
1783         break;
1784     case BACKVOL:
1785         statep->nextp = cm_data.volumeBKIDHashTablep[i];
1786         cm_data.volumeBKIDHashTablep[i] = volp;
1787         break;
1788     }
1789     _InterlockedOr(&statep->qflags, CM_VOLUME_QFLAG_IN_HASH);
1790 }
1791
1792
1793 /* call with volume write-locked and mutex held */
1794 void cm_RemoveVolumeFromIDHashTable(cm_volume_t *volp, afs_uint32 volType)
1795 {
1796     cm_volume_t **lvolpp;
1797     cm_volume_t *tvolp;
1798     struct cm_vol_state * statep;
1799     int i;
1800
1801     statep = cm_VolumeStateByType(volp, volType);
1802
1803     if (statep->qflags & CM_VOLUME_QFLAG_IN_HASH) {
1804         /* hash it out first */
1805         i = CM_VOLUME_ID_HASH(statep->ID);
1806
1807         switch (volType) {
1808         case RWVOL:
1809             lvolpp = &cm_data.volumeRWIDHashTablep[i];
1810             tvolp = cm_data.volumeRWIDHashTablep[i];
1811             break;
1812         case ROVOL:
1813             lvolpp = &cm_data.volumeROIDHashTablep[i];
1814             tvolp = cm_data.volumeROIDHashTablep[i];
1815             break;
1816         case BACKVOL:
1817             lvolpp = &cm_data.volumeBKIDHashTablep[i];
1818             tvolp = cm_data.volumeBKIDHashTablep[i];
1819             break;
1820         default:
1821             osi_assertx(0, "invalid volume type");
1822         }
1823         do {
1824             if (tvolp == volp) {
1825                 *lvolpp = statep->nextp;
1826                 _InterlockedAnd(&statep->qflags, ~CM_VOLUME_QFLAG_IN_HASH);
1827                 statep->nextp = NULL;
1828                 break;
1829             }
1830
1831             lvolpp = &tvolp->vol[volType].nextp;
1832             tvolp = tvolp->vol[volType].nextp;
1833         } while(tvolp);
1834     }
1835 }
1836
1837 /* must be called with cm_volumeLock write-locked! */
1838 void cm_AdjustVolumeLRU(cm_volume_t *volp)
1839 {
1840     lock_AssertWrite(&cm_volumeLock);
1841
1842     if (volp == cm_data.volumeLRUFirstp)
1843         return;
1844
1845     if (volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE)
1846         osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1847     osi_QAddH((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1848     _InterlockedOr(&volp->qflags, CM_VOLUME_QFLAG_IN_LRU_QUEUE);
1849
1850     osi_assertx(cm_data.volumeLRULastp != NULL, "null cm_data.volumeLRULastp");
1851 }
1852
1853 /* must be called with cm_volumeLock write-locked! */
1854 void cm_MoveVolumeToLRULast(cm_volume_t *volp)
1855 {
1856     lock_AssertWrite(&cm_volumeLock);
1857
1858     if (volp == cm_data.volumeLRULastp)
1859         return;
1860
1861     if (volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE)
1862         osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1863     osi_QAddT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1864     _InterlockedOr(&volp->qflags, CM_VOLUME_QFLAG_IN_LRU_QUEUE);
1865
1866     osi_assertx(cm_data.volumeLRULastp != NULL, "null cm_data.volumeLRULastp");
1867 }
1868
1869 /* must be called with cm_volumeLock write-locked! */
1870 void cm_RemoveVolumeFromLRU(cm_volume_t *volp)
1871 {
1872     lock_AssertWrite(&cm_volumeLock);
1873
1874     if (volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE) {
1875         osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1876         _InterlockedAnd(&volp->qflags, ~CM_VOLUME_QFLAG_IN_LRU_QUEUE);
1877     }
1878
1879     osi_assertx(cm_data.volumeLRULastp != NULL, "null cm_data.volumeLRULastp");
1880 }
1881
1882 static char * volstatus_str(enum volstatus vs)
1883 {
1884     switch (vs) {
1885     case vl_online:
1886         return "online";
1887     case vl_busy:
1888         return "busy";
1889     case vl_offline:
1890         return "offline";
1891     case vl_alldown:
1892         return "alldown";
1893     default:
1894         return "unknown";
1895     }
1896 }
1897
1898 void cm_VolumeStatusNotification(cm_volume_t * volp, afs_uint32 volID, enum volstatus old, enum volstatus new)
1899 {
1900     char volstr[CELL_MAXNAMELEN + VL_MAXNAMELEN]="";
1901     char *ext = "";
1902
1903     if (volID == volp->vol[RWVOL].ID)
1904         ext = "";
1905     else if (volID == volp->vol[ROVOL].ID)
1906         ext = ".readonly";
1907     else if (volID == volp->vol[BACKVOL].ID)
1908         ext = ".backup";
1909     else
1910         ext = ".nomatch";
1911     snprintf(volstr, sizeof(volstr), "%s:%s%s", volp->cellp->name, volp->namep, ext);
1912
1913     osi_Log4(afsd_logp, "VolumeStatusNotification: %-48s [%10u] (%s -> %s)",
1914              osi_LogSaveString(afsd_logp, volstr), volID, volstatus_str(old), volstatus_str(new));
1915
1916     cm_VolStatus_Change_Notification(volp->cellp->cellID, volID, new);
1917 }
1918
1919 enum volstatus cm_GetVolumeStatus(cm_volume_t *volp, afs_uint32 volID)
1920 {
1921     cm_vol_state_t * statep = cm_VolumeStateByID(volp, volID);
1922     if (statep)
1923         return statep->state;
1924     else
1925         return vl_unknown;
1926 }
1927
1928 /* Renew .readonly volume callbacks that are more than
1929  * 30 minutes old.  (A volume callback is issued for 2 hours.)
1930  */
1931 void
1932 cm_VolumeRenewROCallbacks(void)
1933 {
1934     cm_volume_t * volp;
1935     time_t minexp = time(NULL) + 90 * 60;
1936     extern int daemon_ShutdownFlag;
1937     extern int powerStateSuspended;
1938
1939     lock_ObtainRead(&cm_volumeLock);
1940     for (volp = cm_data.allVolumesp;
1941          volp && !daemon_ShutdownFlag && !powerStateSuspended;
1942          volp=volp->allNextp) {
1943         if ( volp->cbExpiresRO > 0 && volp->cbExpiresRO < minexp) {
1944             cm_req_t      req;
1945             cm_fid_t      fid;
1946             cm_scache_t * scp;
1947
1948             cm_SetFid(&fid, volp->cellp->cellID, volp->vol[ROVOL].ID, 1, 1);
1949
1950             cm_InitReq(&req);
1951
1952             lock_ReleaseRead(&cm_volumeLock);
1953             if (cm_GetSCache(&fid, NULL, &scp, cm_rootUserp, &req) == 0) {
1954                 lock_ObtainWrite(&scp->rw);
1955                 cm_GetCallback(scp, cm_rootUserp, &req, 1);
1956                 lock_ReleaseWrite(&scp->rw);
1957                 cm_ReleaseSCache(scp);
1958             }
1959             lock_ObtainRead(&cm_volumeLock);
1960         }
1961     }
1962     lock_ReleaseRead(&cm_volumeLock);
1963 }
1964
1965 cm_vol_state_t *
1966 cm_VolumeStateByType(cm_volume_t *volp, afs_uint32 volType)
1967 {
1968     return &volp->vol[volType];
1969 }
1970
1971 cm_vol_state_t *
1972 cm_VolumeStateByID(cm_volume_t *volp, afs_uint32 id)
1973 {
1974     cm_vol_state_t * statep = NULL;
1975
1976     if (id == volp->vol[RWVOL].ID)
1977         statep = &volp->vol[RWVOL];
1978     else if (id == volp->vol[ROVOL].ID)
1979         statep = &volp->vol[ROVOL];
1980     else if (id == volp->vol[BACKVOL].ID)
1981         statep = &volp->vol[BACKVOL];
1982
1983     return(statep);
1984 }
1985
1986 cm_vol_state_t *
1987 cm_VolumeStateByName(cm_volume_t *volp, char *volname)
1988 {
1989     size_t len = strlen(volname);
1990     cm_vol_state_t *statep;
1991
1992     if (cm_stricmp_utf8N(".readonly", &volname[len-9]) == 0)
1993         statep = &volp->vol[ROVOL];
1994     else if (cm_stricmp_utf8N(".backup", &volname[len-7]) == 0)
1995         statep = &volp->vol[BACKVOL];
1996     else
1997         statep = &volp->vol[RWVOL];
1998
1999     return statep;
2000 }
2001
2002 afs_int32
2003 cm_VolumeType(cm_volume_t *volp, afs_uint32 id)
2004 {
2005     if (id == volp->vol[RWVOL].ID)
2006         return(RWVOL);
2007     else if (id == volp->vol[ROVOL].ID)
2008         return(ROVOL);
2009     else if (id == volp->vol[BACKVOL].ID)
2010         return (BACKVOL);
2011
2012     return -1;
2013 }
2014
2015 LONG_PTR
2016 cm_ChecksumVolumeServerList(struct cm_fid *fidp, cm_user_t *userp, cm_req_t *reqp)
2017 {
2018     LONG_PTR cksum = 0;
2019     long code;
2020     afs_uint32 replicated;
2021     cm_serverRef_t **serverspp;
2022
2023     code = cm_GetServerList(fidp, userp, reqp, &replicated, &serverspp);
2024     if (code == 0) {
2025         cksum = cm_ChecksumServerList(*serverspp);
2026         cm_FreeServerList(serverspp, 0);
2027     }
2028     return cksum;
2029 }
2030
2031 afs_int32
2032 cm_IsVolumeReplicated(cm_fid_t *fidp)
2033 {
2034     afs_int32 replicated = 0;
2035     cm_volume_t *volp;
2036     cm_vol_state_t * volstatep;
2037
2038     volp = cm_GetVolumeByFID(fidp);
2039     if (volp) {
2040         volstatep = cm_VolumeStateByID(volp, fidp->volume);
2041         replicated = (volstatep->flags & CM_VOL_STATE_FLAG_REPLICATED);
2042         cm_PutVolume(volp);
2043     }
2044
2045     return replicated;
2046 }