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 <afs/param.h>
  11 #include <afs/stds.h>
  12
  13 #include <windows.h>
  14 #include <winsock2.h>
  15 #include <nb30.h>
  16 #include <string.h>
  17 #include <malloc.h>
  18 #include "afsd.h"
  19 #include <osi.h>
  20 #include <rx/rx.h>
  21
  22 osi_rwlock_t cm_volumeLock;
  23
  24 long
  25 cm_ValidateVolume(void)
  26 {
  27     cm_volume_t * volp;
  28     afs_uint32 count;
  29
  30     for (volp = cm_data.allVolumesp, count = 0; volp; volp=volp->allNextp, count++) {
  31         if ( volp->magic != CM_VOLUME_MAGIC ) {
  32             afsi_log("cm_ValidateVolume failure: volp->magic != CM_VOLUME_MAGIC");
  33             fprintf(stderr, "cm_ValidateVolume failure: volp->magic != CM_VOLUME_MAGIC\n");
  34             return -1;
  35         }
  36         if ( volp->cellp && volp->cellp->magic != CM_CELL_MAGIC ) {
  37             afsi_log("cm_ValidateVolume failure: volp->cellp->magic != CM_CELL_MAGIC");
  38             fprintf(stderr, "cm_ValidateVolume failure: volp->cellp->magic != CM_CELL_MAGIC\n");
  39             return -2;
  40         }
  41         if ( volp->allNextp && volp->allNextp->magic != CM_VOLUME_MAGIC ) {
  42             afsi_log("cm_ValidateVolume failure: volp->allNextp->magic != CM_VOLUME_MAGIC");
  43             fprintf(stderr, "cm_ValidateVolume failure: volp->allNextp->magic != CM_VOLUME_MAGIC\n");
  44             return -3;
  45         }
  46         if ( count != 0 && volp == cm_data.allVolumesp ||
  47              count > cm_data.maxVolumes ) {
  48             afsi_log("cm_ValidateVolume failure: cm_data.allVolumep loop detected");
  49             fprintf(stderr, "cm_ValidateVolume failure: cm_data.allVolumep loop detected\n");
  50             return -4;
  51         }
  52     }
  53
  54     if ( count != cm_data.currentVolumes ) {
  55         afsi_log("cm_ValidateVolume failure: count != cm_data.currentVolumes");
  56         fprintf(stderr, "cm_ValidateVolume failure: count != cm_data.currentVolumes\n");
  57         return -5;
  58     }
  59
  60     return 0;
  61 }
  62
  63 long
  64 cm_ShutdownVolume(void)
  65 {
  66     cm_volume_t * volp;
  67
  68     for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
  69         afs_uint32 volType;
  70         for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
  71             if (volp->vol[volType].ID)
  72                 cm_VolumeStatusNotification(volp, volp->vol[volType].ID, volp->vol[volType].state, vl_alldown);
  73         }
  74         volp->cbExpiresRO = 0;
  75         lock_FinalizeRWLock(&volp->rw);
  76     }
  77
  78     return 0;
  79 }
  80
  81 void cm_InitVolume(int newFile, long maxVols)
  82 {
  83     static osi_once_t once;
  84
  85     if (osi_Once(&once)) {
  86         lock_InitializeRWLock(&cm_volumeLock, "cm global volume lock");
  87
  88         if ( newFile ) {
  89             cm_data.allVolumesp = NULL;
  90             cm_data.currentVolumes = 0;
  91             cm_data.maxVolumes = maxVols;
  92             memset(cm_data.volumeNameHashTablep, 0, sizeof(cm_volume_t *) * cm_data.volumeHashTableSize);
  93             memset(cm_data.volumeRWIDHashTablep, 0, sizeof(cm_volume_t *) * cm_data.volumeHashTableSize);
  94             memset(cm_data.volumeROIDHashTablep, 0, sizeof(cm_volume_t *) * cm_data.volumeHashTableSize);
  95             memset(cm_data.volumeBKIDHashTablep, 0, sizeof(cm_volume_t *) * cm_data.volumeHashTableSize);
  96             cm_data.volumeLRUFirstp = cm_data.volumeLRULastp = NULL;
  97         } else {
  98             cm_volume_t * volp;
  99
 100             for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
 101                 afs_uint32 volType;
 102
 103                 lock_InitializeRWLock(&volp->rw, "cm_volume_t rwlock");
 104                 volp->flags |= CM_VOLUMEFLAG_RESET;
 105                 for (volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
 106                     volp->vol[volType].state = vl_unknown;
 107                     volp->vol[volType].serversp = NULL;
 108                     if (volp->vol[volType].ID)
 109                         cm_VolumeStatusNotification(volp, volp->vol[volType].ID, vl_alldown, volp->vol[volType].state);
 110                 }
 111                 volp->cbExpiresRO = 0;
 112             }
 113         }
 114         osi_EndOnce(&once);
 115     }
 116 }
 117
 118
 119 /* returns true if the id is a decimal integer, in which case we interpret it
 120  * as an id.  make the cache manager much simpler.
 121  * Stolen from src/volser/vlprocs.c */
 122 int
 123 cm_VolNameIsID(char *aname)
 124 {
 125     int tc;
 126     while (tc = *aname++) {
 127         if (tc > '9' || tc < '0')
 128             return 0;
 129     }
 130     return 1;
 131 }
 132
 133
 134 /*
 135  * Update a volume.  Caller holds a write lock on the volume (volp->rw).
 136  *
 137  *
 138  *  shadow / openafs / jhutz@CS.CMU.EDU {ANDREW.CMU.EDU}  01:38    (JHutz)
 139  *    Yes, we support multihomed fileservers.
 140  *    Since before we got the code from IBM.
 141  *    But to find out about multiple addresses on a multihomed server, you need
 142  *    to use VL_GetEntryByNameU and VL_GetAddrsU.  If you use
 143  *    VL_GetEntryByNameO or VL_GetEntryByNameN, the vlserver just gives you one
 144  *    address per server.
 145  *  shadow / openafs / jhutz@CS.CMU.EDU {ANDREW.CMU.EDU}  01:39    (JHutz)
 146  *    see src/afs/afs_volume.c, paying particular attention to
 147  *    afs_NewVolumeByName, afs_SetupVolume, and InstallUVolumeEntry
 148  *  shadow / openafs / jaltman {ANDREW.CMU.EDU}  01:40    (Jeffrey Altman)
 149  *    thanks.  The windows client calls the 0 versions.
 150  *  shadow / openafs / jhutz@CS.CMU.EDU {ANDREW.CMU.EDU}  01:51    (JHutz)
 151  *    Oh.  Ew.
 152  *    By not using the N versions, you only get up to 8 sites instead of 13.
 153  *    By not using the U versions, you don't get to know about multihomed serve
 154  *  shadow / openafs / jhutz@CS.CMU.EDU {ANDREW.CMU.EDU}  01:52    (JHutz)
 155  *    Of course, you probably want to support the older versions for backward
 156  *    compatibility.  If you do that, you need to call the newest interface
 157  *    first, and fall back to successively older versions if you get
 158  *    RXGEN_OPCODE.
 159  */
 160 #define MULTIHOMED 1
 161 long cm_UpdateVolumeLocation(struct cm_cell *cellp, cm_user_t *userp, cm_req_t *reqp,
 162                      cm_volume_t *volp)
 163 {
 164     cm_conn_t *connp;
 165     int i, j, k;
 166     cm_serverRef_t *tsrp;
 167     cm_server_t *tsp;
 168     struct sockaddr_in tsockAddr;
 169     long tflags;
 170     u_long tempAddr;
 171     struct vldbentry vldbEntry;
 172     struct nvldbentry nvldbEntry;
 173 #ifdef MULTIHOMED
 174     struct uvldbentry uvldbEntry;
 175 #endif
 176     int method = -1;
 177     int ROcount = 0;
 178     long code;
 179     enum volstatus rwNewstate = vl_online;
 180     enum volstatus roNewstate = vl_online;
 181     enum volstatus bkNewstate = vl_online;
 182 #ifdef AFS_FREELANCE_CLIENT
 183     int freelance = 0;
 184 #endif
 185     afs_uint32 volType;
 186
 187     /* clear out old bindings */
 188     for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
 189         if (volp->vol[volType].serversp)
 190             cm_FreeServerList(&volp->vol[volType].serversp, CM_FREESERVERLIST_DELETE);
 191     }
 192
 193 #ifdef AFS_FREELANCE_CLIENT
 194     if ( cellp->cellID == AFS_FAKE_ROOT_CELL_ID && volp->vol[RWVOL].ID == AFS_FAKE_ROOT_VOL_ID )
 195     {
 196         freelance = 1;
 197         memset(&vldbEntry, 0, sizeof(vldbEntry));
 198         vldbEntry.flags |= VLF_RWEXISTS;
 199         vldbEntry.volumeId[0] = AFS_FAKE_ROOT_VOL_ID;
 200         code = 0;
 201         method = 0;
 202     } else
 203 #endif
 204     {
 205         while (volp->flags & CM_VOLUMEFLAG_UPDATING_VL) {
 206             osi_SleepW((LONG_PTR) &volp->flags, &volp->rw);
 207             lock_ObtainWrite(&volp->rw);
 208
 209             if (!(volp->flags & CM_VOLUMEFLAG_RESET))
 210                 return 0;
 211         }
 212
 213         volp->flags |= CM_VOLUMEFLAG_UPDATING_VL;
 214         lock_ReleaseWrite(&volp->rw);
 215
 216         if (cellp->flags & CM_CELLFLAG_VLSERVER_INVALID)
 217             cm_UpdateCell(cellp, 0);
 218
 219         /* now we have volume structure locked and held; make RPC to fill it */
 220         osi_Log2(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s", volp->cellp->name, volp->namep);
 221         do {
 222             code = cm_ConnByMServers(cellp->vlServersp, userp, reqp, &connp);
 223             if (code)
 224                 continue;
 225 #ifdef MULTIHOMED
 226             code = VL_GetEntryByNameU(connp->callp, volp->namep, &uvldbEntry);
 227             method = 2;
 228             if ( code == RXGEN_OPCODE )
 229 #endif
 230             {
 231                 code = VL_GetEntryByNameN(connp->callp, volp->namep, &nvldbEntry);
 232                 method = 1;
 233             }
 234             if ( code == RXGEN_OPCODE ) {
 235                 code = VL_GetEntryByNameO(connp->callp, volp->namep, &vldbEntry);
 236                 method = 0;
 237             }
 238         } while (cm_Analyze(connp, userp, reqp, NULL, NULL, cellp->vlServersp, NULL, code));
 239         code = cm_MapVLRPCError(code, reqp);
 240         if ( code )
 241             osi_Log3(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s FAILURE, code 0x%x",
 242                       volp->cellp->name, volp->namep, code);
 243         else
 244             osi_Log2(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s SUCCESS",
 245                       volp->cellp->name, volp->namep);
 246     }
 247
 248     /* We can end up here with code == CM_ERROR_NOSUCHVOLUME if the base volume name
 249      * does not exist but there might exist a .readonly volume.  If the base name
 250      * doesn't exist we will not care about the .backup that might be left behind
 251      * since there should be no method to access it.
 252      */
 253     if (code == CM_ERROR_NOSUCHVOLUME && volp->vol[RWVOL].ID == 0 && strlen(volp->namep) < (VL_MAXNAMELEN - 9)) {
 254         char name[VL_MAXNAMELEN];
 255
 256         snprintf(name, VL_MAXNAMELEN, "%s.readonly", volp->namep);
 257
 258         /* now we have volume structure locked and held; make RPC to fill it */
 259         osi_Log2(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s", volp->cellp->name,
 260                  osi_LogSaveString(afsd_logp,name));
 261         do {
 262             code = cm_ConnByMServers(cellp->vlServersp, userp, reqp, &connp);
 263             if (code)
 264                 continue;
 265 #ifdef MULTIHOMED
 266             code = VL_GetEntryByNameU(connp->callp, name, &uvldbEntry);
 267             method = 2;
 268             if ( code == RXGEN_OPCODE )
 269 #endif
 270             {
 271                 code = VL_GetEntryByNameN(connp->callp, name, &nvldbEntry);
 272                 method = 1;
 273             }
 274             if ( code == RXGEN_OPCODE ) {
 275                 code = VL_GetEntryByNameO(connp->callp, name, &vldbEntry);
 276                 method = 0;
 277             }
 278         } while (cm_Analyze(connp, userp, reqp, NULL, NULL, cellp->vlServersp, NULL, code));
 279         code = cm_MapVLRPCError(code, reqp);
 280         if ( code )
 281             osi_Log3(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s FAILURE, code 0x%x",
 282                       volp->cellp->name, osi_LogSaveString(afsd_logp,name), code);
 283         else
 284             osi_Log2(afsd_logp, "CALL VL_GetEntryByName{UNO} name %s:%s SUCCESS",
 285                       volp->cellp->name, osi_LogSaveString(afsd_logp,name));
 286     }
 287
 288     lock_ObtainWrite(&volp->rw);
 289     if (code == 0) {
 290         afs_int32 flags;
 291         afs_int32 nServers;
 292         afs_int32 rwID;
 293         afs_int32 roID;
 294         afs_int32 bkID;
 295         afs_int32 serverNumber[NMAXNSERVERS];
 296         afs_int32 serverFlags[NMAXNSERVERS];
 297         afs_int32 rwServers_alldown = 1;
 298         afs_int32 roServers_alldown = 1;
 299         afs_int32 bkServers_alldown = 1;
 300         char      name[VL_MAXNAMELEN];
 301
 302 #ifdef AFS_FREELANCE_CLIENT
 303         if (freelance)
 304             rwServers_alldown = 0;
 305 #endif
 306
 307         switch ( method ) {
 308         case 0:
 309             flags = vldbEntry.flags;
 310             nServers = vldbEntry.nServers;
 311             rwID = vldbEntry.volumeId[0];
 312             roID = vldbEntry.volumeId[1];
 313             bkID = vldbEntry.volumeId[2];
 314             for ( i=0; i<nServers; i++ ) {
 315                 serverFlags[i] = vldbEntry.serverFlags[i];
 316                 serverNumber[i] = vldbEntry.serverNumber[i];
 317             }
 318             strncpy(name, vldbEntry.name, VL_MAXNAMELEN);
 319             name[VL_MAXNAMELEN - 1] = '\0';
 320             break;
 321         case 1:
 322             flags = nvldbEntry.flags;
 323             nServers = nvldbEntry.nServers;
 324             rwID = nvldbEntry.volumeId[0];
 325             roID = nvldbEntry.volumeId[1];
 326             bkID = nvldbEntry.volumeId[2];
 327             for ( i=0; i<nServers; i++ ) {
 328                 serverFlags[i] = nvldbEntry.serverFlags[i];
 329                 serverNumber[i] = nvldbEntry.serverNumber[i];
 330             }
 331             strncpy(name, nvldbEntry.name, VL_MAXNAMELEN);
 332             name[VL_MAXNAMELEN - 1] = '\0';
 333             break;
 334 #ifdef MULTIHOMED
 335         case 2:
 336             flags = uvldbEntry.flags;
 337             nServers = uvldbEntry.nServers;
 338             rwID = uvldbEntry.volumeId[0];
 339             roID = uvldbEntry.volumeId[1];
 340             bkID = uvldbEntry.volumeId[2];
 341             for ( i=0, j=0; i<nServers && j<NMAXNSERVERS; i++ ) {
 342                 if ( !(uvldbEntry.serverFlags[i] & VLSERVER_FLAG_UUID) ) {
 343                     serverFlags[j] = uvldbEntry.serverFlags[i];
 344                     serverNumber[j] = uvldbEntry.serverNumber[i].time_low;
 345                     j++;
 346                 } else {
 347                     afs_uint32 * addrp, nentries, code, unique;
 348                     bulkaddrs  addrs;
 349                     ListAddrByAttributes attrs;
 350                     afsUUID uuid;
 351
 352                     memset((char *)&attrs, 0, sizeof(attrs));
 353                     attrs.Mask = VLADDR_UUID;
 354                     attrs.uuid = uvldbEntry.serverNumber[i];
 355                     memset((char *)&uuid, 0, sizeof(uuid));
 356                     memset((char *)&addrs, 0, sizeof(addrs));
 357
 358                     do {
 359                         code = cm_ConnByMServers(cellp->vlServersp, userp, reqp, &connp);
 360                         if (code)
 361                             continue;
 362
 363                         code = VL_GetAddrsU(connp->callp, &attrs, &uuid, &unique, &nentries, &addrs);
 364
 365                         if (code == 0 && nentries == 0)
 366                             code = VL_NOENT;
 367                     } while (cm_Analyze(connp, userp, reqp, NULL, NULL, cellp->vlServersp, NULL, code));
 368                     code = cm_MapVLRPCError(code, reqp);
 369                     if (code)
 370                         return code;
 371
 372                     addrp = addrs.bulkaddrs_val;
 373                     for (k = 0; k < nentries && j < NMAXNSERVERS; j++, k++) {
 374                         serverFlags[j] = uvldbEntry.serverFlags[i];
 375                         serverNumber[j] = addrp[k];
 376                     }
 377
 378                     free(addrs.bulkaddrs_val);  /* This is wrong */
 379                 }
 380             }
 381             nServers = j;                                       /* update the server count */
 382             strncpy(name, uvldbEntry.name, VL_MAXNAMELEN);
 383             name[VL_MAXNAMELEN - 1] = '\0';
 384             break;
 385 #endif
 386         }
 387
 388         /* decode the response */
 389         lock_ObtainWrite(&cm_volumeLock);
 390         if (cm_VolNameIsID(volp->namep)) {
 391             size_t    len;
 392
 393             len = strlen(name);
 394
 395             if (len >= 8 && strcmp(name + len - 7, ".backup") == 0) {
 396                 name[len - 7] = '\0';
 397             } else if (len >= 10 && strcmp(name + len - 9, ".readonly") == 0) {
 398                 name[len - 9] = '\0';
 399             }
 400
 401             osi_Log2(afsd_logp, "cm_UpdateVolume name %s -> %s", volp->namep, name);
 402
 403             if (volp->flags & CM_VOLUMEFLAG_IN_HASH)
 404                 cm_RemoveVolumeFromNameHashTable(volp);
 405
 406             strcpy(volp->namep, name);
 407
 408             cm_AddVolumeToNameHashTable(volp);
 409         }
 410
 411         if (flags & VLF_RWEXISTS) {
 412             if (volp->vol[RWVOL].ID != rwID) {
 413                 if (volp->vol[RWVOL].flags & CM_VOLUMEFLAG_IN_HASH)
 414                     cm_RemoveVolumeFromIDHashTable(volp, RWVOL);
 415                 volp->vol[RWVOL].ID = rwID;
 416                 cm_AddVolumeToIDHashTable(volp, RWVOL);
 417             }
 418         } else {
 419             if (volp->vol[RWVOL].flags & CM_VOLUMEFLAG_IN_HASH)
 420                 cm_RemoveVolumeFromIDHashTable(volp, RWVOL);
 421             volp->vol[RWVOL].ID = 0;
 422         }
 423         if (flags & VLF_ROEXISTS) {
 424             if (volp->vol[ROVOL].ID != roID) {
 425                 if (volp->vol[ROVOL].flags & CM_VOLUMEFLAG_IN_HASH)
 426                     cm_RemoveVolumeFromIDHashTable(volp, ROVOL);
 427                 volp->vol[ROVOL].ID = roID;
 428                 cm_AddVolumeToIDHashTable(volp, ROVOL);
 429             }
 430         } else {
 431             if (volp->vol[ROVOL].flags & CM_VOLUMEFLAG_IN_HASH)
 432                 cm_RemoveVolumeFromIDHashTable(volp, ROVOL);
 433             volp->vol[ROVOL].ID = 0;
 434         }
 435         if (flags & VLF_BACKEXISTS) {
 436             if (volp->vol[BACKVOL].ID != bkID) {
 437                 if (volp->vol[BACKVOL].flags & CM_VOLUMEFLAG_IN_HASH)
 438                     cm_RemoveVolumeFromIDHashTable(volp, BACKVOL);
 439                 volp->vol[BACKVOL].ID = bkID;
 440                 cm_AddVolumeToIDHashTable(volp, BACKVOL);
 441             }
 442         } else {
 443             if (volp->vol[BACKVOL].flags & CM_VOLUMEFLAG_IN_HASH)
 444                 cm_RemoveVolumeFromIDHashTable(volp, BACKVOL);
 445             volp->vol[BACKVOL].ID = 0;
 446         }
 447         lock_ReleaseWrite(&cm_volumeLock);
 448         for (i=0; i<nServers; i++) {
 449             /* create a server entry */
 450             tflags = serverFlags[i];
 451             if (tflags & VLSF_DONTUSE)
 452                 continue;
 453             tsockAddr.sin_family = AF_INET;
 454             tempAddr = htonl(serverNumber[i]);
 455             tsockAddr.sin_addr.s_addr = tempAddr;
 456             tsp = cm_FindServer(&tsockAddr, CM_SERVER_FILE);
 457             if (!tsp)
 458                 tsp = cm_NewServer(&tsockAddr, CM_SERVER_FILE,
 459                                     cellp, 0);
 460
 461             /* if this server was created by fs setserverprefs */
 462             if ( !tsp->cellp )
 463                 tsp->cellp = cellp;
 464
 465             osi_assertx(tsp != NULL, "null cm_server_t");
 466
 467             /* and add it to the list(s). */
 468             /*
 469              * Each call to cm_NewServerRef() increments the
 470              * ref count of tsp.  These reference will be dropped,
 471              * if and when the volume is reset; see reset code
 472              * earlier in this function.
 473              */
 474             if ((tflags & VLSF_RWVOL) && (flags & VLF_RWEXISTS)) {
 475                 tsrp = cm_NewServerRef(tsp, rwID);
 476                 cm_InsertServerList(&volp->vol[RWVOL].serversp, tsrp);
 477
 478                 lock_ObtainWrite(&cm_serverLock);
 479                 tsrp->refCount--;       /* drop allocation reference */
 480                 lock_ReleaseWrite(&cm_serverLock);
 481
 482                 if (!(tsp->flags & CM_SERVERFLAG_DOWN))
 483                     rwServers_alldown = 0;
 484             }
 485             if ((tflags & VLSF_ROVOL) && (flags & VLF_ROEXISTS)) {
 486                 tsrp = cm_NewServerRef(tsp, roID);
 487                 cm_InsertServerList(&volp->vol[ROVOL].serversp, tsrp);
 488                 lock_ObtainWrite(&cm_serverLock);
 489                 tsrp->refCount--;       /* drop allocation reference */
 490                 lock_ReleaseWrite(&cm_serverLock);
 491                 ROcount++;
 492
 493                 if (!(tsp->flags & CM_SERVERFLAG_DOWN))
 494                     roServers_alldown = 0;
 495             }
 496             /* We don't use VLSF_BACKVOL !?! */
 497             /* Because only the backup on the server holding the RW
 498              * volume can be valid.  This check prevents errors if a
 499              * RW is moved but the old backup is not removed.
 500              */
 501             if ((tflags & VLSF_RWVOL) && (flags & VLF_BACKEXISTS)) {
 502                 tsrp = cm_NewServerRef(tsp, bkID);
 503                 cm_InsertServerList(&volp->vol[BACKVOL].serversp, tsrp);
 504                 lock_ObtainWrite(&cm_serverLock);
 505                 tsrp->refCount--;       /* drop allocation reference */
 506                 lock_ReleaseWrite(&cm_serverLock);
 507
 508                 if (!(tsp->flags & CM_SERVERFLAG_DOWN))
 509                     bkServers_alldown = 0;
 510             }
 511             /* Drop the reference obtained by cm_FindServer() */
 512             cm_PutServer(tsp);
 513         }
 514
 515         /*
 516          * Randomize RO list
 517          *
 518          * If the first n servers have the same ipRank, then we
 519          * randomly pick one among them and move it to the beginning.
 520          * We don't bother to re-order the whole list because
 521          * the rest of the list is used only if the first server is
 522          * down.  We only do this for the RO list; we assume the other
 523          * lists are length 1.
 524          */
 525         if (ROcount > 1) {
 526             cm_RandomizeServer(&volp->vol[ROVOL].serversp);
 527         }
 528
 529         rwNewstate = rwServers_alldown ? vl_alldown : vl_online;
 530         roNewstate = roServers_alldown ? vl_alldown : vl_online;
 531         bkNewstate = bkServers_alldown ? vl_alldown : vl_online;
 532     } else if (code == CM_ERROR_NOSUCHVOLUME || code == VL_NOENT) {
 533         /* this volume does not exist - we should discard it */
 534         if (volp->flags & CM_VOLUMEFLAG_IN_HASH)
 535             cm_RemoveVolumeFromNameHashTable(volp);
 536         for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
 537             if (volp->vol[volType].flags & CM_VOLUMEFLAG_IN_HASH)
 538                 cm_RemoveVolumeFromIDHashTable(volp, volType);
 539             if (volp->vol[volType].ID) {
 540                 cm_VolumeStatusNotification(volp, volp->vol[volType].ID, volp->vol[volType].state, vl_alldown);
 541                 volp->vol[volType].ID = 0;
 542             }
 543             cm_SetFid(&volp->vol[volType].dotdotFid, 0, 0, 0, 0);
 544         }
 545
 546         /* Move to the end so it will be recycled first */
 547         cm_MoveVolumeToLRULast(volp);
 548
 549         volp->namep[0] ='\0';
 550     } else {
 551         rwNewstate = roNewstate = bkNewstate = vl_alldown;
 552     }
 553
 554     if (volp->vol[RWVOL].state != rwNewstate) {
 555         if (volp->vol[RWVOL].ID)
 556             cm_VolumeStatusNotification(volp, volp->vol[RWVOL].ID, volp->vol[RWVOL].state, rwNewstate);
 557         volp->vol[RWVOL].state = rwNewstate;
 558     }
 559     if (volp->vol[ROVOL].state != roNewstate) {
 560         if (volp->vol[ROVOL].ID)
 561             cm_VolumeStatusNotification(volp, volp->vol[ROVOL].ID, volp->vol[ROVOL].state, roNewstate);
 562         volp->vol[ROVOL].state = roNewstate;
 563     }
 564     if (volp->vol[BACKVOL].state != bkNewstate) {
 565         if (volp->vol[BACKVOL].ID)
 566             cm_VolumeStatusNotification(volp, volp->vol[BACKVOL].ID, volp->vol[BACKVOL].state, bkNewstate);
 567         volp->vol[BACKVOL].state = bkNewstate;
 568     }
 569
 570     volp->flags &= ~CM_VOLUMEFLAG_UPDATING_VL;
 571     osi_Wakeup((LONG_PTR) &volp->flags);
 572
 573     return code;
 574 }
 575
 576 /* Requires read or write lock on cm_volumeLock */
 577 void cm_GetVolume(cm_volume_t *volp)
 578 {
 579     InterlockedIncrement(&volp->refCount);
 580 }
 581
 582 cm_volume_t *cm_GetVolumeByFID(cm_fid_t *fidp)
 583 {
 584     cm_volume_t *volp;
 585     afs_uint32 hash;
 586
 587     lock_ObtainRead(&cm_volumeLock);
 588     hash = CM_VOLUME_ID_HASH(fidp->volume);
 589     /* The volumeID can be any one of the three types.  So we must
 590      * search the hash table for all three types until we find it.
 591      * We will search in the order of RO, RW, BK.
 592      */
 593     for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = volp->vol[ROVOL].nextp) {
 594         if ( fidp->cell == volp->cellp->cellID && fidp->volume == volp->vol[ROVOL].ID )
 595             break;
 596     }
 597     if (!volp) {
 598         /* try RW volumes */
 599         for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = volp->vol[RWVOL].nextp) {
 600             if ( fidp->cell == volp->cellp->cellID && fidp->volume == volp->vol[RWVOL].ID )
 601                 break;
 602         }
 603     }
 604     if (!volp) {
 605         /* try BK volumes */
 606         for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = volp->vol[BACKVOL].nextp) {
 607             if ( fidp->cell == volp->cellp->cellID && fidp->volume == volp->vol[BACKVOL].ID )
 608                 break;
 609         }
 610     }
 611
 612     /* hold the volume if we found it */
 613     if (volp)
 614         cm_GetVolume(volp);
 615
 616     lock_ReleaseRead(&cm_volumeLock);
 617     return volp;
 618 }
 619
 620 long cm_FindVolumeByID(cm_cell_t *cellp, afs_uint32 volumeID, cm_user_t *userp,
 621                       cm_req_t *reqp, afs_uint32 flags, cm_volume_t **outVolpp)
 622 {
 623     cm_volume_t *volp;
 624 #ifdef SEARCH_ALL_VOLUMES
 625     cm_volume_t *volp2;
 626 #endif
 627     char volNameString[VL_MAXNAMELEN];
 628     afs_uint32 hash;
 629     long code = 0;
 630
 631     lock_ObtainRead(&cm_volumeLock);
 632 #ifdef SEARCH_ALL_VOLUMES
 633     for(volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
 634         if (cellp == volp->cellp &&
 635              ((unsigned) volumeID == volp->vol[RWVOL].ID ||
 636                (unsigned) volumeID == volp->vol[ROVOL].ID ||
 637                (unsigned) volumeID == volp->vol[BACKVOL].ID))
 638             break;
 639     }
 640
 641     volp2 = volp;
 642 #endif /* SEARCH_ALL_VOLUMES */
 643
 644     hash = CM_VOLUME_ID_HASH(volumeID);
 645     /* The volumeID can be any one of the three types.  So we must
 646      * search the hash table for all three types until we find it.
 647      * We will search in the order of RO, RW, BK.
 648      */
 649     for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = volp->vol[ROVOL].nextp) {
 650         if ( cellp == volp->cellp && volumeID == volp->vol[ROVOL].ID )
 651             break;
 652     }
 653     if (!volp) {
 654         /* try RW volumes */
 655         for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = volp->vol[RWVOL].nextp) {
 656             if ( cellp == volp->cellp && volumeID == volp->vol[RWVOL].ID )
 657                 break;
 658         }
 659     }
 660     if (!volp) {
 661         /* try BK volumes */
 662         for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = volp->vol[BACKVOL].nextp) {
 663             if ( cellp == volp->cellp && volumeID == volp->vol[BACKVOL].ID )
 664                 break;
 665         }
 666     }
 667
 668 #ifdef SEARCH_ALL_VOLUMES
 669     osi_assertx(volp == volp2, "unexpected cm_vol_t");
 670 #endif
 671
 672     /* hold the volume if we found it */
 673     if (volp)
 674         cm_GetVolume(volp);
 675
 676     lock_ReleaseRead(&cm_volumeLock);
 677
 678     /* return it held */
 679     if (volp) {
 680         lock_ObtainWrite(&volp->rw);
 681
 682         code = 0;
 683         if ((volp->flags & CM_VOLUMEFLAG_RESET) && !(flags & CM_GETVOL_FLAG_NO_RESET)) {
 684             code = cm_UpdateVolumeLocation(cellp, userp, reqp, volp);
 685             if (code == 0)
 686                 volp->flags &= ~CM_VOLUMEFLAG_RESET;
 687         }
 688         lock_ReleaseWrite(&volp->rw);
 689         if (code == 0) {
 690             *outVolpp = volp;
 691
 692             if (!(flags & CM_GETVOL_FLAG_NO_LRU_UPDATE)) {
 693                 lock_ObtainWrite(&cm_volumeLock);
 694                 cm_AdjustVolumeLRU(volp);
 695                 lock_ReleaseWrite(&cm_volumeLock);
 696             }
 697         } else
 698             cm_PutVolume(volp);
 699
 700         return code;
 701     }
 702
 703     /* otherwise, we didn't find it so consult the VLDB */
 704     sprintf(volNameString, "%u", volumeID);
 705     code = cm_FindVolumeByName(cellp, volNameString, userp, reqp,
 706                               flags, outVolpp);
 707     return code;
 708 }
 709
 710
 711 long cm_FindVolumeByName(struct cm_cell *cellp, char *volumeNamep,
 712                         struct cm_user *userp, struct cm_req *reqp,
 713                         afs_uint32 flags, cm_volume_t **outVolpp)
 714 {
 715     cm_volume_t *volp;
 716 #ifdef SEARCH_ALL_VOLUMES
 717     cm_volume_t *volp2;
 718 #endif
 719     long        code = 0;
 720     char        name[VL_MAXNAMELEN];
 721     size_t      len;
 722     int         type;
 723     afs_uint32  hash;
 724
 725     strncpy(name, volumeNamep, VL_MAXNAMELEN);
 726     name[VL_MAXNAMELEN-1] = '\0';
 727     len = strlen(name);
 728
 729     if (len >= 8 && strcmp(name + len - 7, ".backup") == 0) {
 730         type = BACKVOL;
 731         name[len - 7] = '\0';
 732     } else if (len >= 10 && strcmp(name + len - 9, ".readonly") == 0) {
 733         type = ROVOL;
 734         name[len - 9] = '\0';
 735     } else {
 736         type = RWVOL;
 737     }
 738
 739     lock_ObtainRead(&cm_volumeLock);
 740 #ifdef SEARCH_ALL_VOLUMES
 741     for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
 742         if (cellp == volp->cellp && strcmp(name, volp->namep) == 0) {
 743             break;
 744         }
 745     }
 746     volp2 = volp;
 747 #endif /* SEARCH_ALL_VOLUMES */
 748
 749     hash = CM_VOLUME_NAME_HASH(name);
 750     for (volp = cm_data.volumeNameHashTablep[hash]; volp; volp = volp->nameNextp) {
 751         if (cellp == volp->cellp && strcmp(name, volp->namep) == 0)
 752             break;
 753     }
 754
 755 #ifdef SEARCH_ALL_VOLUMES
 756     osi_assertx(volp2 == volp, "unexpected cm_vol_t");
 757 #endif
 758
 759     if (!volp && (flags & CM_GETVOL_FLAG_CREATE)) {
 760         afs_uint32 volType;
 761         /* otherwise, get from VLDB */
 762
 763         if ( cm_data.currentVolumes >= cm_data.maxVolumes ) {
 764 #ifdef RECYCLE_FROM_ALL_VOLUMES_LIST
 765             for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
 766                 if ( volp->refCount == 0 ) {
 767                     /* There is one we can re-use */
 768                     break;
 769                 }
 770             }
 771 #else
 772             for ( volp = cm_data.volumeLRULastp;
 773                   volp;
 774                   volp = (cm_volume_t *) osi_QPrev(&volp->q))
 775             {
 776                 if ( volp->refCount == 0 ) {
 777                     /* There is one we can re-use */
 778                     break;
 779                 }
 780             }
 781 #endif
 782             if (!volp)
 783                 osi_panic("Exceeded Max Volumes", __FILE__, __LINE__);
 784
 785             lock_ReleaseRead(&cm_volumeLock);
 786             lock_ObtainWrite(&volp->rw);
 787             lock_ObtainWrite(&cm_volumeLock);
 788
 789             osi_Log2(afsd_logp, "Recycling Volume %s:%s",
 790                      volp->cellp->name, volp->namep);
 791
 792             if (volp->flags & CM_VOLUMEFLAG_IN_LRU_QUEUE)
 793                 cm_RemoveVolumeFromLRU(volp);
 794             if (volp->flags & CM_VOLUMEFLAG_IN_HASH)
 795                 cm_RemoveVolumeFromNameHashTable(volp);
 796
 797             for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
 798                 if (volp->vol[volType].flags & CM_VOLUMEFLAG_IN_HASH)
 799                     cm_RemoveVolumeFromIDHashTable(volp, volType);
 800                 if (volp->vol[volType].ID)
 801                     cm_VolumeStatusNotification(volp, volp->vol[volType].ID, volp->vol[volType].state, vl_unknown);
 802                 volp->vol[volType].ID = 0;
 803                 cm_SetFid(&volp->vol[volType].dotdotFid, 0, 0, 0, 0);
 804             }
 805         } else {
 806             volp = &cm_data.volumeBaseAddress[cm_data.currentVolumes++];
 807             memset(volp, 0, sizeof(cm_volume_t));
 808             volp->magic = CM_VOLUME_MAGIC;
 809             volp->allNextp = cm_data.allVolumesp;
 810             cm_data.allVolumesp = volp;
 811             lock_InitializeRWLock(&volp->rw, "cm_volume_t rwlock");
 812             lock_ReleaseRead(&cm_volumeLock);
 813             lock_ObtainWrite(&volp->rw);
 814             lock_ObtainWrite(&cm_volumeLock);
 815         }
 816         volp->cellp = cellp;
 817         strncpy(volp->namep, name, VL_MAXNAMELEN);
 818         volp->namep[VL_MAXNAMELEN-1] = '\0';
 819         volp->refCount = 1;     /* starts off held */
 820         volp->flags = CM_VOLUMEFLAG_RESET;
 821
 822         for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
 823             volp->vol[volType].state = vl_unknown;
 824             volp->vol[volType].nextp = NULL;
 825             volp->vol[volType].flags = 0;
 826         }
 827         volp->cbExpiresRO = 0;
 828         cm_AddVolumeToNameHashTable(volp);
 829         lock_ReleaseWrite(&cm_volumeLock);
 830     }
 831     else {
 832         if (volp)
 833             cm_GetVolume(volp);
 834         lock_ReleaseRead(&cm_volumeLock);
 835
 836         if (!volp)
 837             return CM_ERROR_NOSUCHVOLUME;
 838
 839         lock_ObtainWrite(&volp->rw);
 840     }
 841
 842     /* if we get here we are holding the mutex */
 843     if ((volp->flags & CM_VOLUMEFLAG_RESET) && !(flags & CM_GETVOL_FLAG_NO_RESET)) {
 844         code = cm_UpdateVolumeLocation(cellp, userp, reqp, volp);
 845         if (code == 0)
 846             volp->flags &= ~CM_VOLUMEFLAG_RESET;
 847     }
 848     lock_ReleaseWrite(&volp->rw);
 849
 850     if (code == 0 && (type == BACKVOL && volp->vol[BACKVOL].ID == 0 ||
 851                       type == ROVOL && volp->vol[ROVOL].ID == 0))
 852         code = CM_ERROR_NOSUCHVOLUME;
 853
 854     if (code == 0) {
 855         *outVolpp = volp;
 856
 857         if (!(flags & CM_GETVOL_FLAG_NO_LRU_UPDATE)) {
 858             lock_ObtainWrite(&cm_volumeLock);
 859             cm_AdjustVolumeLRU(volp);
 860             lock_ReleaseWrite(&cm_volumeLock);
 861         }
 862     } else
 863         cm_PutVolume(volp);
 864
 865     return code;
 866 }
 867
 868 void cm_ForceUpdateVolume(cm_fid_t *fidp, cm_user_t *userp, cm_req_t *reqp)
 869 {
 870     cm_cell_t *cellp;
 871     cm_volume_t *volp;
 872 #ifdef SEARCH_ALL_VOLUMES
 873     cm_volume_t *volp2;
 874 #endif
 875     afs_uint32  hash;
 876
 877     if (!fidp) return;
 878
 879     cellp = cm_FindCellByID(fidp->cell, 0);
 880     if (!cellp) return;
 881
 882     /* search for the volume */
 883     lock_ObtainRead(&cm_volumeLock);
 884 #ifdef SEARCH_ALL_VOLUMES
 885     for(volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
 886         if (cellp == volp->cellp &&
 887              (fidp->volume == volp->vol[RWVOL].ID ||
 888                fidp->volume == volp->vol[ROVOL].ID ||
 889                fidp->volume == volp->vol[BACKVOL].ID))
 890             break;
 891     }
 892 #endif /* SEARCH_ALL_VOLUMES */
 893
 894     hash = CM_VOLUME_ID_HASH(fidp->volume);
 895     /* The volumeID can be any one of the three types.  So we must
 896      * search the hash table for all three types until we find it.
 897      * We will search in the order of RO, RW, BK.
 898      */
 899     for ( volp = cm_data.volumeROIDHashTablep[hash]; volp; volp = volp->vol[ROVOL].nextp) {
 900         if ( cellp == volp->cellp && fidp->volume == volp->vol[ROVOL].ID )
 901             break;
 902     }
 903     if (!volp) {
 904         /* try RW volumes */
 905         for ( volp = cm_data.volumeRWIDHashTablep[hash]; volp; volp = volp->vol[RWVOL].nextp) {
 906             if ( cellp == volp->cellp && fidp->volume == volp->vol[RWVOL].ID )
 907                 break;
 908         }
 909     }
 910     if (!volp) {
 911         /* try BK volumes */
 912         for ( volp = cm_data.volumeBKIDHashTablep[hash]; volp; volp = volp->vol[BACKVOL].nextp) {
 913             if ( cellp == volp->cellp && fidp->volume == volp->vol[BACKVOL].ID )
 914                 break;
 915         }
 916     }
 917
 918 #ifdef SEARCH_ALL_VOLUMES
 919     osi_assertx(volp == volp2, "unexpected cm_vol_t");
 920 #endif
 921     /* hold the volume if we found it */
 922     if (volp)
 923         cm_GetVolume(volp);
 924
 925     lock_ReleaseRead(&cm_volumeLock);
 926
 927     /* update it */
 928     cm_data.mountRootGen = time(NULL);
 929     lock_ObtainWrite(&volp->rw);
 930     volp->flags |= CM_VOLUMEFLAG_RESET;
 931 #ifdef COMMENT
 932     /* Mark the volume to be updated but don't update it now.
 933      * This function is called only from within cm_Analyze
 934      * when cm_ConnByMServers has failed with all servers down
 935      * The problem is that cm_UpdateVolume is going to call
 936      * cm_ConnByMServers which may cause a recursive chain
 937      * of calls each returning a retry on failure.
 938      * Instead, set the flag so the next time the volume is
 939      * accessed by Name or ID the UpdateVolume call will
 940      * occur.
 941      */
 942     code = cm_UpdateVolumeLocation(cellp, userp, reqp, volp);
 943     if (code == 0)
 944         volp->flags &= ~CM_VOLUMEFLAG_RESET;
 945 #endif
 946     lock_ReleaseWrite(&volp->rw);
 947
 948     cm_PutVolume(volp);
 949 }
 950
 951 /* find the appropriate servers from a volume */
 952 cm_serverRef_t **cm_GetVolServers(cm_volume_t *volp, afs_uint32 volume)
 953 {
 954     cm_serverRef_t **serverspp;
 955     cm_serverRef_t *current;;
 956
 957     lock_ObtainWrite(&cm_serverLock);
 958
 959     if (volume == volp->vol[RWVOL].ID)
 960         serverspp = &volp->vol[RWVOL].serversp;
 961     else if (volume == volp->vol[ROVOL].ID)
 962         serverspp = &volp->vol[ROVOL].serversp;
 963     else if (volume == volp->vol[BACKVOL].ID)
 964         serverspp = &volp->vol[BACKVOL].serversp;
 965     else
 966         osi_panic("bad volume ID in cm_GetVolServers", __FILE__, __LINE__);
 967
 968     for (current = *serverspp; current; current = current->next)
 969         current->refCount++;
 970
 971     lock_ReleaseWrite(&cm_serverLock);
 972
 973     return serverspp;
 974 }
 975
 976 void cm_PutVolume(cm_volume_t *volp)
 977 {
 978     afs_int32 refCount = InterlockedDecrement(&volp->refCount);
 979     osi_assertx(refCount >= 0, "cm_volume_t refCount underflow has occurred");
 980 }
 981
 982 /* return the read-only volume, if there is one, or the read-write volume if
 983  * not.
 984  */
 985 long cm_GetROVolumeID(cm_volume_t *volp)
 986 {
 987     long id;
 988
 989     lock_ObtainRead(&volp->rw);
 990     if (volp->vol[ROVOL].ID && volp->vol[ROVOL].serversp)
 991         id = volp->vol[ROVOL].ID;
 992     else
 993         id = volp->vol[RWVOL].ID;
 994     lock_ReleaseRead(&volp->rw);
 995
 996     return id;
 997 }
 998
 999 void cm_RefreshVolumes(void)
