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