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