src/WINNT/afsd/cm_server.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afsconfig.h>
  11 #include <afs/param.h>
  12 #include <roken.h>
  13
  14 #include <afs/stds.h>
  15
  16 #include <windows.h>
  17 #include <winsock2.h>
  18 #include <nb30.h>
  19 #include <stdlib.h>
  20 #include <malloc.h>
  21 #include <string.h>
  22
  23 #include "afsd.h"
  24 #include <WINNT\syscfg.h>
  25 #include <WINNT/afsreg.h>
  26 #include <osi.h>
  27 #include <rx/rx.h>
  28 #include <math.h>
  29
  30 osi_rwlock_t cm_serverLock;
  31 osi_rwlock_t cm_syscfgLock;
  32
  33 cm_server_t *cm_allServersp;
  34 afs_uint32   cm_numFileServers = 0;
  35 afs_uint32   cm_numVldbServers = 0;
  36
  37 void
  38 cm_ForceNewConnectionsAllServers(void)
  39 {
  40     cm_server_t *tsp;
  41
  42     lock_ObtainRead(&cm_serverLock);
  43     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
  44         cm_GetServerNoLock(tsp);
  45         lock_ReleaseRead(&cm_serverLock);
  46         cm_ForceNewConnections(tsp);
  47         lock_ObtainRead(&cm_serverLock);
  48         cm_PutServerNoLock(tsp);
  49     }
  50     lock_ReleaseRead(&cm_serverLock);
  51 }
  52
  53 /*
  54  * lock_ObtainMutex must be held prior to calling
  55  * this function.
  56  */
  57 afs_int32
  58 cm_RankServer(cm_server_t * tsp)
  59 {
  60     afs_int32 code = 0; /* start with "success" */
  61     struct rx_debugPeer tpeer;
  62     afs_uint16 port;
  63     afs_uint16 newRank;
  64
  65     switch(tsp->type) {
  66         case CM_SERVER_VLDB:
  67             port = htons(7003);
  68             break;
  69         case CM_SERVER_FILE:
  70             port = htons(7000);
  71             break;
  72         default:
  73             return -1;
  74     }
  75
  76     code = rx_GetLocalPeers(tsp->addr.sin_addr.s_addr, port, &tpeer);
  77
  78     /*check if rx_GetLocalPeers succeeded and if there is data for tsp */
  79     if(code == 0 && (tpeer.rtt == 0 && tpeer.rtt_dev == 0))
  80         code = -1;
  81
  82     if(code == 0) {
  83         if((tsp->flags & CM_SERVERFLAG_PREF_SET))
  84             newRank = tsp->adminRank +
  85                 ((int)(623 * log(tpeer.rtt) / 10) * 10 + 5);
  86         else /* rank has not been set by admin, derive rank from rtt */
  87             newRank = (int)(7200 * log(tpeer.rtt) / 5000) * 5000 + 5000;
  88
  89         newRank += (rand() & 0x000f); /* randomize */
  90
  91         if (abs(newRank - tsp->ipRank) > 0xf) {
  92             tsp->ipRank = newRank;
  93
  94             lock_ReleaseMutex(&tsp->mx);
  95             switch (tsp->type) {
  96             case CM_SERVER_FILE:
  97                 /*
  98                  * find volumes which might have RO copy
  99                  * on server and change the ordering of
 100                  * their RO list
 101                  */
 102                 cm_ChangeRankVolume(tsp);
 103                 break;
 104             case CM_SERVER_VLDB:
 105                 /* set preferences for an existing vlserver */
 106                 cm_ChangeRankCellVLServer(tsp);
 107                 break;
 108             }
 109             lock_ObtainMutex(&tsp->mx);
 110         }
 111     }
 112
 113     return code;
 114 }
 115
 116 void
 117 cm_PingServer(cm_server_t *tsp)
 118 {
 119     long code;
 120     int wasDown = 0;
 121     cm_conn_t *connp;
 122     struct rx_connection * rxconnp;
 123     Capabilities caps = {0, 0};
 124     char hoststr[16];
 125     cm_req_t req;
 126
 127     lock_ObtainMutex(&tsp->mx);
 128     if (tsp->flags & CM_SERVERFLAG_PINGING) {
 129         tsp->waitCount++;
 130         osi_SleepM((LONG_PTR)tsp, &tsp->mx);
 131         lock_ObtainMutex(&tsp->mx);
 132         tsp->waitCount--;
 133         if (tsp->waitCount == 0)
 134             _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_PINGING);
 135         else
 136             osi_Wakeup((LONG_PTR)tsp);
 137         lock_ReleaseMutex(&tsp->mx);
 138         return;
 139     }
 140     _InterlockedOr(&tsp->flags, CM_SERVERFLAG_PINGING);
 141     wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
 142     afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
 143     lock_ReleaseMutex(&tsp->mx);
 144
 145     code = cm_ConnByServer(tsp, cm_rootUserp, &connp);
 146     if (code == 0) {
 147         /* now call the appropriate ping call.  Drop the timeout if
 148         * the server is known to be down, so that we don't waste a
 149         * lot of time retiming out down servers.
 150         */
 151
 152         osi_Log4(afsd_logp, "cm_PingServer server %s (%s) was %s with caps 0x%x",
 153                   osi_LogSaveString(afsd_logp, hoststr),
 154                   tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 155                   wasDown ? "down" : "up",
 156                   tsp->capabilities);
 157
 158         rxconnp = cm_GetRxConn(connp);
 159         if (wasDown)
 160             rx_SetConnDeadTime(rxconnp, 10);
 161         if (tsp->type == CM_SERVER_VLDB) {
 162             code = VL_ProbeServer(rxconnp);
 163         }
 164         else {
 165             /* file server */
 166             code = RXAFS_GetCapabilities(rxconnp, &caps);
 167         }
 168         if (wasDown)
 169             rx_SetConnDeadTime(rxconnp, ConnDeadtimeout);
 170         rx_PutConnection(rxconnp);
 171         cm_PutConn(connp);
 172     }   /* got an unauthenticated connection to this server */
 173
 174     lock_ObtainMutex(&tsp->mx);
 175     if (code >= 0 || code == RXGEN_OPCODE) {
 176         /* mark server as up */
 177         _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_DOWN);
 178         tsp->downTime = 0;
 179
 180         /* we currently handle 32-bits of capabilities */
 181         if (code != RXGEN_OPCODE && caps.Capabilities_len > 0) {
 182             tsp->capabilities = caps.Capabilities_val[0];
 183             xdr_free((xdrproc_t) xdr_Capabilities, &caps);
 184             caps.Capabilities_len = 0;
 185             caps.Capabilities_val = 0;
 186         } else {
 187             tsp->capabilities = 0;
 188         }
 189
 190         osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is up with caps 0x%x",
 191                   osi_LogSaveString(afsd_logp, hoststr),
 192                   tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 193                   tsp->capabilities);
 194
 195         /* Now update the volume status if necessary */
 196         if (wasDown) {
 197             cm_server_vols_t * tsrvp;
 198             cm_volume_t * volp;
 199             int i;
 200
 201             for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
 202                 for (i=0; i<NUM_SERVER_VOLS; i++) {
 203                     if (tsrvp->ids[i] != 0) {
 204                         cm_InitReq(&req);
 205
 206                         lock_ReleaseMutex(&tsp->mx);
 207                         code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
 208                                                 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
 209                         lock_ObtainMutex(&tsp->mx);
 210                         if (code == 0) {
 211                             cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
 212                             cm_PutVolume(volp);
 213                         }
 214                     }
 215                 }
 216             }
 217         }
 218     } else {
 219         /* mark server as down */
 220         if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
 221             _InterlockedOr(&tsp->flags, CM_SERVERFLAG_DOWN);
 222             tsp->downTime = time(NULL);
 223         }
 224         if (code != VRESTARTING) {
 225             lock_ReleaseMutex(&tsp->mx);
 226             cm_ForceNewConnections(tsp);
 227             lock_ObtainMutex(&tsp->mx);
 228         }
 229         osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is down with caps 0x%x",
 230                   osi_LogSaveString(afsd_logp, hoststr),
 231                   tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 232                   tsp->capabilities);
 233
 234         /* Now update the volume status if necessary */
 235         if (!wasDown) {
 236             cm_server_vols_t * tsrvp;
 237             cm_volume_t * volp;
 238             int i;
 239
 240             for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
 241                 for (i=0; i<NUM_SERVER_VOLS; i++) {
 242                     if (tsrvp->ids[i] != 0) {
 243                         cm_InitReq(&req);
 244
 245                         lock_ReleaseMutex(&tsp->mx);
 246                         code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
 247                                                 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
 248                         lock_ObtainMutex(&tsp->mx);
 249                         if (code == 0) {
 250                             cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
 251                             cm_PutVolume(volp);
 252                         }
 253                     }
 254                 }
 255             }
 256         }
 257     }
 258
 259     if (tsp->waitCount == 0)
 260         _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_PINGING);
 261     else
 262         osi_Wakeup((LONG_PTR)tsp);
 263     lock_ReleaseMutex(&tsp->mx);
 264 }
 265
 266 void
 267 cm_RankUpServers()
 268 {
 269     cm_server_t * tsp;
 270
 271     lock_ObtainRead(&cm_serverLock);
 272     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
 273         cm_GetServerNoLock(tsp);
 274         lock_ReleaseRead(&cm_serverLock);
 275
 276         lock_ObtainMutex(&tsp->mx);
 277
 278         /* if the server is not down, rank the server */
 279         if(!(tsp->flags & CM_SERVERFLAG_DOWN))
 280            cm_RankServer(tsp);
 281
 282         lock_ReleaseMutex(&tsp->mx);
 283
 284         lock_ObtainRead(&cm_serverLock);
 285         cm_PutServerNoLock(tsp);
 286     }
 287     lock_ReleaseRead(&cm_serverLock);
 288 }
 289
 290 static void cm_CheckServersSingular(afs_uint32 flags, cm_cell_t *cellp)
 291 {
 292     /* ping all file servers, up or down, with unauthenticated connection,
 293      * to find out whether we have all our callbacks from the server still.
 294      * Also, ping down VLDBs.
 295      */
 296     cm_server_t *tsp;
 297     int doPing;
 298     int isDown;
 299     int isFS;
 300     int isVLDB;
 301
 302     lock_ObtainRead(&cm_serverLock);
 303     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
 304         cm_GetServerNoLock(tsp);
 305         lock_ReleaseRead(&cm_serverLock);
 306
 307         /* now process the server */
 308         lock_ObtainMutex(&tsp->mx);
 309
 310         doPing = 0;
 311         isDown = tsp->flags & CM_SERVERFLAG_DOWN;
 312         isFS   = tsp->type == CM_SERVER_FILE;
 313         isVLDB = tsp->type == CM_SERVER_VLDB;
 314
 315         /* only do the ping if the cell matches the requested cell, or we're
 316          * matching all cells (cellp == NULL), and if we've requested to ping
 317          * this type of {up, down} servers.
 318          */
 319         if ((cellp == NULL || cellp == tsp->cellp) &&
 320              ((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
 321                (!isDown && (flags & CM_FLAG_CHECKUPSERVERS))) &&
 322              ((!(flags & CM_FLAG_CHECKVLDBSERVERS) ||
 323                isVLDB && (flags & CM_FLAG_CHECKVLDBSERVERS)) &&
 324               (!(flags & CM_FLAG_CHECKFILESERVERS) ||
 325                  isFS && (flags & CM_FLAG_CHECKFILESERVERS)))) {
 326             doPing = 1;
 327         }       /* we're supposed to check this up/down server */
 328         lock_ReleaseMutex(&tsp->mx);
 329
 330         /* at this point, we've adjusted the server state, so do the ping and
 331          * adjust things.
 332          */
 333         if (doPing)
 334             cm_PingServer(tsp);
 335
 336         /* also, run the GC function for connections on all of the
 337          * server's connections.
 338          */
 339         cm_GCConnections(tsp);
 340
 341         lock_ObtainRead(&cm_serverLock);
 342         cm_PutServerNoLock(tsp);
 343     }
 344     lock_ReleaseRead(&cm_serverLock);
 345 }
 346
 347 static void cm_CheckServersMulti(afs_uint32 flags, cm_cell_t *cellp)
 348 {
 349     /*
 350      * The goal of this function is to probe simultaneously
 351      * probe all of the up/down servers (vldb/file) as
 352      * specified by flags in the minimum number of RPCs.
 353      * Effectively that means use one multi_RXAFS_GetCapabilities()
 354      * followed by possibly one multi_RXAFS_GetTime() and
 355      * one multi_VL_ProbeServer().
 356      *
 357      * To make this work we must construct the list of vldb
 358      * and file servers that are to be probed as well as the
 359      * associated data structures.
 360      */
 361
 362     int srvAddrCount = 0;
 363     struct srvAddr **addrs = NULL;
 364     cm_conn_t **conns = NULL;
 365     struct rx_connection **rxconns = NULL;
 366     cm_req_t req;
 367     afs_int32 i, nconns = 0, maxconns;
 368     afs_int32 *conntimer, *results;
 369     Capabilities *caps = NULL;
 370     cm_server_t ** serversp, *tsp;
 371     afs_uint32 isDown, wasDown;
 372     afs_uint32 code;
 373     time_t start, *deltas;
 374     char hoststr[16];
 375
 376     cm_InitReq(&req);
 377     maxconns = max(cm_numFileServers,cm_numVldbServers);
 378     if (maxconns == 0)
 379         return;
 380
 381     conns = (cm_conn_t **)malloc(maxconns * sizeof(cm_conn_t *));
 382     rxconns = (struct rx_connection **)malloc(maxconns * sizeof(struct rx_connection *));
 383     conntimer = (afs_int32 *)malloc(maxconns * sizeof (afs_int32));
 384     deltas = (time_t *)malloc(maxconns * sizeof (time_t));
 385     results = (afs_int32 *)malloc(maxconns * sizeof (afs_int32));
 386     serversp = (cm_server_t **)malloc(maxconns * sizeof(cm_server_t *));
 387     caps = (Capabilities *)malloc(maxconns * sizeof(Capabilities));
 388
 389     memset(caps, 0, maxconns * sizeof(Capabilities));
 390
 391     if ((flags & CM_FLAG_CHECKFILESERVERS) ||
 392         !(flags & (CM_FLAG_CHECKFILESERVERS|CM_FLAG_CHECKVLDBSERVERS)))
 393     {
 394         lock_ObtainRead(&cm_serverLock);
 395         for (nconns=0, tsp = cm_allServersp; tsp && nconns < maxconns; tsp = tsp->allNextp) {
 396             if (tsp->type != CM_SERVER_FILE ||
 397                 tsp->cellp == NULL ||           /* SetPref only */
 398                 cellp && cellp != tsp->cellp)
 399                 continue;
 400
 401             cm_GetServerNoLock(tsp);
 402             lock_ReleaseRead(&cm_serverLock);
 403
 404             lock_ObtainMutex(&tsp->mx);
 405             isDown = tsp->flags & CM_SERVERFLAG_DOWN;
 406
 407             if ((tsp->flags & CM_SERVERFLAG_PINGING) ||
 408                 !((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
 409                    (!isDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
 410                 lock_ReleaseMutex(&tsp->mx);
 411                 lock_ObtainRead(&cm_serverLock);
 412                 cm_PutServerNoLock(tsp);
 413                 continue;
 414             }
 415
 416             _InterlockedOr(&tsp->flags, CM_SERVERFLAG_PINGING);
 417             lock_ReleaseMutex(&tsp->mx);
 418
 419             serversp[nconns] = tsp;
 420             code = cm_ConnByServer(tsp, cm_rootUserp, &conns[nconns]);
 421             if (code) {
 422                 lock_ObtainRead(&cm_serverLock);
 423                 cm_PutServerNoLock(tsp);
 424                 continue;
 425             }
 426             lock_ObtainRead(&cm_serverLock);
 427             rxconns[nconns] = cm_GetRxConn(conns[nconns]);
 428             if (conntimer[nconns] = (isDown ? 1 : 0))
 429                 rx_SetConnDeadTime(rxconns[nconns], 10);
 430
 431             nconns++;
 432         }
 433         lock_ReleaseRead(&cm_serverLock);
 434
 435         if (nconns) {
 436             /* Perform the multi call */
 437             start = time(NULL);
 438             multi_Rx(rxconns,nconns)
 439             {
 440                 multi_RXAFS_GetCapabilities(&caps[multi_i]);
 441                 results[multi_i]=multi_error;
 442             } multi_End;
 443         }
 444
 445         /* Process results of servers that support RXAFS_GetCapabilities */
 446         for (i=0; i<nconns; i++) {
 447             if (conntimer[i])
 448                 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
 449             rx_PutConnection(rxconns[i]);
 450             cm_PutConn(conns[i]);
 451
 452             tsp = serversp[i];
 453             cm_GCConnections(tsp);
 454
 455             lock_ObtainMutex(&tsp->mx);
 456             wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
 457
 458             if (results[i] >= 0 || results[i] == RXGEN_OPCODE)  {
 459                 /* mark server as up */
 460                 _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_DOWN);
 461                 tsp->downTime = 0;
 462
 463                 /* we currently handle 32-bits of capabilities */
 464                 if (results[i] != RXGEN_OPCODE && caps[i].Capabilities_len > 0) {
 465                     tsp->capabilities = caps[i].Capabilities_val[0];
 466                     xdr_free((xdrproc_t) xdr_Capabilities, &caps[i]);
 467                     caps[i].Capabilities_len = 0;
 468                     caps[i].Capabilities_val = 0;
 469                 } else {
 470                     tsp->capabilities = 0;
 471                 }
 472
 473                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
 474                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
 475                           osi_LogSaveString(afsd_logp, hoststr),
 476                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 477                           tsp->capabilities);
 478
 479                 /* Now update the volume status if necessary */
 480                 if (wasDown) {
 481                     cm_server_vols_t * tsrvp;
 482                     cm_volume_t * volp;
 483                     int i;
 484
 485                     for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
 486                         for (i=0; i<NUM_SERVER_VOLS; i++) {
 487                             if (tsrvp->ids[i] != 0) {
 488                                 cm_InitReq(&req);
 489
 490                                 lock_ReleaseMutex(&tsp->mx);
 491                                 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
 492                                                          &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
 493                                 lock_ObtainMutex(&tsp->mx);
 494                                 if (code == 0) {
 495                                     cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
 496                                     cm_PutVolume(volp);
 497                                 }
 498                             }
 499                         }
 500                     }
 501                 }
 502             } else {
 503                 /* mark server as down */
 504                 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
 505                     _InterlockedOr(&tsp->flags, CM_SERVERFLAG_DOWN);
 506                     tsp->downTime = time(NULL);
 507                 }
 508                 if (code != VRESTARTING) {
 509                     lock_ReleaseMutex(&tsp->mx);
 510                     cm_ForceNewConnections(tsp);
 511                     lock_ObtainMutex(&tsp->mx);
 512                 }
 513                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
 514                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
 515                           osi_LogSaveString(afsd_logp, hoststr),
 516                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 517                           tsp->capabilities);
 518
 519                 /* Now update the volume status if necessary */
 520                 if (!wasDown) {
 521                     cm_server_vols_t * tsrvp;
 522                     cm_volume_t * volp;
 523                     int i;
 524
 525                     for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
 526                         for (i=0; i<NUM_SERVER_VOLS; i++) {
 527                             if (tsrvp->ids[i] != 0) {
 528                                 cm_InitReq(&req);
 529
 530                                 lock_ReleaseMutex(&tsp->mx);
 531                                 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
 532                                                          &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
 533                                 lock_ObtainMutex(&tsp->mx);
 534                                 if (code == 0) {
 535                                     cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
 536                                     cm_PutVolume(volp);
 537                                 }
 538                             }
 539                         }
 540                     }
 541                 }
 542             }
 543
 544             if (tsp->waitCount == 0)
 545                 _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_PINGING);
 546             else
 547                 osi_Wakeup((LONG_PTR)tsp);
 548
 549             lock_ReleaseMutex(&tsp->mx);
 550
 551             cm_PutServer(tsp);
 552         }
 553     }
 554
 555     if ((flags & CM_FLAG_CHECKVLDBSERVERS) ||
 556         !(flags & (CM_FLAG_CHECKFILESERVERS|CM_FLAG_CHECKVLDBSERVERS)))
 557     {
 558         lock_ObtainRead(&cm_serverLock);
 559         for (nconns=0, tsp = cm_allServersp; tsp && nconns < maxconns; tsp = tsp->allNextp) {
 560             if (tsp->type != CM_SERVER_VLDB ||
 561                 tsp->cellp == NULL ||           /* SetPref only */
 562                 cellp && cellp != tsp->cellp)
 563                 continue;
 564
 565             cm_GetServerNoLock(tsp);
 566             lock_ReleaseRead(&cm_serverLock);
 567
 568             lock_ObtainMutex(&tsp->mx);
 569             isDown = tsp->flags & CM_SERVERFLAG_DOWN;
 570
 571             if ((tsp->flags & CM_SERVERFLAG_PINGING) ||
 572                 !((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
 573                    (!isDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
 574                 lock_ReleaseMutex(&tsp->mx);
 575                 lock_ObtainRead(&cm_serverLock);
 576                 cm_PutServerNoLock(tsp);
 577                 continue;
 578             }
 579
 580             _InterlockedOr(&tsp->flags, CM_SERVERFLAG_PINGING);
 581             lock_ReleaseMutex(&tsp->mx);
 582
 583             serversp[nconns] = tsp;
 584             code = cm_ConnByServer(tsp, cm_rootUserp, &conns[nconns]);
 585             if (code) {
 586                 lock_ObtainRead(&cm_serverLock);
 587                 cm_PutServerNoLock(tsp);
 588                 continue;
 589             }
 590             lock_ObtainRead(&cm_serverLock);
 591             rxconns[nconns] = cm_GetRxConn(conns[nconns]);
 592             conntimer[nconns] = (isDown ? 1 : 0);
 593             if (isDown)
 594                 rx_SetConnDeadTime(rxconns[nconns], 10);
 595
 596             nconns++;
 597         }
 598         lock_ReleaseRead(&cm_serverLock);
 599
 600         if (nconns) {
 601             /* Perform the multi call */
 602             start = time(NULL);
 603             multi_Rx(rxconns,nconns)
 604             {
 605                 multi_VL_ProbeServer();
 606                 results[multi_i]=multi_error;
 607             } multi_End;
 608         }
 609
 610         /* Process results of servers that support VL_ProbeServer */
 611         for (i=0; i<nconns; i++) {
 612             if (conntimer[i])
 613                 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
 614             rx_PutConnection(rxconns[i]);
 615             cm_PutConn(conns[i]);
 616
 617             tsp = serversp[i];
 618             cm_GCConnections(tsp);
 619
 620             lock_ObtainMutex(&tsp->mx);
 621             wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
 622
 623             if (results[i] >= 0)  {
 624                 /* mark server as up */
 625                 _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_DOWN);
 626                 tsp->downTime = 0;
 627                 tsp->capabilities = 0;
 628
 629                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
 630                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
 631                           osi_LogSaveString(afsd_logp, hoststr),
 632                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 633                           tsp->capabilities);
 634             } else {
 635                 /* mark server as down */
 636                 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
 637                     _InterlockedOr(&tsp->flags, CM_SERVERFLAG_DOWN);
 638                     tsp->downTime = time(NULL);
 639                 }
 640                 if (code != VRESTARTING) {
 641                     lock_ReleaseMutex(&tsp->mx);
 642                     cm_ForceNewConnections(tsp);
 643                     lock_ObtainMutex(&tsp->mx);
 644                 }
 645                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
 646                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
 647                           osi_LogSaveString(afsd_logp, hoststr),
 648                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 649                           tsp->capabilities);
 650             }
 651
 652             if (tsp->waitCount == 0)
 653                 _InterlockedAnd(&tsp->flags, ~CM_SERVERFLAG_PINGING);
 654             else
 655                 osi_Wakeup((LONG_PTR)tsp);
 656
 657             lock_ReleaseMutex(&tsp->mx);
 658
 659             cm_PutServer(tsp);
 660         }
 661     }
 662
 663     free(conns);
 664     free(rxconns);
 665     free(conntimer);
 666     free(deltas);
 667     free(results);
 668     free(serversp);
 669     free(caps);
 670 }
 671
 672 void cm_CheckServers(afs_uint32 flags, cm_cell_t *cellp)
 673 {
 674     DWORD code;
 675     HKEY parmKey;
 676     DWORD dummyLen;
 677     DWORD multi = 1;
 678
 679     code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
 680                          0, KEY_QUERY_VALUE, &parmKey);
 681     if (code == ERROR_SUCCESS) {
 682         dummyLen = sizeof(multi);
 683         code = RegQueryValueEx(parmKey, "MultiCheckServers", NULL, NULL,
 684                                 (BYTE *) &multi, &dummyLen);
 685         RegCloseKey (parmKey);
 686     }
 687
 688     if (multi)
 689         cm_CheckServersMulti(flags, cellp);
 690     else
 691         cm_CheckServersSingular(flags, cellp);
 692 }
 693
 694 void cm_InitServer(void)
 695 {
 696     static osi_once_t once;
 697
 698     if (osi_Once(&once)) {
 699         lock_InitializeRWLock(&cm_serverLock, "cm_serverLock", LOCK_HIERARCHY_SERVER_GLOBAL);
 700         lock_InitializeRWLock(&cm_syscfgLock, "cm_syscfgLock", LOCK_HIERARCHY_SYSCFG_GLOBAL);
 701         osi_EndOnce(&once);
 702     }
 703 }
 704
 705 /* Protected by cm_syscfgLock (rw) */
 706 int cm_noIPAddr;         /* number of client network interfaces */
 707 int cm_IPAddr[CM_MAXINTERFACE_ADDR];    /* client's IP address in host order */
 708 int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
 709 int cm_NetMtu[CM_MAXINTERFACE_ADDR];    /* client's MTU sizes */
 710 int cm_NetFlags[CM_MAXINTERFACE_ADDR];  /* network flags */
 711 int cm_LanAdapterChangeDetected = 1;
 712
 713 void cm_SetLanAdapterChangeDetected(void)
 714 {
 715     lock_ObtainWrite(&cm_syscfgLock);
 716     cm_LanAdapterChangeDetected = 1;
 717     lock_ReleaseWrite(&cm_syscfgLock);
 718 }
 719
 720 void cm_GetServer(cm_server_t *serverp)
 721 {
 722     lock_ObtainRead(&cm_serverLock);
 723     InterlockedIncrement(&serverp->refCount);
 724     lock_ReleaseRead(&cm_serverLock);
 725 }
 726
 727 void cm_GetServerNoLock(cm_server_t *serverp)
 728 {
 729     InterlockedIncrement(&serverp->refCount);
 730 }
 731
 732 void cm_PutServer(cm_server_t *serverp)
 733 {
 734     afs_int32 refCount;
 735     lock_ObtainRead(&cm_serverLock);
 736     refCount = InterlockedDecrement(&serverp->refCount);
 737     osi_assertx(refCount >= 0, "cm_server_t refCount underflow");
 738     lock_ReleaseRead(&cm_serverLock);
 739 }
 740
 741 void cm_PutServerNoLock(cm_server_t *serverp)
 742 {
 743     afs_int32 refCount = InterlockedDecrement(&serverp->refCount);
 744     osi_assertx(refCount >= 0, "cm_server_t refCount underflow");
 745 }
 746
 747 void cm_SetServerNo64Bit(cm_server_t * serverp, int no64bit)
 748 {
 749     lock_ObtainMutex(&serverp->mx);
 750     if (no64bit)
 751         _InterlockedOr(&serverp->flags, CM_SERVERFLAG_NO64BIT);
 752     else
 753         _InterlockedAnd(&serverp->flags, ~CM_SERVERFLAG_NO64BIT);
 754     lock_ReleaseMutex(&serverp->mx);
 755 }
 756
 757 void cm_SetServerNoInlineBulk(cm_server_t * serverp, int no)
 758 {
 759     lock_ObtainMutex(&serverp->mx);
 760     if (no)
 761         _InterlockedOr(&serverp->flags, CM_SERVERFLAG_NOINLINEBULK);
 762     else
 763         _InterlockedAnd(&serverp->flags, ~CM_SERVERFLAG_NOINLINEBULK);
 764     lock_ReleaseMutex(&serverp->mx);
 765 }
 766
 767 void cm_SetServerPrefs(cm_server_t * serverp)
 768 {
 769     unsigned long       serverAddr;     /* in host byte order */
 770     unsigned long       myAddr, myNet, mySubnet;/* in host byte order */
 771     unsigned long       netMask;
 772     int                 i;
 773     long code;
 774     int writeLock = 0;
 775
 776     lock_ObtainRead(&cm_syscfgLock);
 777     if (cm_LanAdapterChangeDetected) {
 778         lock_ConvertRToW(&cm_syscfgLock);
 779         writeLock = 1;
 780         if (cm_LanAdapterChangeDetected) {
 781             /* get network related info */
 782             cm_noIPAddr = CM_MAXINTERFACE_ADDR;
 783             code = syscfg_GetIFInfo(&cm_noIPAddr,
 784                                      cm_IPAddr, cm_SubnetMask,
 785                                      cm_NetMtu, cm_NetFlags);
 786             cm_LanAdapterChangeDetected = 0;
 787         }
 788         lock_ConvertWToR(&cm_syscfgLock);
 789     }
 790
 791     serverAddr = ntohl(serverp->addr.sin_addr.s_addr);
 792     serverp->ipRank  = CM_IPRANK_LOW;   /* default settings */
 793
 794     for ( i=0; i < cm_noIPAddr; i++)
 795     {
 796         /* loop through all the client's IP address and compare
 797         ** each of them against the server's IP address */
 798
 799         myAddr = cm_IPAddr[i];
 800         if ( IN_CLASSA(myAddr) )
 801             netMask = IN_CLASSA_NET;
 802         else if ( IN_CLASSB(myAddr) )
 803             netMask = IN_CLASSB_NET;
 804         else if ( IN_CLASSC(myAddr) )
 805             netMask = IN_CLASSC_NET;
 806         else
 807             netMask = 0;
 808
 809         myNet    =  myAddr & netMask;
 810         mySubnet =  myAddr & cm_SubnetMask[i];
 811
 812         if ( (serverAddr & netMask) == myNet )
 813         {
 814             if ( (serverAddr & cm_SubnetMask[i]) == mySubnet)
 815             {
 816                 if ( serverAddr == myAddr )
 817                     serverp->ipRank = min(serverp->ipRank,
 818                                            CM_IPRANK_TOP);/* same machine */
 819                 else serverp->ipRank = min(serverp->ipRank,
 820                                             CM_IPRANK_HI); /* same subnet */
 821             }
 822             else serverp->ipRank = min(serverp->ipRank,CM_IPRANK_MED);
 823             /* same net */
 824         }
 825     } /* and of for loop */
 826
 827     /* random between 0..15*/
 828     serverp->ipRank += (rand() % 0x000f);
 829     lock_ReleaseRead(&cm_syscfgLock);
 830 }
 831
 832 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp, afsUUID *uuidp, afs_uint32 flags) {
 833     cm_server_t *tsp;
 834
 835     osi_assertx(socketp->sin_family == AF_INET, "unexpected socket family");
 836
 837     lock_ObtainWrite(&cm_serverLock);   /* get server lock */
 838     tsp = cm_FindServer(socketp, type, TRUE);
 839     if (tsp) {
 840         /* we might have found a server created by set server prefs */
 841         if (uuidp && !afs_uuid_is_nil(uuidp) &&
 842             !(tsp->flags & CM_SERVERFLAG_UUID))
 843         {
 844             tsp->uuid = *uuidp;
 845             _InterlockedOr(&tsp->flags, CM_SERVERFLAG_UUID);
 846         }
 847         lock_ReleaseWrite(&cm_serverLock);
 848         return tsp;
 849     }
 850
 851     tsp = malloc(sizeof(*tsp));
 852     if (tsp) {
 853         memset(tsp, 0, sizeof(*tsp));
 854         tsp->type = type;
 855         tsp->cellp = cellp;
 856         if (uuidp && !afs_uuid_is_nil(uuidp)) {
 857             tsp->uuid = *uuidp;
 858             _InterlockedOr(&tsp->flags, CM_SERVERFLAG_UUID);
 859         }
 860         tsp->refCount = 1;
 861         lock_InitializeMutex(&tsp->mx, "cm_server_t mutex", LOCK_HIERARCHY_SERVER);
 862         tsp->addr = *socketp;
 863
 864         cm_SetServerPrefs(tsp);
 865
 866         tsp->allNextp = cm_allServersp;
 867         cm_allServersp = tsp;
 868
 869         switch (type) {
 870         case CM_SERVER_VLDB:
 871             cm_numVldbServers++;
 872             break;
 873         case CM_SERVER_FILE:
 874             cm_numFileServers++;
 875             break;
 876         }
 877     }
 878     lock_ReleaseWrite(&cm_serverLock);  /* release server lock */
 879
 880     if (!(flags & CM_FLAG_NOPROBE) && tsp) {
 881         _InterlockedOr(&tsp->flags, CM_SERVERFLAG_DOWN);        /* assume down; ping will mark up if available */
 882         cm_PingServer(tsp);                                     /* Obtain Capabilities and check up/down state */
 883     }
 884
 885     return tsp;
 886 }
 887
 888 cm_server_t *
 889 cm_FindServerByIP(afs_uint32 ipaddr, unsigned short port, int type, int locked)
 890 {
 891     cm_server_t *tsp;
 892
 893     if (!locked)
 894         lock_ObtainRead(&cm_serverLock);
 895
 896     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
 897         if (tsp->type == type &&
 898             tsp->addr.sin_addr.S_un.S_addr == ipaddr &&
 899             (tsp->addr.sin_port == port || tsp->addr.sin_port == 0))
 900             break;
 901     }
 902
 903     /* bump ref count if we found the server */
 904     if (tsp)
 905         cm_GetServerNoLock(tsp);
 906
 907     if (!locked)
 908         lock_ReleaseRead(&cm_serverLock);
 909
 910     return tsp;
 911 }
 912
 913 cm_server_t *
 914 cm_FindServerByUuid(afsUUID *serverUuid, int type, int locked)
 915 {
 916     cm_server_t *tsp;
 917
 918     if (locked)
 919         lock_ObtainRead(&cm_serverLock);
 920
 921     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
 922         if (tsp->type == type && !afs_uuid_equal(&tsp->uuid, serverUuid))
 923             break;
 924     }
 925
 926     /* bump ref count if we found the server */
 927     if (tsp)
 928         cm_GetServerNoLock(tsp);
 929
 930     if (!locked)
 931         lock_ReleaseRead(&cm_serverLock);
 932
 933     return tsp;
 934 }
 935
 936 /* find a server based on its properties */
 937 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type, int locked)
 938 {
 939     osi_assertx(addrp->sin_family == AF_INET, "unexpected socket value");
 940
 941     return cm_FindServerByIP(addrp->sin_addr.s_addr, addrp->sin_port, type, locked);
 942 }
 943
 944 cm_server_vols_t *cm_NewServerVols(void) {
 945     cm_server_vols_t *tsvp;
 946
 947     tsvp = malloc(sizeof(*tsvp));
 948     if (tsvp)
 949         memset(tsvp, 0, sizeof(*tsvp));
 950
 951     return tsvp;
 952 }
 953
 954 /*
 955  * cm_NewServerRef() returns with the allocated cm_serverRef_t
 956  * with a refCount of 1.
 957  */
 958 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp, afs_uint32 volID)
 959 {
 960     cm_serverRef_t *tsrp;
 961     cm_server_vols_t **tsrvpp = NULL;
 962     afs_uint32 *slotp = NULL;
 963     int found = 0;
 964
 965     cm_GetServer(serverp);
 966     tsrp = malloc(sizeof(*tsrp));
 967     tsrp->server = serverp;
 968     tsrp->status = srv_not_busy;
 969     tsrp->next = NULL;
 970     tsrp->volID = volID;
 971     tsrp->refCount = 1;
 972
 973     /* if we have a non-zero volID, we need to add it to the list
 974      * of volumes maintained by the server.  There are two phases:
 975      * (1) see if the volID is already in the list and (2) insert
 976      * it into the first empty slot if it is not.
 977      */
 978     if (volID) {
 979         lock_ObtainMutex(&serverp->mx);
 980
 981         tsrvpp = &serverp->vols;
 982         while (*tsrvpp) {
 983             int i;
 984
 985             for (i=0; i<NUM_SERVER_VOLS; i++) {
 986                 if ((*tsrvpp)->ids[i] == volID) {
 987                     found = 1;
 988                     break;
 989                 } else if (!slotp && (*tsrvpp)->ids[i] == 0) {
 990                     slotp = &(*tsrvpp)->ids[i];
 991                 }
 992             }
 993
 994             if (found)
 995                 break;
 996
 997             tsrvpp = &(*tsrvpp)->nextp;
 998         }
 999
1000         if (!found) {
1001             if (slotp) {
1002                 *slotp = volID;
1003             } else {
1004                 /* if we didn't find an empty slot in a current
1005                  * page we must need a new page */
1006                 *tsrvpp = cm_NewServerVols();
1007                 if (*tsrvpp)
1008                     (*tsrvpp)->ids[0] = volID;
1009             }
1010         }
1011
1012         lock_ReleaseMutex(&serverp->mx);
1013     }
1014
1015     return tsrp;
1016 }
1017
1018 void cm_GetServerRef(cm_serverRef_t *tsrp, int locked)
1019 {
1020     afs_int32 refCount;
1021
1022     if (!locked)
1023         lock_ObtainRead(&cm_serverLock);
1024     refCount = InterlockedIncrement(&tsrp->refCount);
1025     if (!locked)
1026         lock_ReleaseRead(&cm_serverLock);
1027 }
1028
1029 afs_int32 cm_PutServerRef(cm_serverRef_t *tsrp, int locked)
1030 {
1031     afs_int32 refCount;
1032
1033     if (!locked)
1034         lock_ObtainRead(&cm_serverLock);
1035     refCount = InterlockedDecrement(&tsrp->refCount);
1036     osi_assertx(refCount >= 0, "cm_serverRef_t refCount underflow");
1037
1038     if (!locked)
1039         lock_ReleaseRead(&cm_serverLock);
1040
1041     return refCount;
1042 }
1043
1044
1045
1046 LONG_PTR cm_ChecksumServerList(cm_serverRef_t *serversp)
1047 {
1048     LONG_PTR sum = 0;
1049     int first = 1;
1050     cm_serverRef_t *tsrp;
1051
1052     lock_ObtainRead(&cm_serverLock);
1053     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
1054         if (tsrp->status == srv_deleted)
1055             continue;
1056         if (first)
1057             first = 0;
1058         else
1059             sum <<= 1;
1060         sum ^= (LONG_PTR) tsrp->server;
1061     }
1062
1063     lock_ReleaseRead(&cm_serverLock);
1064     return sum;
1065 }
1066
1067 /*
1068 ** Insert a server into the server list keeping the list sorted in
1069 ** ascending order of ipRank.
1070 **
1071 ** The refCount of the cm_serverRef_t is not altered.
1072 */
1073 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
1074 {
1075     cm_serverRef_t      *current;
1076     unsigned short ipRank;
1077
1078     lock_ObtainWrite(&cm_serverLock);
1079     /*
1080      * Since we are grabbing the serverLock exclusively remove any
1081      * deleted serverRef objects with a zero refcount before
1082      * inserting the new item.
1083      */
1084     if (*list) {
1085         cm_serverRef_t  **currentp = list;
1086         cm_serverRef_t  **nextp = NULL;
1087         cm_serverRef_t  * next = NULL;
1088
1089         for (currentp = list; *currentp; currentp = nextp)
1090         {
1091             nextp = &(*currentp)->next;
1092             if ((*currentp)->refCount == 0 &&
1093                 (*currentp)->status == srv_deleted) {
1094                 next = *nextp;
1095
1096                 if ((*currentp)->volID)
1097                     cm_RemoveVolumeFromServer((*currentp)->server, (*currentp)->volID);
1098                 cm_FreeServer((*currentp)->server);
1099                 free(*currentp);
1100                 nextp = &next;
1101             }
1102         }
1103     }
1104
1105     /* insertion into empty list  or at the beginning of the list */
1106     if (!(*list))
1107     {
1108         element->next = NULL;
1109         *list = element;
1110         goto done;
1111     }
1112
1113     /*
1114      * Now that deleted entries have been removed and we know that the
1115      * list was not empty, look for duplicates.  If the element we are
1116      * inserting already exists, discard it.
1117      */
1118     for ( current = *list; current; current = current->next)
1119     {
1120         cm_server_t * server1 = current->server;
1121         cm_server_t * server2 = element->server;
1122
1123         if (current->status == srv_deleted)
1124             continue;
1125
1126         if (server1->type != server2->type)
1127             continue;
1128
1129         if (server1->addr.sin_addr.s_addr != server2->addr.sin_addr.s_addr)
1130             continue;
1131
1132         if ((server1->flags & CM_SERVERFLAG_UUID) != (server2->flags & CM_SERVERFLAG_UUID))
1133             continue;
1134
1135         if ((server1->flags & CM_SERVERFLAG_UUID) &&
1136             !afs_uuid_equal(&server1->uuid, &server2->uuid))
1137             continue;
1138
1139         /* we must have a match, discard the new element */
1140         free(element);
1141         goto done;
1142     }
1143
1144     ipRank = element->server->ipRank;
1145
1146         /* insertion at the beginning of the list */
1147     if ((*list)->server->ipRank > ipRank)
1148     {
1149         element->next = *list;
1150         *list = element;
1151         goto done;
1152     }
1153
1154     /* find appropriate place to insert */
1155     for ( current = *list; current->next; current = current->next)
1156     {
1157         if ( current->next->server->ipRank > ipRank )
1158             break;
1159     }
1160     element->next = current->next;
1161     current->next = element;
1162
1163   done:
1164     lock_ReleaseWrite(&cm_serverLock);
1165 }
1166 /*
1167 ** Re-sort the server list with the modified rank
1168 ** returns 0 if element was changed successfully.
1169 ** returns 1 if  list remained unchanged.
1170 */
1171 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t*    server)
1172 {
1173     cm_serverRef_t  **current;
1174     cm_serverRef_t   *element;
1175
1176     lock_ObtainWrite(&cm_serverLock);
1177     current=list;
1178     element=0;
1179
1180     /* if there is max of one element in the list, nothing to sort */
1181     if ( (!*current) || !((*current)->next)  ) {
1182         lock_ReleaseWrite(&cm_serverLock);
1183         return 1;               /* list unchanged: return success */
1184     }
1185
1186     /* if the server is on the list, delete it from list */
1187     while ( *current )
1188     {
1189         if ( (*current)->server == server)
1190         {
1191             element = (*current);
1192             *current = element->next; /* delete it */
1193             break;
1194         }
1195         current = & ( (*current)->next);
1196     }
1197     lock_ReleaseWrite(&cm_serverLock);
1198
1199     /* if this volume is not replicated on this server  */
1200     if (!element)
1201         return 1;       /* server is not on list */
1202
1203     /* re-insert deleted element into the list with modified rank*/
1204     cm_InsertServerList(list, element);
1205
1206     return 0;
1207 }
1208 /*
1209 ** If there are more than one server on the list and the first n servers on
1210 ** the list have the same rank( n>1), then randomise among the first n servers.
1211 */
1212 void cm_RandomizeServer(cm_serverRef_t** list)
1213 {
1214     int                 count, picked;
1215     cm_serverRef_t*     tsrp, *lastTsrp;
1216     unsigned short      lowestRank;
1217
1218     lock_ObtainWrite(&cm_serverLock);
1219     tsrp = *list;
1220
1221     /* an empty list or a list with only one element */
1222     if ( !tsrp || ! tsrp->next ) {
1223         lock_ReleaseWrite(&cm_serverLock);
1224         return ;
1225     }
1226
1227     /* count the number of servers with the lowest rank */
1228     lowestRank = tsrp->server->ipRank;
1229     for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
1230     {
1231         if ( tsrp->server->ipRank != lowestRank)
1232             break;
1233         else
1234             count++;
1235     }
1236
1237     /* if there is only one server with the lowest rank, we are done */
1238     if ( count <= 1 ) {
1239         lock_ReleaseWrite(&cm_serverLock);
1240         return ;
1241     }
1242
1243     picked = rand() % count;
1244     if ( !picked ) {
1245         lock_ReleaseWrite(&cm_serverLock);
1246         return ;
1247     }
1248
1249     tsrp = *list;
1250     while (--picked >= 0)
1251     {
1252         lastTsrp = tsrp;
1253         tsrp = tsrp->next;
1254     }
1255     lastTsrp->next = tsrp->next;  /* delete random element from list*/
1256     tsrp->next     = *list; /* insert element at the beginning of list */
1257     *list          = tsrp;
1258     lock_ReleaseWrite(&cm_serverLock);
1259 }
1260
1261 /* call cm_FreeServer while holding a write lock on cm_serverLock */
1262 void cm_FreeServer(cm_server_t* serverp)
1263 {
1264     cm_server_vols_t * tsrvp, *nextp;
1265     int delserver = 0;
1266
1267     cm_PutServerNoLock(serverp);
1268     if (serverp->refCount == 0)
1269     {
1270         /*
1271          * we need to check to ensure that all of the connections
1272          * for this server have a 0 refCount; otherwise, they will
1273          * not be garbage collected
1274          *
1275          * must drop the cm_serverLock because cm_GCConnections
1276          * obtains the cm_connLock and that comes first in the
1277          * lock hierarchy.
1278          */
1279         lock_ReleaseWrite(&cm_serverLock);
1280         cm_GCConnections(serverp);  /* connsp */
1281         lock_ObtainWrite(&cm_serverLock);
1282     }
1283
1284
1285     /*
1286      * Once we have the cm_serverLock locked check to make
1287      * sure the refCount is still zero before removing the
1288      * server entirely.
1289      */
1290     if (serverp->refCount == 0) {
1291         if (!(serverp->flags & CM_SERVERFLAG_PREF_SET)) {
1292             switch (serverp->type) {
1293             case CM_SERVER_VLDB:
1294                 cm_numVldbServers--;
1295                 break;
1296             case CM_SERVER_FILE:
1297                 cm_numFileServers--;
1298                 break;
1299             }
1300
1301             lock_FinalizeMutex(&serverp->mx);
1302             if ( cm_allServersp == serverp )
1303                 cm_allServersp = serverp->allNextp;
1304             else {
1305                 cm_server_t *tsp;
1306
1307                 for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
1308                     if ( tsp->allNextp == serverp ) {
1309                         tsp->allNextp = serverp->allNextp;
1310                         break;
1311                     }
1312                 }
1313             }
1314
1315             /* free the volid list */
1316             for ( tsrvp = serverp->vols; tsrvp; tsrvp = nextp) {
1317                 nextp = tsrvp->nextp;
1318                 free(tsrvp);
1319             }
1320
1321             free(serverp);
1322         }
1323     }
1324 }
1325
1326 /* Called with cm_serverLock write locked */
1327 void cm_RemoveVolumeFromServer(cm_server_t * serverp, afs_uint32 volID)
1328 {
1329     cm_server_vols_t * tsrvp;
1330     int i;
1331
1332     if (volID == 0)
1333         return;
1334
1335     for (tsrvp = serverp->vols; tsrvp; tsrvp = tsrvp->nextp) {
1336         for (i=0; i<NUM_SERVER_VOLS; i++) {
1337             if (tsrvp->ids[i] == volID) {
1338                 tsrvp->ids[i] = 0;;
1339                 break;
1340             }
1341         }
1342     }
1343 }
1344
1345 void cm_FreeServerList(cm_serverRef_t** list, afs_uint32 flags)
1346 {
1347     cm_serverRef_t  **current;
1348     cm_serverRef_t  **nextp;
1349     cm_serverRef_t  * next;
1350     afs_int32         refCount;
1351
1352     lock_ObtainWrite(&cm_serverLock);
1353     current = list;
1354     nextp = 0;
1355     next = 0;
1356
1357     if (*list == NULL)
1358         goto done;
1359
1360     while (*current)
1361     {
1362         nextp = &(*current)->next;
1363         refCount = cm_PutServerRef(*current, TRUE);
1364         if (refCount == 0) {
1365             next = *nextp;
1366
1367             if ((*current)->volID)
1368                 cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1369             cm_FreeServer((*current)->server);
1370             free(*current);
1371             *current = next;
1372         } else {
1373             if (flags & CM_FREESERVERLIST_DELETE) {
1374                 (*current)->status = srv_deleted;
1375                 if ((*current)->volID)
1376                     cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1377             }
1378             current = nextp;
1379         }
1380     }
1381
1382   done:
1383
1384     lock_ReleaseWrite(&cm_serverLock);
1385 }
1386
1387 /* dump all servers to a file.
1388  * cookie is used to identify this batch for easy parsing,
1389  * and it a string provided by a caller
1390  */
1391 int cm_DumpServers(FILE *outputFile, char *cookie, int lock)
1392 {
1393     int zilch;
1394     cm_server_t *tsp;
1395     char output[1024];
1396     char uuidstr[128];
1397     char hoststr[16];
1398
1399     if (lock)
1400         lock_ObtainRead(&cm_serverLock);
1401
1402     sprintf(output,
1403             "%s - dumping servers - cm_numFileServers=%d, cm_numVldbServers=%d\r\n",
1404             cookie, cm_numFileServers, cm_numVldbServers);
1405     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1406
1407     for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp)
1408     {
1409         char * type;
1410         char * down;
1411
1412         switch (tsp->type) {
1413         case CM_SERVER_VLDB:
1414             type = "vldb";
1415             break;
1416         case CM_SERVER_FILE:
1417             type = "file";
1418             break;
1419         default:
1420             type = "unknown";
1421         }
1422
1423         afsUUID_to_string(&tsp->uuid, uuidstr, sizeof(uuidstr));
1424         afs_inet_ntoa_r(tsp->addr.sin_addr.s_addr, hoststr);
1425         down = ctime(&tsp->downTime);
1426         down[strlen(down)-1] = '\0';
1427
1428         sprintf(output,
1429                  "%s - tsp=0x%p cell=%s addr=%-15s port=%u uuid=%s type=%s caps=0x%x "
1430                  "flags=0x%x waitCount=%u rank=%u downTime=\"%s\" refCount=%u\r\n",
1431                  cookie, tsp, tsp->cellp ? tsp->cellp->name : "", hoststr,
1432                  ntohs(tsp->addr.sin_port), uuidstr, type,
1433                  tsp->capabilities, tsp->flags, tsp->waitCount, tsp->ipRank,
1434                  (tsp->flags & CM_SERVERFLAG_DOWN) ?  down : "up",
1435                  tsp->refCount);
1436         WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1437     }
1438     sprintf(output, "%s - Done dumping servers.\r\n", cookie);
1439     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1440
1441     if (lock)
1442         lock_ReleaseRead(&cm_serverLock);
1443
1444     return (0);
1445 }
1446
1447 /*
1448  * Determine if two servers are in fact the same.
1449  *
1450  * Returns 1 if they match, 0 if they do not
1451  */
1452 int cm_ServerEqual(cm_server_t *srv1, cm_server_t *srv2)
1453 {
1454     RPC_STATUS status;
1455
1456     if (srv1 == NULL || srv2 == NULL)
1457         return 0;
1458
1459     if (srv1 == srv2)
1460         return 1;
1461
1462     if (srv1->flags & CM_SERVERFLAG_UUID) {
1463         if (!(srv2->flags & CM_SERVERFLAG_UUID))
1464             return 0;
1465
1466         /* Both support UUID */
1467         if (UuidEqual((UUID *)&srv1->uuid, (UUID *)&srv2->uuid, &status))
1468             return 1;
1469     } else {
1470         if (srv1->flags & CM_SERVERFLAG_UUID)
1471             return 0;
1472
1473         /* Neither support UUID so perform an addr/port comparison */
1474         if ( srv1->addr.sin_family == srv2->addr.sin_family &&
1475              srv1->addr.sin_addr.s_addr == srv2->addr.sin_addr.s_addr &&
1476              srv1->addr.sin_port == srv2->addr.sin_port )
1477             return 1;
1478     }
1479
1480     return 0;
1481 }
1482