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