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