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