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                     char uuid1[128], uuid2[128];
 585                     char hoststr[16];
 586
 587                     afsUUID_to_string(&serverUUID[i], uuid1, sizeof(uuid1));
 588                     afsUUID_to_string(&tsp->uuid, uuid2, sizeof(uuid2));
 589                     afs_inet_ntoa_r(serverNumber[i], hoststr);
 590
 591                     osi_Log3(afsd_logp, "cm_UpdateVolumeLocation UUIDs do not match! %s != %s (%s)",
 592                               osi_LogSaveString(afsd_logp, uuid1),
 593                               osi_LogSaveString(afsd_logp, uuid2),
 594                               osi_LogSaveString(afsd_logp, hoststr));
 595                 }
 596             }
 597             if (!tsp) {
 598                 /*
 599                  * cm_NewServer will probe the file server which in turn will
 600                  * update the state on the volume group object.  Do not probe
 601                  * in this thread.  It will block the thread and can result in
 602                  * a recursive call to cm_UpdateVolumeLocation().
 603                  */
 604                 lock_ReleaseWrite(&volp->rw);
 605                 tsp = cm_NewServer(&tsockAddr, CM_SERVER_FILE, cellp, &serverUUID[i], CM_FLAG_NOPROBE);
 606                 lock_ObtainWrite(&volp->rw);
 607             }
 608             osi_assertx(tsp != NULL, "null cm_server_t");
 609
 610             /*
 611              * if this server was created by fs setserverprefs
 612              * then it won't have either a cell assignment or
 613              * a server uuid.
 614              */
 615             if ( !tsp->cellp )
 616                 tsp->cellp = cellp;
 617             if ( (method == 2) && !(tsp->flags & CM_SERVERFLAG_UUID) &&
 618                  !afs_uuid_is_nil(&serverUUID[i])) {
 619                 tsp->uuid = serverUUID[i];
 620                 _InterlockedOr(&tsp->flags, CM_SERVERFLAG_UUID);
 621             }
 622
 623             /* and add it to the list(s). */
 624             /*
 625              * Each call to cm_NewServerRef() increments the
 626              * ref count of tsp.  These reference will be dropped,
 627              * if and when the volume is reset; see reset code
 628              * earlier in this function.
 629              */
 630             if ((tflags & VLSF_RWVOL) && (flags & VLF_RWEXISTS)) {
 631                 tsrp = cm_NewServerRef(tsp, rwID);
 632                 cm_InsertServerList(&volp->vol[RWVOL].serversp, tsrp);
 633                 if (!(tsp->flags & CM_SERVERFLAG_DOWN))
 634                     rwServers_alldown = 0;
 635             }
 636             /*
 637              * If there are mixed versions of RO releases on the replica
 638              * sites, skip the servers with the out of date versions.
 639              */
 640             if ((tflags & VLSF_ROVOL) && (flags & VLF_ROEXISTS) &&
 641                 (!isMixed || (tflags & VLSF_NEWREPSITE))) {
 642                 tsrp = cm_NewServerRef(tsp, roID);
 643                 cm_InsertServerList(&volp->vol[ROVOL].serversp, tsrp);
 644                 ROcount++;
 645
 646                 if (!(tsp->flags & CM_SERVERFLAG_DOWN))
 647                     roServers_alldown = 0;
 648             }
 649             /* We don't use VLSF_BACKVOL !?! */
 650             /* Because only the backup on the server holding the RW
 651              * volume can be valid.  This check prevents errors if a
 652              * RW is moved but the old backup is not removed.
 653              */
 654             if ((tflags & VLSF_RWVOL) && (flags & VLF_BACKEXISTS)) {
 655                 tsrp = cm_NewServerRef(tsp, bkID);
 656                 cm_InsertServerList(&volp->vol[BACKVOL].serversp, tsrp);
 657
 658                 if (!(tsp->flags & CM_SERVERFLAG_DOWN))
 659                     bkServers_alldown = 0;
 660             }
 661             /* Drop the reference obtained by cm_FindServer() */
 662             cm_PutServer(tsp);
 663         }
 664
 665         /*
 666          * Randomize RO list
 667          *
 668          * If the first n servers have the same rank, then we
 669          * randomly pick one among them and move it to the beginning.
 670          * We don't bother to re-order the whole list because
 671          * the rest of the list is used only if the first server is
 672          * down.  We only do this for the RO list; we assume the other
 673          * lists are length 1.
 674          */
 675         if (ROcount > 1) {
 676             cm_RandomizeServer(&volp->vol[ROVOL].serversp);
 677             _InterlockedOr(&volp->vol[ROVOL].flags, CM_VOL_STATE_FLAG_REPLICATED);
 678         }
 679         else {
 680             _InterlockedAnd(&volp->vol[ROVOL].flags, ~CM_VOL_STATE_FLAG_REPLICATED);
 681         }
 682
 683         rwNewstate = rwServers_alldown ? vl_alldown : vl_online;
 684         roNewstate = roServers_alldown ? vl_alldown : vl_online;
 685         bkNewstate = bkServers_alldown ? vl_alldown : vl_online;
 686
 687         _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_NOEXIST);
 688     } else if (code == CM_ERROR_NOSUCHVOLUME || code == VL_NOENT || code == VL_BADNAME) {
 689         _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_NOEXIST);
 690     } else {
 691         rwNewstate = roNewstate = bkNewstate = vl_alldown;
 692
 693         /*
 694          * we are updating lastUpdateTime but didn't get an answer
 695          * so clear the no exist flag.
 696          */
 697         _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_NOEXIST);
 698     }
 699
 700     if (volp->vol[RWVOL].state != rwNewstate) {
 701         if (volp->vol[RWVOL].ID)
 702             cm_VolumeStatusNotification(volp, volp->vol[RWVOL].ID, volp->vol[RWVOL].state, rwNewstate);
 703         volp->vol[RWVOL].state = rwNewstate;
 704     }
 705     if (volp->vol[ROVOL].state != roNewstate) {
 706         if (volp->vol[ROVOL].ID)
 707             cm_VolumeStatusNotification(volp, volp->vol[ROVOL].ID, volp->vol[ROVOL].state, roNewstate);
 708         volp->vol[ROVOL].state = roNewstate;
 709     }
 710     if (volp->vol[BACKVOL].state != bkNewstate) {
 711         if (volp->vol[BACKVOL].ID)
 712             cm_VolumeStatusNotification(volp, volp->vol[BACKVOL].ID, volp->vol[BACKVOL].state, bkNewstate);
 713         volp->vol[BACKVOL].state = bkNewstate;
 714     }
 715
 716     if (code == 0 || (volp->flags & CM_VOLUMEFLAG_NOEXIST))
 717         volp->lastUpdateTime = time(NULL);
 718
 719     if (isMixed)
 720         _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_RO_MIXED);
 721     else
 722         _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_RO_MIXED);
 723
 724     if (code == 0)
 725         _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_RESET);
 726
 727     _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_UPDATING_VL);
 728     osi_Log4(afsd_logp, "cm_UpdateVolumeLocation done, waking others name %s:%s flags 0x%x code 0x%x",
 729              osi_LogSaveString(afsd_logp,volp->cellp->name),
 730              osi_LogSaveString(afsd_logp,volp->namep), volp->flags, code);
 731     osi_Wakeup((LONG_PTR) &volp->flags);
 732
 733     return code;
 734 }
 735
 736 /* Requires read or write lock on cm_volumeLock */
 737 void cm_GetVolume(cm_volume_t *volp)
 738 {
 739     InterlockedIncrement(&volp->refCount);
 740 }
 741
 742 cm_volume_t *cm_GetVolumeByFID(cm_fid_t *fidp)
 743 {
 744     cm_volume_t *volp;
 745     afs_uint32 hash;
 746
 747     lock_ObtainRead(&cm_volumeLock);
 748     hash = CM_VOLUME_ID_HASH(fidp->volume);
 749     /* The volumeID can be any one of the three types.  So we must
 750      * search the hash table for all three types until we find it.
 751      * We will search in the order of RO, RW, BK.
 752      */
 753     for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = volp->vol[ROVOL].nextp) {
 754         if ( fidp->cell == volp->cellp->cellID && fidp->volume == volp->vol[ROVOL].ID )
 755             break;
 756     }
 757     if (!volp) {
 758         /* try RW volumes */
 759         for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = volp->vol[RWVOL].nextp) {
 760             if ( fidp->cell == volp->cellp->cellID && fidp->volume == volp->vol[RWVOL].ID )
 761                 break;
 762         }
 763     }
 764     if (!volp) {
 765         /* try BK volumes */
 766         for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = volp->vol[BACKVOL].nextp) {
 767             if ( fidp->cell == volp->cellp->cellID && fidp->volume == volp->vol[BACKVOL].ID )
 768                 break;
 769         }
 770     }
 771
 772     /* hold the volume if we found it */
 773     if (volp)
 774         cm_GetVolume(volp);
 775
 776     lock_ReleaseRead(&cm_volumeLock);
 777     return volp;
 778 }
 779
 780 cm_volume_t *cm_FindVolumeByFID(cm_fid_t *fidp, cm_user_t *userp, cm_req_t *reqp)
 781 {
 782     cm_volume_t *volp = NULL;
 783     cm_cell_t   *cellp;
 784     long         code;
 785
 786     cellp = cm_FindCellByID(fidp->cell, CM_FLAG_NOPROBE);
 787     if (!cellp) {
 788         return NULL;
 789     }
 790
 791     code = cm_FindVolumeByID(cellp, fidp->volume, userp, reqp, CM_GETVOL_FLAG_CREATE, &volp);
 792     if (code)
 793         return NULL;
 794
 795     return volp;
 796 }
 797
 798 long cm_FindVolumeByID(cm_cell_t *cellp, afs_uint32 volumeID, cm_user_t *userp,
 799                       cm_req_t *reqp, afs_uint32 flags, cm_volume_t **outVolpp)
 800 {
 801     cm_volume_t *volp;
 802 #ifdef SEARCH_ALL_VOLUMES
 803     cm_volume_t *volp2;
 804 #endif
 805     char volNameString[VL_MAXNAMELEN];
 806     afs_uint32 hash;
 807     long code = 0;
 808
 809     lock_ObtainRead(&cm_volumeLock);
 810 #ifdef SEARCH_ALL_VOLUMES
 811     for(volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
 812         if (cellp == volp->cellp &&
 813              ((unsigned) volumeID == volp->vol[RWVOL].ID ||
 814                (unsigned) volumeID == volp->vol[ROVOL].ID ||
 815                (unsigned) volumeID == volp->vol[BACKVOL].ID))
 816             break;
 817     }
 818
 819     volp2 = volp;
 820 #endif /* SEARCH_ALL_VOLUMES */
 821
 822     hash = CM_VOLUME_ID_HASH(volumeID);
 823     /* The volumeID can be any one of the three types.  So we must
 824      * search the hash table for all three types until we find it.
 825      * We will search in the order of RO, RW, BK.
 826      */
 827     for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = volp->vol[ROVOL].nextp) {
 828         if ( cellp == volp->cellp && volumeID == volp->vol[ROVOL].ID )
 829             break;
 830     }
 831     if (!volp) {
 832         /* try RW volumes */
 833         for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = volp->vol[RWVOL].nextp) {
 834             if ( cellp == volp->cellp && volumeID == volp->vol[RWVOL].ID )
 835                 break;
 836         }
 837     }
 838     if (!volp) {
 839         /* try BK volumes */
 840         for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = volp->vol[BACKVOL].nextp) {
 841             if ( cellp == volp->cellp && volumeID == volp->vol[BACKVOL].ID )
 842                 break;
 843         }
 844     }
 845
 846 #ifdef SEARCH_ALL_VOLUMES
 847     osi_assertx(volp == volp2, "unexpected cm_vol_t");
 848 #endif
 849
 850     /* hold the volume if we found it */
 851     if (volp)
 852         cm_GetVolume(volp);
 853
 854     lock_ReleaseRead(&cm_volumeLock);
 855
 856     /* return it held */
 857     if (volp) {
 858         lock_ObtainWrite(&volp->rw);
 859
 860         code = 0;
 861         if ((volp->flags & CM_VOLUMEFLAG_RESET) && !(flags & CM_GETVOL_FLAG_NO_RESET)) {
 862             code = cm_UpdateVolumeLocation(cellp, userp, reqp, volp);
 863         }
 864         lock_ReleaseWrite(&volp->rw);
 865         if (code == 0) {
 866             *outVolpp = volp;
 867
 868             if (!(flags & CM_GETVOL_FLAG_NO_LRU_UPDATE)) {
 869                 lock_ObtainWrite(&cm_volumeLock);
 870                 cm_AdjustVolumeLRU(volp);
 871                 lock_ReleaseWrite(&cm_volumeLock);
 872             }
 873         } else {
 874             lock_ObtainRead(&cm_volumeLock);
 875             cm_PutVolume(volp);
 876             lock_ReleaseRead(&cm_volumeLock);
 877         }
 878         return code;
 879     }
 880
 881     /* otherwise, we didn't find it so consult the VLDB */
 882     sprintf(volNameString, "%u", volumeID);
 883     code = cm_FindVolumeByName(cellp, volNameString, userp, reqp,
 884                               flags | CM_GETVOL_FLAG_IGNORE_LINKED_CELL, outVolpp);
 885
 886     if (code == CM_ERROR_NOSUCHVOLUME && cellp->linkedName[0] &&
 887         !(flags & CM_GETVOL_FLAG_IGNORE_LINKED_CELL)) {
 888         cm_cell_t *linkedCellp = cm_GetCell(cellp->linkedName, flags);
 889
 890         if (linkedCellp)
 891             code = cm_FindVolumeByID(linkedCellp, volumeID, userp, reqp,
 892                                      flags | CM_GETVOL_FLAG_IGNORE_LINKED_CELL,
 893                                      outVolpp);
 894     }
 895     return code;
 896 }
 897
 898
 899 long cm_FindVolumeByName(struct cm_cell *cellp, char *volumeNamep,
 900                         struct cm_user *userp, struct cm_req *reqp,
 901                         afs_uint32 flags, cm_volume_t **outVolpp)
 902 {
 903     cm_volume_t *volp;
 904 #ifdef SEARCH_ALL_VOLUMES
 905     cm_volume_t *volp2;
 906 #endif
 907     long        code = 0;
 908     char        name[VL_MAXNAMELEN];
 909     size_t      len;
 910     int         type;
 911     afs_uint32  hash;
 912
 913     strncpy(name, volumeNamep, VL_MAXNAMELEN);
 914     name[VL_MAXNAMELEN-1] = '\0';
 915     len = strlen(name);
 916
 917     if (len >= 8 && strcmp(name + len - 7, ".backup") == 0) {
 918         type = BACKVOL;
 919         name[len - 7] = '\0';
 920     } else if (len >= 10 && strcmp(name + len - 9, ".readonly") == 0) {
 921         type = ROVOL;
 922         name[len - 9] = '\0';
 923     } else {
 924         type = RWVOL;
 925     }
 926
 927     lock_ObtainRead(&cm_volumeLock);
 928 #ifdef SEARCH_ALL_VOLUMES
 929     for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
 930         if (cellp == volp->cellp && strcmp(name, volp->namep) == 0) {
 931             break;
 932         }
 933     }
 934     volp2 = volp;
 935 #endif /* SEARCH_ALL_VOLUMES */
 936
 937     hash = CM_VOLUME_NAME_HASH(name);
 938     for (volp = cm_data.volumeNameHashTablep[hash]; volp; volp = volp->nameNextp) {
 939         if (cellp == volp->cellp && strcmp(name, volp->namep) == 0)
 940             break;
 941     }
 942
 943 #ifdef SEARCH_ALL_VOLUMES
 944     osi_assertx(volp2 == volp, "unexpected cm_vol_t");
 945 #endif
 946
 947     if (!volp && (flags & CM_GETVOL_FLAG_CREATE)) {
 948         afs_uint32 volType;
 949         /* otherwise, get from VLDB */
 950
 951         /*
 952          * Change to a write lock so that we have exclusive use of
 953          * the first cm_volume_t with a refCount of 0 so that we
 954          * have time to increment it.
 955          */
 956         lock_ConvertRToW(&cm_volumeLock);
 957
 958         /*
 959          * While the lock was converted it may have been dropped
 960          * Search again now that we are exclusive.
 961          */
 962         for (volp = cm_data.volumeNameHashTablep[hash]; volp; volp = volp->nameNextp) {
 963             if (cellp == volp->cellp && strcmp(name, volp->namep) == 0)
 964                 break;
 965         }
 966
 967         if (volp) {
 968             cm_GetVolume(volp);
 969             lock_ReleaseWrite(&cm_volumeLock);
 970             lock_ObtainWrite(&volp->rw);
 971         } else {
 972             if ( cm_data.currentVolumes >= cm_data.maxVolumes ) {
 973 #ifdef RECYCLE_FROM_ALL_VOLUMES_LIST
 974                 for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
 975                     if ( volp->refCount == 0 ) {
 976                         /* There is one we can re-use */
 977                         break;
 978                     }
 979                 }
 980 #else
 981                 for ( volp = cm_data.volumeLRULastp;
 982                       volp;
 983                       volp = (cm_volume_t *) osi_QPrev(&volp->q))
 984                 {
 985                     if ( volp->refCount == 0 ) {
 986                         /* There is one we can re-use */
 987                         break;
 988                     }
 989                 }
 990 #endif
 991                 if (!volp)
 992                     osi_panic("Exceeded Max Volumes", __FILE__, __LINE__);
 993
 994                 osi_Log2(afsd_logp, "Recycling Volume %s:%s",
 995                          volp->cellp->name, volp->namep);
 996
 997                 /* The volp is removed from the LRU queue in order to
 998                  * prevent two threads from attempting to recycle the
 999                  * same object.  This volp must be re-inserted back into
1000                  * the LRU queue before this function exits.
1001                  */
1002                 if (volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE)
1003                     cm_RemoveVolumeFromLRU(volp);
1004                 if (volp->qflags & CM_VOLUME_QFLAG_IN_HASH)
1005                     cm_RemoveVolumeFromNameHashTable(volp);
1006
1007                 for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
1008                     if (volp->vol[volType].qflags & CM_VOLUME_QFLAG_IN_HASH)
1009                         cm_RemoveVolumeFromIDHashTable(volp, volType);
1010                     if (volp->vol[volType].ID)
1011                         cm_VolumeStatusNotification(volp, volp->vol[volType].ID, volp->vol[volType].state, vl_unknown);
1012                     volp->vol[volType].ID = 0;
1013                     cm_SetFid(&volp->vol[volType].dotdotFid, 0, 0, 0, 0);
1014                 }
1015             } else {
1016                 volp = &cm_data.volumeBaseAddress[InterlockedIncrement(&cm_data.currentVolumes) - 1];
1017                 memset(volp, 0, sizeof(cm_volume_t));
1018                 volp->magic = CM_VOLUME_MAGIC;
1019                 volp->allNextp = cm_data.allVolumesp;
1020                 cm_data.allVolumesp = volp;
1021                 lock_InitializeRWLock(&volp->rw, "cm_volume_t rwlock", LOCK_HIERARCHY_VOLUME);
1022             }
1023             /*
1024              * no one else can find this object and we have not dropped
1025              * cm_volumeLock in any case.  The object is either new or
1026              * recycled.  Initialize its new values and put it into the
1027              * name hash table before dropping cm_volumeLock which makes
1028              * it visible to competing threads.
1029              */
1030             volp->cellp = cellp;
1031             strncpy(volp->namep, name, VL_MAXNAMELEN);
1032             volp->namep[VL_MAXNAMELEN-1] = '\0';
1033             volp->flags = CM_VOLUMEFLAG_RESET;
1034             volp->lastUpdateTime = 0;
1035
1036             for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
1037                 volp->vol[volType].state = vl_unknown;
1038                 volp->vol[volType].nextp = NULL;
1039                 volp->vol[volType].flags = 0;
1040             }
1041             volp->cbExpiresRO = 0;
1042             volp->cbIssuedRO = 0;
1043             volp->cbServerpRO = NULL;
1044             volp->creationDateRO = 0;
1045             cm_AddVolumeToNameHashTable(volp);
1046             cm_GetVolume(volp);
1047             lock_ReleaseWrite(&cm_volumeLock);
1048             lock_ObtainWrite(&volp->rw);
1049             for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
1050                 cm_FreeServerList(&volp->vol[volType].serversp, CM_FREESERVERLIST_DELETE);
1051             }
1052         }
1053     }
1054     else if (volp) {
1055         cm_GetVolume(volp);
1056         lock_ReleaseRead(&cm_volumeLock);
1057         lock_ObtainWrite(&volp->rw);
1058     } else {
1059         lock_ReleaseRead(&cm_volumeLock);
1060         return CM_ERROR_NOSUCHVOLUME;
1061     }
1062
1063     /* if we get here we are holding the mutex */
1064     if ((volp->flags & CM_VOLUMEFLAG_RESET) && !(flags & CM_GETVOL_FLAG_NO_RESET)) {
1065         code = cm_UpdateVolumeLocation(cellp, userp, reqp, volp);
1066     }
1067     lock_ReleaseWrite(&volp->rw);
1068
1069     if (code == 0 && (type == BACKVOL && volp->vol[BACKVOL].ID == 0 ||
1070                       type == ROVOL && volp->vol[ROVOL].ID == 0))
1071         code = CM_ERROR_NOSUCHVOLUME;
1072
1073     if (code == 0) {
1074         *outVolpp = volp;
1075
1076         lock_ObtainWrite(&cm_volumeLock);
1077         if (!(volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE) ||
1078              (flags & CM_GETVOL_FLAG_NO_LRU_UPDATE))
1079             cm_AdjustVolumeLRU(volp);
1080         lock_ReleaseWrite(&cm_volumeLock);
1081     } else {
1082         /*
1083          * do not return it to the caller but do insert it in the LRU
1084          * otherwise it will be lost
1085          */
1086         lock_ObtainWrite(&cm_volumeLock);
1087         if (!(volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE) ||
1088              (flags & CM_GETVOL_FLAG_NO_LRU_UPDATE))
1089             cm_AdjustVolumeLRU(volp);
1090         cm_PutVolume(volp);
1091         lock_ReleaseWrite(&cm_volumeLock);
1092     }
1093
1094     if (code == CM_ERROR_NOSUCHVOLUME && cellp->linkedName[0] &&
1095         !(flags & CM_GETVOL_FLAG_IGNORE_LINKED_CELL)) {
1096         cm_cell_t *linkedCellp = cm_GetCell(cellp->linkedName, flags);
1097
1098         if (linkedCellp)
1099             code = cm_FindVolumeByName(linkedCellp, volumeNamep, userp, reqp,
1100                                        flags | CM_GETVOL_FLAG_IGNORE_LINKED_CELL,
1101                                        outVolpp);
1102     }
1103     return code;
1104 }
1105
1106 /*
1107  * Only call this function in response to a VNOVOL or VMOVED error
1108  * from a file server.  Do not call it in response to CM_ERROR_NOSUCHVOLUME
1109  * as that can lead to recursive calls.
1110  */
1111 long cm_ForceUpdateVolume(cm_fid_t *fidp, cm_user_t *userp, cm_req_t *reqp)
1112 {
1113     cm_cell_t *cellp;
1114     cm_volume_t *volp;
1115 #ifdef SEARCH_ALL_VOLUMES
1116     cm_volume_t *volp2;
1117 #endif
1118     afs_uint32  hash;
1119     long code;
1120
1121     if (!fidp)
1122         return CM_ERROR_INVAL;
1123
1124     cellp = cm_FindCellByID(fidp->cell, 0);
1125     if (!cellp)
1126         return CM_ERROR_NOSUCHCELL;
1127
1128     /* search for the volume */
1129     lock_ObtainRead(&cm_volumeLock);
1130 #ifdef SEARCH_ALL_VOLUMES
1131     for(volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
1132         if (cellp == volp->cellp &&
1133              (fidp->volume == volp->vol[RWVOL].ID ||
1134                fidp->volume == volp->vol[ROVOL].ID ||
1135                fidp->volume == volp->vol[BACKVOL].ID))
1136             break;
1137     }
1138 #endif /* SEARCH_ALL_VOLUMES */
1139
1140     hash = CM_VOLUME_ID_HASH(fidp->volume);
1141     /* The volumeID can be any one of the three types.  So we must
1142      * search the hash table for all three types until we find it.
1143      * We will search in the order of RO, RW, BK.
1144      */
1145     for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = volp->vol[ROVOL].nextp) {
1146         if ( cellp == volp->cellp && fidp->volume == volp->vol[ROVOL].ID )
1147             break;
1148     }
1149     if (!volp) {
1150         /* try RW volumes */
1151         for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = volp->vol[RWVOL].nextp) {
1152             if ( cellp == volp->cellp && fidp->volume == volp->vol[RWVOL].ID )
1153                 break;
1154         }
1155     }
1156     if (!volp) {
1157         /* try BK volumes */
1158         for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = volp->vol[BACKVOL].nextp) {
1159             if ( cellp == volp->cellp && fidp->volume == volp->vol[BACKVOL].ID )
1160                 break;
1161         }
1162     }
1163
1164 #ifdef SEARCH_ALL_VOLUMES
1165     osi_assertx(volp == volp2, "unexpected cm_vol_t");
1166 #endif
1167     /* hold the volume if we found it */
1168     if (volp)
1169         cm_GetVolume(volp);
1170
1171     lock_ReleaseRead(&cm_volumeLock);
1172
1173     if (!volp)
1174         return CM_ERROR_NOSUCHVOLUME;
1175
1176     /* update it */
1177     cm_data.mountRootGen = time(NULL);
1178     lock_ObtainWrite(&volp->rw);
1179     _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_RESET);
1180     volp->lastUpdateTime = 0;
1181
1182     code = cm_UpdateVolumeLocation(cellp, userp, reqp, volp);
1183     lock_ReleaseWrite(&volp->rw);
1184
1185     lock_ObtainRead(&cm_volumeLock);
1186     cm_PutVolume(volp);
1187     lock_ReleaseRead(&cm_volumeLock);
1188
1189     return code;
1190 }
1191
1192 /* find the appropriate servers from a volume */
1193 cm_serverRef_t **cm_GetVolServers(cm_volume_t *volp, afs_uint32 volid, cm_user_t *userp, cm_req_t *reqp, afs_uint32 *replicated)
1194 {
1195     cm_serverRef_t **serverspp;
1196     cm_serverRef_t *current;
1197     int firstTry = 1;
1198     cm_vol_state_t *volstatep = NULL;
1199
1200   start:
1201     volstatep = cm_VolumeStateByID(volp, volid);
1202
1203     lock_ObtainWrite(&cm_serverLock);
1204     if (volstatep) {
1205         if (replicated)
1206             *replicated = (volstatep->flags & CM_VOL_STATE_FLAG_REPLICATED);
1207         serverspp = &volstatep->serversp;
1208     } else {
1209         lock_ReleaseWrite(&cm_serverLock);
1210         if (firstTry) {
1211             afs_int32 code;
1212             firstTry = 0;
1213             lock_ObtainWrite(&volp->rw);
1214             _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_RESET);
1215             volp->lastUpdateTime = 0;
1216             code = cm_UpdateVolumeLocation(volp->cellp, userp, reqp, volp);
1217             lock_ReleaseWrite(&volp->rw);
1218             if (code == 0)
1219                 goto start;
1220         }
1221         return NULL;
1222     }
1223
1224     /*
1225      * Increment the refCount on deleted items as well.
1226      * They will be freed by cm_FreeServerList when they get to zero
1227      */
1228     for (current = *serverspp; current; current = current->next)
1229         cm_GetServerRef(current, TRUE);
1230
1231     lock_ReleaseWrite(&cm_serverLock);
1232
1233     return serverspp;
1234 }
1235
1236 void cm_PutVolume(cm_volume_t *volp)
1237 {
1238     afs_int32 refCount = InterlockedDecrement(&volp->refCount);
1239     osi_assertx(refCount >= 0, "cm_volume_t refCount underflow has occurred");
1240 }
1241
1242 /* return the read-only volume, if there is one, or the read-write volume if
1243  * not.
1244  */
1245 long cm_GetROVolumeID(cm_volume_t *volp)
1246 {
1247     long id;
1248
1249     lock_ObtainRead(&volp->rw);
1250     if (volp->vol[ROVOL].ID && !cm_IsServerListEmpty(volp->vol[ROVOL].serversp))
1251         id = volp->vol[ROVOL].ID;
1252     else
1253         id = volp->vol[RWVOL].ID;
1254     lock_ReleaseRead(&volp->rw);
1255
1256     return id;
1257 }
1258
1259 void cm_RefreshVolumes(int lifetime)
1260 {
1261     cm_volume_t *volp;
1262     afs_int32 refCount;
1263     time_t now;
1264
1265     now = time(NULL);
1266
1267     /* force mount point target updates */
1268     if (cm_data.mountRootGen + lifetime <= now)
1269         cm_data.mountRootGen = now;
1270
1271     /*
1272      * force a re-loading of volume data from the vldb
1273      * if the lifetime for the cached data has expired
1274      */
1275     lock_ObtainRead(&cm_volumeLock);
1276     for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
1277         cm_GetVolume(volp);
1278         lock_ReleaseRead(&cm_volumeLock);
1279
1280         if (!(volp->flags & CM_VOLUMEFLAG_RESET) ||
1281             (volp->flags & CM_VOLUMEFLAG_NOEXIST)) {
1282             lock_ObtainWrite(&volp->rw);
1283             if (volp->flags & CM_VOLUMEFLAG_NOEXIST) {
1284                 _InterlockedAnd(&volp->flags, ~CM_VOLUMEFLAG_NOEXIST);
1285             }
1286
1287             if (volp->flags & CM_VOLUMEFLAG_RO_MIXED) {
1288                 if (volp->lastUpdateTime + 300 <= now) {
1289                     _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_RESET);
1290                     volp->lastUpdateTime = 0;
1291                 }
1292             } else {
1293                 if (volp->lastUpdateTime + lifetime <= now) {
1294                     _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_RESET);
1295                     volp->lastUpdateTime = 0;
1296                 }
1297             }
1298             lock_ReleaseWrite(&volp->rw);
1299         }
1300
1301         lock_ObtainRead(&cm_volumeLock);
1302         cm_PutVolume(volp);
1303     }
1304     lock_ReleaseRead(&cm_volumeLock);
1305 }
1306
1307 void
1308 cm_CheckOfflineVolumeState(cm_volume_t *volp, cm_vol_state_t *statep, afs_uint32 volID,
1309                            afs_uint32 *onlinep, afs_uint32 *volumeUpdatedp)
1310 {
1311     cm_conn_t *connp;
1312     long code;
1313     AFSFetchVolumeStatus volStat;
1314     char *Name;
1315     char *OfflineMsg;
1316     char *MOTD;
1317     cm_req_t req;
1318     struct rx_connection * rxconnp;
1319     char volName[32];
1320     afs_uint32 volType;
1321     char offLineMsg[256];
1322     char motd[256];
1323     long alldown, alldeleted;
1324     cm_serverRef_t *serversp;
1325     cm_fid_t vfid;
1326     cm_scache_t *vscp = NULL;
1327
1328     Name = volName;
1329     OfflineMsg = offLineMsg;
1330     MOTD = motd;
1331
1332     volType = cm_VolumeType(volp, volID);
1333
1334     if (statep->ID != 0 && (!volID || volID == statep->ID)) {
1335         /* create fid for volume root so that VNOVOL and VMOVED errors can be processed */
1336         cm_SetFid(&vfid, volp->cellp->cellID, statep->ID, 1, 1);
1337
1338         if (!statep->serversp && !(*volumeUpdatedp)) {
1339             cm_InitReq(&req);
1340             code = cm_UpdateVolumeLocation(volp->cellp, cm_rootUserp, &req, volp);
1341             *volumeUpdatedp = 1;
1342         }
1343
1344         lock_ObtainRead(&cm_serverLock);
1345         if (statep->serversp) {
1346             alldown = 1;
1347             alldeleted = 1;
1348             for (serversp = statep->serversp; serversp; serversp = serversp->next) {
1349                 if (serversp->status == srv_deleted)
1350                     continue;
1351
1352                 alldeleted = 0;
1353
1354                 if (!(serversp->server->flags & CM_SERVERFLAG_DOWN))
1355                     alldown = 0;
1356
1357                 if (serversp->status == srv_busy || serversp->status == srv_offline)
1358                     serversp->status = srv_not_busy;
1359             }
1360             lock_ReleaseRead(&cm_serverLock);
1361
1362             if (alldeleted && !(*volumeUpdatedp)) {
1363                 cm_InitReq(&req);
1364                 code = cm_UpdateVolumeLocation(volp->cellp, cm_rootUserp, &req, volp);
1365                 *volumeUpdatedp = 1;
1366             }
1367
1368             if (statep->state == vl_busy || statep->state == vl_offline || statep->state == vl_unknown ||
1369                 (!alldown && statep->state == vl_alldown)) {
1370                 cm_InitReq(&req);
1371                 req.flags |= CM_REQ_OFFLINE_VOL_CHK;
1372                 lock_ReleaseWrite(&volp->rw);
1373
1374                 code = cm_GetSCache(&vfid, NULL, &vscp, cm_rootUserp, &req);
1375                 if (code = 0) {
1376                     do {
1377                         code = cm_ConnFromVolume(volp, statep->ID, cm_rootUserp, &req, &connp);
1378                         if (code)
1379                            continue;
1380
1381                         rxconnp = cm_GetRxConn(connp);
1382                         code = RXAFS_GetVolumeStatus(rxconnp, statep->ID,
1383                                                      &volStat, &Name, &OfflineMsg, &MOTD);
1384                         rx_PutConnection(rxconnp);
1385                     } while (cm_Analyze(connp, cm_rootUserp, &req, &vfid, NULL, 0, NULL, NULL, NULL, NULL, code));
1386                     code = cm_MapRPCError(code, &req);
1387
1388                     if (code == 0 && volType == ROVOL)
1389                     {
1390                         lock_ObtainWrite(&volp->rw);
1391                         volp->volumeSizeRO = volStat.BlocksInUse * 1024;
1392                         _InterlockedOr(&volp->flags, CM_VOLUMEFLAG_RO_SIZE_VALID);
1393                         lock_ReleaseWrite(&volp->rw);
1394                     }
1395
1396                     cm_ReleaseSCache(vscp);
1397                 }
1398                 lock_ObtainWrite(&volp->rw);
1399                 if (code == 0 && volStat.Online) {
1400                     cm_VolumeStatusNotification(volp, statep->ID, statep->state, vl_online);
1401                     statep->state = vl_online;
1402                     *onlinep = 1;
1403                 } else if (code == CM_ERROR_NOACCESS) {
1404                     cm_VolumeStatusNotification(volp, statep->ID, statep->state, vl_unknown);
1405                     statep->state = vl_unknown;
1406                     *onlinep = 1;
1407                 }
1408             } else if (alldown && statep->state != vl_alldown) {
1409                 cm_VolumeStatusNotification(volp, statep->ID, statep->state, vl_alldown);
1410                 statep->state = vl_alldown;
1411             }
1412         } else {
1413             lock_ReleaseRead(&cm_serverLock);
1414             if (statep->state != vl_alldown) {
1415                 cm_VolumeStatusNotification(volp, statep->ID, statep->state, vl_alldown);
1416                 statep->state = vl_alldown;
1417             }
1418         }
1419     }
1420 }
1421
1422 /* The return code is 0 if the volume is not online and
1423  * 1 if the volume is online
1424  */
1425 long
1426 cm_CheckOfflineVolume(cm_volume_t *volp, afs_uint32 volID)
1427 {
1428     long code;
1429     cm_req_t req;
1430     afs_uint32 online = 0;
1431     afs_uint32 volumeUpdated = 0;
1432
1433     lock_ObtainWrite(&volp->rw);
1434
1435     if (volp->flags & CM_VOLUMEFLAG_RESET) {
1436         cm_InitReq(&req);
1437         code = cm_UpdateVolumeLocation(volp->cellp, cm_rootUserp, &req, volp);
1438         volumeUpdated = 1;
1439     }
1440
1441     cm_CheckOfflineVolumeState(volp, &volp->vol[RWVOL], volID, &online, &volumeUpdated);
1442     cm_CheckOfflineVolumeState(volp, &volp->vol[ROVOL], volID, &online, &volumeUpdated);
1443     cm_CheckOfflineVolumeState(volp, &volp->vol[BACKVOL], volID, &online, &volumeUpdated);
1444
1445     lock_ReleaseWrite(&volp->rw);
1446     return online;
1447 }
1448
1449
1450 /*
1451  * called from the Daemon thread.
1452  * when checking the offline status, check those of the most recently used volumes first.
1453  */
1454 void cm_CheckOfflineVolumes(void)
1455 {
1456     cm_volume_t *volp;
1457     afs_int32 refCount;
1458     extern int daemon_ShutdownFlag;
1459     extern int powerStateSuspended;
1460
1461     lock_ObtainRead(&cm_volumeLock);
1462     for (volp = cm_data.volumeLRULastp;
1463          volp && !daemon_ShutdownFlag && !powerStateSuspended;
1464          volp=(cm_volume_t *) osi_QPrev(&volp->q)) {
1465         /*
1466          * Skip volume entries that did not exist last time
1467          * the vldb was queried.  For those entries wait until
1468          * the next actual request is received for the volume
1469          * before checking its state.
1470          */
1471         if ((volp->qflags & CM_VOLUME_QFLAG_IN_HASH) &&
1472             !(volp->flags & CM_VOLUMEFLAG_NOEXIST)) {
1473             cm_GetVolume(volp);
1474             lock_ReleaseRead(&cm_volumeLock);
1475             cm_CheckOfflineVolume(volp, 0);
1476             lock_ObtainRead(&cm_volumeLock);
1477             cm_PutVolume(volp);
1478         }
1479     }
1480     lock_ReleaseRead(&cm_volumeLock);
1481 }
1482
1483
1484 static void
1485 cm_UpdateVolumeStatusInt(cm_volume_t *volp, struct cm_vol_state *statep)
1486 {
1487     enum volstatus newStatus;
1488     cm_serverRef_t *tsrp;
1489     cm_server_t *tsp;
1490     int someBusy = 0, someOffline = 0, allOffline = 1, allBusy = 1, allDown = 1;
1491     char addr[16];
1492
1493     if (!volp || !statep) {
1494 #ifdef DEBUG
1495         DebugBreak();
1496 #endif
1497         return;
1498     }
1499
1500     lock_ObtainWrite(&cm_serverLock);
1501     for (tsrp = statep->serversp; tsrp; tsrp=tsrp->next) {
1502         tsp = tsrp->server;
1503         sprintf(addr, "%d.%d.%d.%d",
1504                  ((tsp->addr.sin_addr.s_addr & 0xff)),
1505                  ((tsp->addr.sin_addr.s_addr & 0xff00)>> 8),
1506                  ((tsp->addr.sin_addr.s_addr & 0xff0000)>> 16),
1507                  ((tsp->addr.sin_addr.s_addr & 0xff000000)>> 24));
1508
1509         if (tsrp->status == srv_deleted) {
1510             osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s deleted",
1511                      statep->ID, osi_LogSaveString(afsd_logp,addr));
1512             continue;
1513         }
1514         if (tsp) {
1515             cm_GetServerNoLock(tsp);
1516             if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
1517                 allDown = 0;
1518                 if (tsrp->status == srv_busy) {
1519                     osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s busy",
1520                               statep->ID, osi_LogSaveString(afsd_logp,addr));
1521                     allOffline = 0;
1522                     someBusy = 1;
1523                 } else if (tsrp->status == srv_offline) {
1524                     osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s offline",
1525                               statep->ID, osi_LogSaveString(afsd_logp,addr));
1526                     allBusy = 0;
1527                     someOffline = 1;
1528                 } else {
1529                     osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s online",
1530                               statep->ID, osi_LogSaveString(afsd_logp,addr));
1531                     allOffline = 0;
1532                     allBusy = 0;
1533                 }
1534             } else {
1535                 osi_Log2(afsd_logp, "cm_UpdateVolumeStatusInt volume %d server reference %s down",
1536                           statep->ID, osi_LogSaveString(afsd_logp,addr));
1537             }
1538             cm_PutServerNoLock(tsp);
1539         }
1540     }
1541     lock_ReleaseWrite(&cm_serverLock);
1542
1543     osi_Log5(afsd_logp, "cm_UpdateVolumeStatusInt allDown %d allBusy %d someBusy %d someOffline %d allOffline %d",
1544              allDown, allBusy, someBusy, someOffline, allOffline);
1545
1546     if (allDown)
1547         newStatus = vl_alldown;
1548     else if (allBusy || (someBusy && someOffline))
1549         newStatus = vl_busy;
1550     else if (allOffline)
1551         newStatus = vl_offline;
1552     else
1553         newStatus = vl_online;
1554
1555     if (statep->ID && statep->state != newStatus)
1556         cm_VolumeStatusNotification(volp, statep->ID, statep->state, newStatus);
1557
1558     statep->state = newStatus;
1559 }
1560
1561 void
1562 cm_UpdateVolumeStatus(cm_volume_t *volp, afs_uint32 volID)
1563 {
1564
1565     if (volp->vol[RWVOL].ID == volID) {
1566         cm_UpdateVolumeStatusInt(volp, &volp->vol[RWVOL]);
1567     } else if (volp->vol[ROVOL].ID == volID) {
1568         cm_UpdateVolumeStatusInt(volp, &volp->vol[ROVOL]);
1569     } else if (volp->vol[BACKVOL].ID == volID) {
1570         cm_UpdateVolumeStatusInt(volp, &volp->vol[BACKVOL]);
1571     } else {
1572         /*
1573          * If we are called with volID == 0 then something has gone wrong.
1574          * Most likely a race occurred in the server volume list maintenance.
1575          * Since we don't know which volume's status should be updated,
1576          * just update all of them that are known to exist.  Better to be
1577          * correct than fast.
1578          */
1579         afs_uint32 volType;
1580         for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
1581             if (volp->vol[volType].ID != 0)
1582                 cm_UpdateVolumeStatusInt(volp, &volp->vol[volType]);
1583         }
1584     }
1585 }
1586
1587 /*
1588 ** Finds all volumes that reside on this server and reorders their
1589 ** RO list according to the changed rank of server.
1590 */
1591 void cm_ChangeRankVolume(cm_server_t *tsp)
1592 {
1593     int                 code;
1594     cm_volume_t*        volp;
1595     afs_int32 refCount;
1596
1597     /* find volumes which might have RO copy on server*/
1598     lock_ObtainRead(&cm_volumeLock);
1599     for(volp = cm_data.allVolumesp; volp; volp=volp->allNextp)
1600     {
1601         code = 1 ;      /* assume that list is unchanged */
1602         cm_GetVolume(volp);
1603         lock_ReleaseRead(&cm_volumeLock);
1604         lock_ObtainWrite(&volp->rw);
1605
1606         if ((tsp->cellp==volp->cellp) && (volp->vol[ROVOL].serversp))
1607             code =cm_ChangeRankServer(&volp->vol[ROVOL].serversp, tsp);
1608
1609         /* this volume list was changed */
1610         if ( !code )
1611             cm_RandomizeServer(&volp->vol[ROVOL].serversp);
1612
1613         lock_ReleaseWrite(&volp->rw);
1614         lock_ObtainRead(&cm_volumeLock);
1615         cm_PutVolume(volp);
1616     }
1617     lock_ReleaseRead(&cm_volumeLock);
1618 }
1619
1620 /* dump all volumes that have reference count > 0 to a file.
1621  * cookie is used to identify this batch for easy parsing,
1622  * and it a string provided by a caller
1623  */
1624 int cm_DumpVolumes(FILE *outputFile, char *cookie, int lock)
1625 {
1626     int zilch;
1627     cm_volume_t *volp;
1628     char output[1024];
1629
1630     if (lock) {
1631         lock_ObtainRead(&cm_scacheLock);
1632         lock_ObtainRead(&cm_volumeLock);
1633     }
1634
1635     sprintf(output, "%s - dumping volumes - cm_data.currentVolumes=%d, cm_data.maxVolumes=%d\r\n",
1636             cookie, cm_data.currentVolumes, cm_data.maxVolumes);
1637     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1638
1639     for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp)
1640     {
1641         time_t t;
1642         char *srvStr = NULL;
1643         afs_uint32 srvStrRpc = TRUE;
1644         char *cbt = NULL;
1645         char *cdrot = NULL;
1646
1647         if (volp->cbServerpRO) {
1648             if (!((volp->cbServerpRO->flags & CM_SERVERFLAG_UUID) &&
1649                 UuidToString((UUID *)&volp->cbServerpRO->uuid, &srvStr) == RPC_S_OK)) {
1650                 srvStr = malloc(16);
1651                 if (srvStr != NULL)
1652                     afs_inet_ntoa_r(volp->cbServerpRO->addr.sin_addr.s_addr, srvStr);
1653                 srvStrRpc = FALSE;
1654             }
1655         }
1656         if (volp->cbExpiresRO) {
1657             t = volp->cbExpiresRO;
1658             cbt = ctime(&t);
1659             if (cbt) {
1660                 cbt = strdup(cbt);
1661                 cbt[strlen(cbt)-1] = '\0';
1662             }
1663         }
1664         if (volp->creationDateRO) {
1665             t = volp->creationDateRO;
1666             cdrot = ctime(&t);
1667             if (cdrot) {
1668                 cdrot = strdup(cdrot);
1669                 cdrot[strlen(cdrot)-1] = '\0';
1670             }
1671         }
1672
1673         sprintf(output,
1674                 "%s - volp=0x%p cell=%s name=%s rwID=%u roID=%u bkID=%u flags=0x%x:%x "
1675                 "cbServerpRO='%s' cbExpiresRO='%s' creationDateRO='%s' refCount=%u\r\n",
1676                  cookie, volp, volp->cellp->name, volp->namep, volp->vol[RWVOL].ID,
1677                  volp->vol[ROVOL].ID, volp->vol[BACKVOL].ID, volp->flags, volp->qflags,
1678                  srvStr ? srvStr : "<none>", cbt ? cbt : "<none>", cdrot ? cdrot : "<none>",
1679                  volp->refCount);
1680         WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1681
1682         if (srvStr) {
1683             if (srvStrRpc)
1684                 RpcStringFree(&srvStr);
1685             else
1686                 free(srvStr);
1687         }
1688         if (cbt)
1689             free(cbt);
1690         if (cdrot)
1691             free(cdrot);
1692     }
1693     sprintf(output, "%s - Done dumping volumes.\r\n", cookie);
1694     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1695
1696     if (lock) {
1697         lock_ReleaseRead(&cm_volumeLock);
1698         lock_ReleaseRead(&cm_scacheLock);
1699     }
1700     return (0);
1701 }
1702
1703
1704 /*
1705  * String hash function used by SDBM project.
1706  * It was chosen because it is fast and provides
1707  * decent coverage.
1708  */
1709 afs_uint32 SDBMHash(const char * str)
1710 {
1711     afs_uint32 hash = 0;
1712     size_t i, len;
1713
1714     if (str == NULL)
1715         return 0;
1716
1717     for(i = 0, len = strlen(str); i < len; i++)
1718     {
1719         hash = str[i] + (hash << 6) + (hash << 16) - hash;
1720     }
1721
1722     return (hash & 0x7FFFFFFF);
1723 }
1724
1725 /* call with volume write-locked and mutex held */
1726 void cm_AddVolumeToNameHashTable(cm_volume_t *volp)
1727 {
1728     int i;
1729
1730     if (volp->qflags & CM_VOLUME_QFLAG_IN_HASH)
1731         return;
1732
1733     i = CM_VOLUME_NAME_HASH(volp->namep);
1734
1735     volp->nameNextp = cm_data.volumeNameHashTablep[i];
1736     cm_data.volumeNameHashTablep[i] = volp;
1737     _InterlockedOr(&volp->qflags, CM_VOLUME_QFLAG_IN_HASH);
1738 }
1739
1740 /* call with volume write-locked and mutex held */
1741 void cm_RemoveVolumeFromNameHashTable(cm_volume_t *volp)
1742 {
1743     cm_volume_t **lvolpp;
1744     cm_volume_t *tvolp;
1745     int i;
1746
1747     if (volp->qflags & CM_VOLUME_QFLAG_IN_HASH) {
1748         /* hash it out first */
1749         i = CM_VOLUME_NAME_HASH(volp->namep);
1750         for (lvolpp = &cm_data.volumeNameHashTablep[i], tvolp = cm_data.volumeNameHashTablep[i];
1751              tvolp;
1752              lvolpp = &tvolp->nameNextp, tvolp = tvolp->nameNextp) {
1753             if (tvolp == volp) {
1754                 *lvolpp = volp->nameNextp;
1755                 _InterlockedAnd(&volp->qflags, ~CM_VOLUME_QFLAG_IN_HASH);
1756                 volp->nameNextp = NULL;
1757                 break;
1758             }
1759         }
1760     }
1761 }
1762
1763 /* call with volume write-locked and mutex held */
1764 void cm_AddVolumeToIDHashTable(cm_volume_t *volp, afs_uint32 volType)
1765 {
1766     int i;
1767     struct cm_vol_state * statep;
1768
1769     statep = cm_VolumeStateByType(volp, volType);
1770
1771     if (statep->qflags & CM_VOLUME_QFLAG_IN_HASH)
1772         return;
1773
1774     i = CM_VOLUME_ID_HASH(statep->ID);
1775
1776     switch (volType) {
1777     case RWVOL:
1778         statep->nextp = cm_data.volumeRWIDHashTablep[i];
1779         cm_data.volumeRWIDHashTablep[i] = volp;
1780         break;
1781     case ROVOL:
1782         statep->nextp = cm_data.volumeROIDHashTablep[i];
1783         cm_data.volumeROIDHashTablep[i] = volp;
1784         break;
1785     case BACKVOL:
1786         statep->nextp = cm_data.volumeBKIDHashTablep[i];
1787         cm_data.volumeBKIDHashTablep[i] = volp;
1788         break;
1789     }
1790     _InterlockedOr(&statep->qflags, CM_VOLUME_QFLAG_IN_HASH);
1791 }
1792
1793
1794 /* call with volume write-locked and mutex held */
1795 void cm_RemoveVolumeFromIDHashTable(cm_volume_t *volp, afs_uint32 volType)
1796 {
1797     cm_volume_t **lvolpp;
1798     cm_volume_t *tvolp;
1799     struct cm_vol_state * statep;
1800     int i;
1801
1802     statep = cm_VolumeStateByType(volp, volType);
1803
1804     if (statep->qflags & CM_VOLUME_QFLAG_IN_HASH) {
1805         /* hash it out first */
1806         i = CM_VOLUME_ID_HASH(statep->ID);
1807
1808         switch (volType) {
1809         case RWVOL:
1810             lvolpp = &cm_data.volumeRWIDHashTablep[i];
1811             tvolp = cm_data.volumeRWIDHashTablep[i];
1812             break;
1813         case ROVOL:
1814             lvolpp = &cm_data.volumeROIDHashTablep[i];
1815             tvolp = cm_data.volumeROIDHashTablep[i];
1816             break;
1817         case BACKVOL:
1818             lvolpp = &cm_data.volumeBKIDHashTablep[i];
1819             tvolp = cm_data.volumeBKIDHashTablep[i];
1820             break;
1821         default:
1822             osi_assertx(0, "invalid volume type");
1823         }
1824         do {
1825             if (tvolp == volp) {
1826                 *lvolpp = statep->nextp;
1827                 _InterlockedAnd(&statep->qflags, ~CM_VOLUME_QFLAG_IN_HASH);
1828                 statep->nextp = NULL;
1829                 break;
1830             }
1831
1832             lvolpp = &tvolp->vol[volType].nextp;
1833             tvolp = tvolp->vol[volType].nextp;
1834         } while(tvolp);
1835     }
1836 }
1837
1838 /* must be called with cm_volumeLock write-locked! */
1839 void cm_AdjustVolumeLRU(cm_volume_t *volp)
1840 {
1841     lock_AssertWrite(&cm_volumeLock);
1842
1843     if (volp == cm_data.volumeLRUFirstp)
1844         return;
1845
1846     if (volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE)
1847         osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1848     osi_QAddH((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1849     _InterlockedOr(&volp->qflags, CM_VOLUME_QFLAG_IN_LRU_QUEUE);
1850
1851     osi_assertx(cm_data.volumeLRULastp != NULL, "null cm_data.volumeLRULastp");
1852 }
1853
1854 /* must be called with cm_volumeLock write-locked! */
1855 void cm_MoveVolumeToLRULast(cm_volume_t *volp)
1856 {
1857     lock_AssertWrite(&cm_volumeLock);
1858
1859     if (volp == cm_data.volumeLRULastp)
1860         return;
1861
1862     if (volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE)
1863         osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1864     osi_QAddT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1865     _InterlockedOr(&volp->qflags, CM_VOLUME_QFLAG_IN_LRU_QUEUE);
1866
1867     osi_assertx(cm_data.volumeLRULastp != NULL, "null cm_data.volumeLRULastp");
1868 }
1869
1870 /* must be called with cm_volumeLock write-locked! */
1871 void cm_RemoveVolumeFromLRU(cm_volume_t *volp)
1872 {
1873     lock_AssertWrite(&cm_volumeLock);
1874
1875     if (volp->qflags & CM_VOLUME_QFLAG_IN_LRU_QUEUE) {
1876         osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1877         _InterlockedAnd(&volp->qflags, ~CM_VOLUME_QFLAG_IN_LRU_QUEUE);
1878     }
1879
1880     osi_assertx(cm_data.volumeLRULastp != NULL, "null cm_data.volumeLRULastp");
1881 }
1882
1883 static char * volstatus_str(enum volstatus vs)
1884 {
1885     switch (vs) {
1886     case vl_online:
1887         return "online";
1888     case vl_busy:
1889         return "busy";
1890     case vl_offline:
1891         return "offline";
1892     case vl_alldown:
1893         return "alldown";
1894     default:
1895         return "unknown";
1896     }
1897 }
1898
1899 void cm_VolumeStatusNotification(cm_volume_t * volp, afs_uint32 volID, enum volstatus old, enum volstatus new)
1900 {
1901     char volstr[CELL_MAXNAMELEN + VL_MAXNAMELEN]="";
1902     char *ext = "";
1903
1904     if (volID == volp->vol[RWVOL].ID)
1905         ext = "";
1906     else if (volID == volp->vol[ROVOL].ID)
1907         ext = ".readonly";
1908     else if (volID == volp->vol[BACKVOL].ID)
1909         ext = ".backup";
1910     else
1911         ext = ".nomatch";
1912     snprintf(volstr, sizeof(volstr), "%s:%s%s", volp->cellp->name, volp->namep, ext);
1913
1914     osi_Log4(afsd_logp, "VolumeStatusNotification: %-48s [%10u] (%s -> %s)",
1915              osi_LogSaveString(afsd_logp, volstr), volID, volstatus_str(old), volstatus_str(new));
1916
1917     cm_VolStatus_Change_Notification(volp->cellp->cellID, volID, new);
1918 }
1919
1920 enum volstatus cm_GetVolumeStatus(cm_volume_t *volp, afs_uint32 volID)
1921 {
1922     cm_vol_state_t * statep = cm_VolumeStateByID(volp, volID);
1923     if (statep)
1924         return statep->state;
1925     else
1926         return vl_unknown;
1927 }
1928
1929 /* Renew .readonly volume callbacks that are more than
1930  * 30 minutes old.  (A volume callback is issued for 2 hours.)
1931  */
1932 void
1933 cm_VolumeRenewROCallbacks(void)
1934 {
1935     cm_volume_t * volp;
1936     time_t minexp = time(NULL) + 90 * 60;
1937     extern int daemon_ShutdownFlag;
1938     extern int powerStateSuspended;
1939
1940     lock_ObtainRead(&cm_volumeLock);
1941     for (volp = cm_data.allVolumesp;
1942          volp && !daemon_ShutdownFlag && !powerStateSuspended;
1943          volp=volp->allNextp) {
1944         if ( volp->cbExpiresRO > 0 && volp->cbExpiresRO < minexp) {
1945             cm_req_t      req;
1946             cm_fid_t      fid;
1947             cm_scache_t * scp;
1948
1949             cm_SetFid(&fid, volp->cellp->cellID, volp->vol[ROVOL].ID, 1, 1);
1950
1951             cm_InitReq(&req);
1952
1953             lock_ReleaseRead(&cm_volumeLock);
1954             if (cm_GetSCache(&fid, NULL, &scp, cm_rootUserp, &req) == 0) {
1955                 lock_ObtainWrite(&scp->rw);
1956                 cm_GetCallback(scp, cm_rootUserp, &req, 1);
1957                 lock_ReleaseWrite(&scp->rw);
1958                 cm_ReleaseSCache(scp);
1959             }
1960             lock_ObtainRead(&cm_volumeLock);
1961         }
1962     }
1963     lock_ReleaseRead(&cm_volumeLock);
1964 }
1965
1966 cm_vol_state_t *
1967 cm_VolumeStateByType(cm_volume_t *volp, afs_uint32 volType)
1968 {
1969     return &volp->vol[volType];
1970 }
1971
1972 cm_vol_state_t *
1973 cm_VolumeStateByID(cm_volume_t *volp, afs_uint32 id)
1974 {
1975     cm_vol_state_t * statep = NULL;
1976
1977     if (id == volp->vol[RWVOL].ID)
1978         statep = &volp->vol[RWVOL];
1979     else if (id == volp->vol[ROVOL].ID)
1980         statep = &volp->vol[ROVOL];
1981     else if (id == volp->vol[BACKVOL].ID)
1982         statep = &volp->vol[BACKVOL];
1983
1984     return(statep);
1985 }
1986
1987 cm_vol_state_t *
1988 cm_VolumeStateByName(cm_volume_t *volp, char *volname)
1989 {
1990     size_t len = strlen(volname);
1991     cm_vol_state_t *statep;
1992
1993     if (cm_stricmp_utf8N(".readonly", &volname[len-9]) == 0)
1994         statep = &volp->vol[ROVOL];
1995     else if (cm_stricmp_utf8N(".backup", &volname[len-7]) == 0)
1996         statep = &volp->vol[BACKVOL];
1997     else
1998         statep = &volp->vol[RWVOL];
1999
2000     return statep;
2001 }
2002
2003 afs_int32
2004 cm_VolumeType(cm_volume_t *volp, afs_uint32 id)
2005 {
2006     if (id == volp->vol[RWVOL].ID)
2007         return(RWVOL);
2008     else if (id == volp->vol[ROVOL].ID)
2009         return(ROVOL);
2010     else if (id == volp->vol[BACKVOL].ID)
2011         return (BACKVOL);
2012
2013     return -1;
2014 }
2015
2016 LONG_PTR
2017 cm_ChecksumVolumeServerList(struct cm_fid *fidp, cm_user_t *userp, cm_req_t *reqp)
2018 {
2019     LONG_PTR cksum = 0;
2020     long code;
2021     afs_uint32 replicated;
2022     cm_serverRef_t **serverspp;
2023
2024     code = cm_GetServerList(fidp, userp, reqp, &replicated, &serverspp);
2025     if (code == 0) {
2026         cksum = cm_ChecksumServerList(*serverspp);
2027         cm_FreeServerList(serverspp, 0);
2028     }
2029     return cksum;
2030 }
2031
2032 afs_int32
2033 cm_IsVolumeReplicated(cm_fid_t *fidp)
2034 {
2035     afs_int32 replicated = 0;
2036     cm_volume_t *volp;
2037     cm_vol_state_t * volstatep;
2038
2039     volp = cm_GetVolumeByFID(fidp);
2040     if (volp) {
2041         volstatep = cm_VolumeStateByID(volp, fidp->volume);
2042         replicated = (volstatep->flags & CM_VOL_STATE_FLAG_REPLICATED);
2043         cm_PutVolume(volp);
2044     }
2045
2046     return replicated;
2047 }