src/WINNT/afsd/cm_server.c

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