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