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