1000 {
1001     cm_volume_t *volp;
1002     cm_scache_t *scp;
1003     afs_int32 refCount;
1004
1005     cm_data.mountRootGen = time(NULL);
1006
1007     /* force a re-loading of volume data from the vldb */
1008     lock_ObtainRead(&cm_volumeLock);
1009     for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
1010         InterlockedIncrement(&volp->refCount);
1011         lock_ReleaseRead(&cm_volumeLock);
1012
1013         lock_ObtainWrite(&volp->rw);
1014         volp->flags |= CM_VOLUMEFLAG_RESET;
1015         lock_ReleaseWrite(&volp->rw);
1016
1017         lock_ObtainRead(&cm_volumeLock);
1018         refCount = InterlockedDecrement(&volp->refCount);
1019         osi_assertx(refCount >= 0, "cm_volume_t refCount underflow");
1020     }
1021     lock_ReleaseRead(&cm_volumeLock);
1022
1023     /* force mount points to be re-evaluated so that
1024      * if the volume location has changed we will pick
1025      * that up
1026      */
1027     for ( scp = cm_data.scacheLRUFirstp;
1028           scp;
1029           scp = (cm_scache_t *) osi_QNext(&scp->q)) {
1030         if ( scp->fileType == CM_SCACHETYPE_MOUNTPOINT
1031 #ifdef AFS_FREELANCE_CLIENT
1032              && !(scp->fid.cell == AFS_FAKE_ROOT_CELL_ID && scp->fid.volume == AFS_FAKE_ROOT_VOL_ID)
1033 #endif
1034              ) {
1035             lock_ObtainWrite(&scp->rw);
1036             scp->mountPointStringp[0] = '\0';
1037             lock_ReleaseWrite(&scp->rw);
1038         }
1039     }
1040
1041 }
1042
1043
1044 /* The return code is 0 if the volume is not online and
1045  * 1 if the volume is online
1046  */
1047 long
1048 cm_CheckOfflineVolume(cm_volume_t *volp, afs_uint32 volID)
1049 {
1050     cm_conn_t *connp;
1051     long code;
1052     AFSFetchVolumeStatus volStat;
1053     char *Name;
1054     char *OfflineMsg;
1055     char *MOTD;
1056     cm_req_t req;
1057     struct rx_connection * callp;
1058     char volName[32];
1059     char offLineMsg[256];
1060     char motd[256];
1061     long online = 0;
1062     cm_serverRef_t *serversp;
1063
1064     Name = volName;
1065     OfflineMsg = offLineMsg;
1066     MOTD = motd;
1067
1068     lock_ObtainWrite(&volp->rw);
1069
1070     if (volp->flags & CM_VOLUMEFLAG_RESET) {
1071         cm_InitReq(&req);
1072         code = cm_UpdateVolumeLocation(volp->cellp, cm_rootUserp, &req, volp);
1073         if (code == 0)
1074             volp->flags &= ~CM_VOLUMEFLAG_RESET;
1075     }
1076
1077     if (volp->vol[RWVOL].ID != 0 && (!volID || volID == volp->vol[RWVOL].ID) &&
1078          volp->vol[RWVOL].serversp &&
1079          (volp->vol[RWVOL].state == vl_busy || volp->vol[RWVOL].state == vl_offline || volp->vol[RWVOL].state == vl_unknown)) {
1080         cm_InitReq(&req);
1081
1082         for (serversp = volp->vol[RWVOL].serversp; serversp; serversp = serversp->next) {
1083             if (serversp->status == srv_busy || serversp->status == srv_offline)
1084                 serversp->status = srv_not_busy;
1085         }
1086
1087         lock_ReleaseWrite(&volp->rw);
1088         do {
1089             code = cm_ConnFromVolume(volp, volp->vol[RWVOL].ID, cm_rootUserp, &req, &connp);
1090             if (code)
1091                 continue;
1092
1093             callp = cm_GetRxConn(connp);
1094             code = RXAFS_GetVolumeStatus(callp, volp->vol[RWVOL].ID,
1095                                           &volStat, &Name, &OfflineMsg, &MOTD);
1096             rx_PutConnection(callp);
1097
1098         } while (cm_Analyze(connp, cm_rootUserp, &req, NULL, NULL, NULL, NULL, code));
1099         code = cm_MapRPCError(code, &req);
1100
1101         lock_ObtainWrite(&volp->rw);
1102         if (code == 0 && volStat.Online) {
1103             cm_VolumeStatusNotification(volp, volp->vol[RWVOL].ID, volp->vol[RWVOL].state, vl_online);
1104             volp->vol[RWVOL].state = vl_online;
1105             online = 1;
1106         } else if (code == CM_ERROR_NOACCESS) {
1107             cm_VolumeStatusNotification(volp, volp->vol[RWVOL].ID, volp->vol[RWVOL].state, vl_unknown);
1108             volp->vol[RWVOL].state = vl_unknown;
1109             online = 1;
1110         }
1111     }
1112
1113     if (volp->vol[ROVOL].ID != 0 && (!volID || volID == volp->vol[ROVOL].ID) &&
1114          volp->vol[ROVOL].serversp &&
1115          (volp->vol[ROVOL].state == vl_busy || volp->vol[ROVOL].state == vl_offline || volp->vol[ROVOL].state == vl_unknown)) {
1116         cm_InitReq(&req);
1117
1118         for (serversp = volp->vol[ROVOL].serversp; serversp; serversp = serversp->next) {
1119             if (serversp->status == srv_busy || serversp->status == srv_offline)
1120                 serversp->status = srv_not_busy;
1121         }
1122
1123         lock_ReleaseWrite(&volp->rw);
1124         do {
1125             code = cm_ConnFromVolume(volp, volp->vol[ROVOL].ID, cm_rootUserp, &req, &connp);
1126             if (code)
1127                 continue;
1128
1129             callp = cm_GetRxConn(connp);
1130             code = RXAFS_GetVolumeStatus(callp, volp->vol[ROVOL].ID,
1131                                           &volStat, &Name, &OfflineMsg, &MOTD);
1132             rx_PutConnection(callp);
1133
1134         } while (cm_Analyze(connp, cm_rootUserp, &req, NULL, NULL, NULL, NULL, code));
1135         code = cm_MapRPCError(code, &req);
1136
1137         lock_ObtainWrite(&volp->rw);
1138         if (code == 0 && volStat.Online) {
1139             cm_VolumeStatusNotification(volp, volp->vol[ROVOL].ID, volp->vol[ROVOL].state, vl_online);
1140             volp->vol[ROVOL].state = vl_online;
1141             online = 1;
1142         } else if (code == CM_ERROR_NOACCESS) {
1143             cm_VolumeStatusNotification(volp, volp->vol[ROVOL].ID, volp->vol[ROVOL].state, vl_unknown);
1144             volp->vol[ROVOL].state = vl_unknown;
1145             online = 1;
1146         }
1147     }
1148
1149     if (volp->vol[BACKVOL].ID != 0 && (!volID || volID == volp->vol[BACKVOL].ID) &&
1150          volp->vol[BACKVOL].serversp &&
1151          (volp->vol[BACKVOL].state == vl_busy || volp->vol[BACKVOL].state == vl_offline || volp->vol[BACKVOL].state == vl_unknown)) {
1152         cm_InitReq(&req);
1153
1154         for (serversp = volp->vol[BACKVOL].serversp; serversp; serversp = serversp->next) {
1155             if (serversp->status == srv_busy || serversp->status == srv_offline)
1156                 serversp->status = srv_not_busy;
1157         }
1158
1159         lock_ReleaseWrite(&volp->rw);
1160         do {
1161             code = cm_ConnFromVolume(volp, volp->vol[BACKVOL].ID, cm_rootUserp, &req, &connp);
1162             if (code)
1163                 continue;
1164
1165             callp = cm_GetRxConn(connp);
1166             code = RXAFS_GetVolumeStatus(callp, volp->vol[BACKVOL].ID,
1167                                           &volStat, &Name, &OfflineMsg, &MOTD);
1168             rx_PutConnection(callp);
1169
1170         } while (cm_Analyze(connp, cm_rootUserp, &req, NULL, NULL, NULL, NULL, code));
1171         code = cm_MapRPCError(code, &req);
1172
1173         lock_ObtainWrite(&volp->rw);
1174         if (code == 0 && volStat.Online) {
1175             cm_VolumeStatusNotification(volp, volp->vol[BACKVOL].ID, volp->vol[BACKVOL].state, vl_online);
1176             volp->vol[BACKVOL].state = vl_online;
1177             online = 1;
1178         } else if (code == CM_ERROR_NOACCESS) {
1179             cm_VolumeStatusNotification(volp, volp->vol[BACKVOL].ID, volp->vol[BACKVOL].state, vl_unknown);
1180             volp->vol[BACKVOL].state = vl_unknown;
1181             online = 1;
1182         }
1183     }
1184
1185     lock_ReleaseWrite(&volp->rw);
1186     return online;
1187 }
1188
1189
1190 /* called from the Daemon thread */
1191 void cm_CheckOfflineVolumes(void)
1192 {
1193     cm_volume_t *volp;
1194     afs_int32 refCount;
1195
1196     lock_ObtainRead(&cm_volumeLock);
1197     for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
1198         if (volp->flags & CM_VOLUMEFLAG_IN_HASH) {
1199             InterlockedIncrement(&volp->refCount);
1200             lock_ReleaseRead(&cm_volumeLock);
1201             cm_CheckOfflineVolume(volp, 0);
1202             lock_ObtainRead(&cm_volumeLock);
1203             refCount = InterlockedDecrement(&volp->refCount);
1204             osi_assertx(refCount >= 0, "cm_volume_t refCount underflow");
1205         }
1206     }
1207     lock_ReleaseRead(&cm_volumeLock);
1208 }
1209
1210
1211 static void
1212 cm_UpdateVolumeStatusInt(cm_volume_t *volp, struct cm_vol_state *statep)
1213 {
1214     enum volstatus newStatus;
1215     cm_serverRef_t *tsrp;
1216     cm_server_t *tsp;
1217     int someBusy = 0, someOffline = 0, allOffline = 1, allBusy = 1, allDown = 1;
1218
1219     if (!volp || !statep) {
1220 #ifdef DEBUG
1221         DebugBreak();
1222 #endif
1223         return;
1224     }
1225
1226     lock_ObtainWrite(&cm_serverLock);
1227     for (tsrp = statep->serversp; tsrp; tsrp=tsrp->next) {
1228         tsp = tsrp->server;
1229         cm_GetServerNoLock(tsp);
1230         if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
1231             allDown = 0;
1232             if (tsrp->status == srv_busy) {
1233                 allOffline = 0;
1234                 someBusy = 1;
1235             } else if (tsrp->status == srv_offline) {
1236                 allBusy = 0;
1237                 someOffline = 1;
1238             } else {
1239                 allOffline = 0;
1240                 allBusy = 0;
1241             }
1242         }
1243         cm_PutServerNoLock(tsp);
1244     }
1245     lock_ReleaseWrite(&cm_serverLock);
1246
1247     if (allDown)
1248         newStatus = vl_alldown;
1249     else if (allBusy || (someBusy && someOffline))
1250         newStatus = vl_busy;
1251     else if (allOffline)
1252         newStatus = vl_offline;
1253     else
1254         newStatus = vl_online;
1255
1256     if (statep->ID && statep->state != newStatus)
1257         cm_VolumeStatusNotification(volp, statep->ID, statep->state, newStatus);
1258
1259     statep->state = newStatus;
1260 }
1261
1262 void
1263 cm_UpdateVolumeStatus(cm_volume_t *volp, afs_uint32 volID)
1264 {
1265
1266     if (volp->vol[RWVOL].ID == volID) {
1267         cm_UpdateVolumeStatusInt(volp, &volp->vol[RWVOL]);
1268     } else if (volp->vol[ROVOL].ID == volID) {
1269         cm_UpdateVolumeStatusInt(volp, &volp->vol[ROVOL]);
1270     } else if (volp->vol[BACKVOL].ID == volID) {
1271         cm_UpdateVolumeStatusInt(volp, &volp->vol[BACKVOL]);
1272     } else {
1273         /*
1274          * If we are called with volID == 0 then something has gone wrong.
1275          * Most likely a race occurred in the server volume list maintenance.
1276          * Since we don't know which volume's status should be updated,
1277          * just update all of them that are known to exist.  Better to be
1278          * correct than fast.
1279          */
1280         afs_uint32 volType;
1281         for ( volType = RWVOL; volType < NUM_VOL_TYPES; volType++) {
1282             if (volp->vol[volType].ID != 0)
1283                 cm_UpdateVolumeStatusInt(volp, &volp->vol[volType]);
1284         }
1285     }
1286 }
1287
1288 /*
1289 ** Finds all volumes that reside on this server and reorders their
1290 ** RO list according to the changed rank of server.
1291 */
1292 void cm_ChangeRankVolume(cm_server_t *tsp)
1293 {
1294     int                 code;
1295     cm_volume_t*        volp;
1296     afs_int32 refCount;
1297
1298     /* find volumes which might have RO copy on server*/
1299     lock_ObtainRead(&cm_volumeLock);
1300     for(volp = cm_data.allVolumesp; volp; volp=volp->allNextp)
1301     {
1302         code = 1 ;      /* assume that list is unchanged */
1303         InterlockedIncrement(&volp->refCount);
1304         lock_ReleaseRead(&cm_volumeLock);
1305         lock_ObtainWrite(&volp->rw);
1306
1307         if ((tsp->cellp==volp->cellp) && (volp->vol[ROVOL].serversp))
1308             code =cm_ChangeRankServer(&volp->vol[ROVOL].serversp, tsp);
1309
1310         /* this volume list was changed */
1311         if ( !code )
1312             cm_RandomizeServer(&volp->vol[ROVOL].serversp);
1313
1314         lock_ReleaseWrite(&volp->rw);
1315         lock_ObtainRead(&cm_volumeLock);
1316         refCount = InterlockedDecrement(&volp->refCount);
1317         osi_assertx(refCount >= 0, "cm_volume_t refCount underflow");
1318     }
1319     lock_ReleaseRead(&cm_volumeLock);
1320 }
1321
1322 /* dump all volumes that have reference count > 0 to a file.
1323  * cookie is used to identify this batch for easy parsing,
1324  * and it a string provided by a caller
1325  */
1326 int cm_DumpVolumes(FILE *outputFile, char *cookie, int lock)
1327 {
1328     int zilch;
1329     cm_volume_t *volp;
1330     char output[1024];
1331
1332     if (lock) {
1333         lock_ObtainRead(&cm_scacheLock);
1334         lock_ObtainRead(&cm_volumeLock);
1335     }
1336
1337     sprintf(output, "%s - dumping volumes - cm_data.currentVolumes=%d, cm_data.maxVolumes=%d\r\n", cookie, cm_data.currentVolumes, cm_data.maxVolumes);
1338     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1339
1340     for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp)
1341     {
1342         sprintf(output, "%s - volp=0x%p cell=%s name=%s rwID=%u roID=%u bkID=%u flags=0x%x refCount=%u\r\n",
1343                  cookie, volp, volp->cellp->name, volp->namep, volp->vol[RWVOL].ID, volp->vol[ROVOL].ID, volp->vol[BACKVOL].ID, volp->flags,
1344                  volp->refCount);
1345         WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1346     }
1347     sprintf(output, "%s - Done dumping volumes.\r\n", cookie);
1348     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1349
1350     if (lock) {
1351         lock_ReleaseRead(&cm_volumeLock);
1352         lock_ReleaseRead(&cm_scacheLock);
1353     }
1354     return (0);
1355 }
1356
1357
1358 /*
1359  * String hash function used by SDBM project.
1360  * It was chosen because it is fast and provides
1361  * decent coverage.
1362  */
1363 afs_uint32 SDBMHash(const char * str)
1364 {
1365     afs_uint32 hash = 0;
1366     size_t i, len;
1367
1368     if (str == NULL)
1369         return 0;
1370
1371     for(i = 0, len = strlen(str); i < len; i++)
1372     {
1373         hash = str[i] + (hash << 6) + (hash << 16) - hash;
1374     }
1375
1376     return (hash & 0x7FFFFFFF);
1377 }
1378
1379 /* call with volume write-locked and mutex held */
1380 void cm_AddVolumeToNameHashTable(cm_volume_t *volp)
1381 {
1382     int i;
1383
1384     if (volp->flags & CM_VOLUMEFLAG_IN_HASH)
1385         return;
1386
1387     i = CM_VOLUME_NAME_HASH(volp->namep);
1388
1389     volp->nameNextp = cm_data.volumeNameHashTablep[i];
1390     cm_data.volumeNameHashTablep[i] = volp;
1391     volp->flags |= CM_VOLUMEFLAG_IN_HASH;
1392 }
1393
1394 /* call with volume write-locked and mutex held */
1395 void cm_RemoveVolumeFromNameHashTable(cm_volume_t *volp)
1396 {
1397     cm_volume_t **lvolpp;
1398     cm_volume_t *tvolp;
1399     int i;
1400
1401     if (volp->flags & CM_VOLUMEFLAG_IN_HASH) {
1402         /* hash it out first */
1403         i = CM_VOLUME_NAME_HASH(volp->namep);
1404         for (lvolpp = &cm_data.volumeNameHashTablep[i], tvolp = cm_data.volumeNameHashTablep[i];
1405              tvolp;
1406              lvolpp = &tvolp->nameNextp, tvolp = tvolp->nameNextp) {
1407             if (tvolp == volp) {
1408                 *lvolpp = volp->nameNextp;
1409                 volp->flags &= ~CM_VOLUMEFLAG_IN_HASH;
1410                 volp->nameNextp = NULL;
1411                 break;
1412             }
1413         }
1414     }
1415 }
1416
1417 /* call with volume write-locked and mutex held */
1418 void cm_AddVolumeToIDHashTable(cm_volume_t *volp, afs_uint32 volType)
1419 {
1420     int i;
1421     struct cm_vol_state * statep;
1422
1423     statep = cm_VolumeStateByType(volp, volType);
1424
1425     if (statep->flags & CM_VOLUMEFLAG_IN_HASH)
1426         return;
1427
1428     i = CM_VOLUME_ID_HASH(statep->ID);
1429
1430     switch (volType) {
1431     case RWVOL:
1432         statep->nextp = cm_data.volumeRWIDHashTablep[i];
1433         cm_data.volumeRWIDHashTablep[i] = volp;
1434         break;
1435     case ROVOL:
1436         statep->nextp = cm_data.volumeROIDHashTablep[i];
1437         cm_data.volumeROIDHashTablep[i] = volp;
1438         break;
1439     case BACKVOL:
1440         statep->nextp = cm_data.volumeBKIDHashTablep[i];
1441         cm_data.volumeBKIDHashTablep[i] = volp;
1442         break;
1443     }
1444     statep->flags |= CM_VOLUMEFLAG_IN_HASH;
1445 }
1446
1447
1448 /* call with volume write-locked and mutex held */
1449 void cm_RemoveVolumeFromIDHashTable(cm_volume_t *volp, afs_uint32 volType)
1450 {
1451     cm_volume_t **lvolpp;
1452     cm_volume_t *tvolp;
1453     struct cm_vol_state * statep;
1454     int i;
1455
1456     statep = cm_VolumeStateByType(volp, volType);
1457
1458     if (statep->flags & CM_VOLUMEFLAG_IN_HASH) {
1459         /* hash it out first */
1460         i = CM_VOLUME_ID_HASH(statep->ID);
1461
1462         switch (volType) {
1463         case RWVOL:
1464             lvolpp = &cm_data.volumeRWIDHashTablep[i];
1465             tvolp = cm_data.volumeRWIDHashTablep[i];
1466             break;
1467         case ROVOL:
1468             lvolpp = &cm_data.volumeROIDHashTablep[i];
1469             tvolp = cm_data.volumeROIDHashTablep[i];
1470             break;
1471         case BACKVOL:
1472             lvolpp = &cm_data.volumeBKIDHashTablep[i];
1473             tvolp = cm_data.volumeBKIDHashTablep[i];
1474             break;
1475         default:
1476             osi_assertx(0, "invalid volume type");
1477         }
1478         do {
1479             if (tvolp == volp) {
1480                 *lvolpp = statep->nextp;
1481                 statep->flags &= ~CM_VOLUMEFLAG_IN_HASH;
1482                 statep->nextp = NULL;
1483                 break;
1484             }
1485
1486             lvolpp = &tvolp->vol[volType].nextp;
1487             tvolp = tvolp->vol[volType].nextp;
1488         } while(tvolp);
1489     }
1490 }
1491
1492 /* must be called with cm_volumeLock write-locked! */
1493 void cm_AdjustVolumeLRU(cm_volume_t *volp)
1494 {
1495     if (volp == cm_data.volumeLRULastp)
1496         cm_data.volumeLRULastp = (cm_volume_t *) osi_QPrev(&volp->q);
1497     if (volp->flags & CM_VOLUMEFLAG_IN_LRU_QUEUE)
1498         osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1499     osi_QAdd((osi_queue_t **) &cm_data.volumeLRUFirstp, &volp->q);
1500     volp->flags |= CM_VOLUMEFLAG_IN_LRU_QUEUE;
1501     if (!cm_data.volumeLRULastp)
1502         cm_data.volumeLRULastp = volp;
1503 }
1504
1505 /* must be called with cm_volumeLock write-locked! */
1506 void cm_MoveVolumeToLRULast(cm_volume_t *volp)
1507 {
1508     if (volp == cm_data.volumeLRULastp)
1509         return;
1510
1511     if (volp == cm_data.volumeLRUFirstp)
1512         cm_data.volumeLRUFirstp = (cm_volume_t *) osi_QNext(&volp->q);
1513     if (volp->flags & CM_VOLUMEFLAG_IN_LRU_QUEUE)
1514         osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1515     osi_QAddT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1516     volp->flags |= CM_VOLUMEFLAG_IN_LRU_QUEUE;
1517     if (!cm_data.volumeLRULastp)
1518         cm_data.volumeLRULastp = volp;
1519 }
1520
1521 /* must be called with cm_volumeLock write-locked! */
1522 void cm_RemoveVolumeFromLRU(cm_volume_t *volp)
1523 {
1524     if (volp->flags & CM_VOLUMEFLAG_IN_LRU_QUEUE) {
1525         if (volp == cm_data.volumeLRULastp)
1526             cm_data.volumeLRULastp = (cm_volume_t *) osi_QPrev(&volp->q);
1527         osi_QRemoveHT((osi_queue_t **) &cm_data.volumeLRUFirstp, (osi_queue_t **) &cm_data.volumeLRULastp, &volp->q);
1528         volp->flags &= ~CM_VOLUMEFLAG_IN_LRU_QUEUE;
1529     }
1530 }
1531
1532 static char * volstatus_str(enum volstatus vs)
1533 {
1534     switch (vs) {
1535     case vl_online:
1536         return "online";
1537     case vl_busy:
1538         return "busy";
1539     case vl_offline:
1540         return "offline";
1541     case vl_alldown:
1542         return "alldown";
1543     default:
1544         return "unknown";
1545     }
1546 }
1547
1548 void cm_VolumeStatusNotification(cm_volume_t * volp, afs_uint32 volID, enum volstatus old, enum volstatus new)
1549 {
1550     char volstr[CELL_MAXNAMELEN + VL_MAXNAMELEN]="";
1551     char *ext = "";
1552
1553     if (volID == volp->vol[RWVOL].ID)
1554         ext = "";
1555     else if (volID == volp->vol[ROVOL].ID)
1556         ext = ".readonly";
1557     else if (volID == volp->vol[BACKVOL].ID)
1558         ext = ".backup";
1559     else
1560         ext = ".nomatch";
1561     snprintf(volstr, sizeof(volstr), "%s:%s%s", volp->cellp->name, volp->namep, ext);
1562
1563     osi_Log4(afsd_logp, "VolumeStatusNotification: %-48s [%10u] (%s -> %s)",
1564              osi_LogSaveString(afsd_logp, volstr), volID, volstatus_str(old), volstatus_str(new));
1565
1566     cm_VolStatus_Change_Notification(volp->cellp->cellID, volID, new);
1567 }
1568
1569 enum volstatus cm_GetVolumeStatus(cm_volume_t *volp, afs_uint32 volID)
1570 {
1571     cm_vol_state_t * statep = cm_VolumeStateByID(volp, volID);
1572     if (statep)
1573         return statep->state;
1574     else
1575         return vl_unknown;
1576 }
1577
1578 /* Renew .readonly volume callbacks that are more than
1579  * 30 minutes old.  (A volume callback is issued for 2 hours.)
1580  */
1581 void
1582 cm_VolumeRenewROCallbacks(void)
1583 {
1584     cm_volume_t * volp;
1585     time_t minexp = time(NULL) + 90 * 60;
1586
1587     lock_ObtainRead(&cm_volumeLock);
1588     for (volp = cm_data.allVolumesp; volp; volp=volp->allNextp) {
1589         if ( volp->cbExpiresRO > 0 && volp->cbExpiresRO < minexp) {
1590             cm_req_t      req;
1591             cm_fid_t      fid;
1592             cm_scache_t * scp;
1593
1594             cm_SetFid(&fid, volp->cellp->cellID, volp->vol[ROVOL].ID, 1, 1);
1595
1596             cm_InitReq(&req);
1597
1598             lock_ReleaseRead(&cm_volumeLock);
1599             if (cm_GetSCache(&fid, &scp, cm_rootUserp, &req) == 0) {
1600                 lock_ObtainWrite(&scp->rw);
1601                 cm_GetCallback(scp, cm_rootUserp, &req, 1);
1602                 lock_ReleaseWrite(&scp->rw);
1603                 cm_ReleaseSCache(scp);
1604             }
1605             lock_ObtainRead(&cm_volumeLock);
1606         }
1607     }
1608     lock_ReleaseRead(&cm_volumeLock);
1609 }
1610
1611 cm_vol_state_t *
1612 cm_VolumeStateByType(cm_volume_t *volp, afs_uint32 volType)
1613 {
1614     return &volp->vol[volType];
1615 }
1616
1617 cm_vol_state_t *
1618 cm_VolumeStateByID(cm_volume_t *volp, afs_uint32 id)
1619 {
1620     cm_vol_state_t * statep = NULL;
1621
1622     if (id == volp->vol[RWVOL].ID)
1623         statep = &volp->vol[RWVOL];
1624     else if (id == volp->vol[ROVOL].ID)
1625         statep = &volp->vol[ROVOL];
1626     else if (id == volp->vol[BACKVOL].ID)
1627         statep = &volp->vol[BACKVOL];
1628
1629     return(statep);
1630 }
1631
1632 cm_vol_state_t *
1633 cm_VolumeStateByName(cm_volume_t *volp, char *volname)
1634 {
1635     size_t len = strlen(volname);
1636     cm_vol_state_t *statep;
1637
1638     if (stricmp(".readonly", &volname[len-9]) == 0)
1639         statep = &volp->vol[ROVOL];
1640     else if (stricmp(".backup", &volname[len-7]) == 0)
1641         statep = &volp->vol[BACKVOL];
1642     else
1643         statep = &volp->vol[RWVOL];
1644
1645     return statep;
1646 }
1647