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