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