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
  29 void
  30 cm_ForceNewConnectionsAllServers(void)
  31 {
  32     cm_server_t *tsp;
  33
  34     lock_ObtainWrite(&cm_serverLock);
  35     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
  36         cm_GetServerNoLock(tsp);
  37         cm_ForceNewConnections(tsp);
  38         cm_PutServerNoLock(tsp);
  39     }
  40     lock_ReleaseWrite(&cm_serverLock);
  41 }
  42
  43 void
  44 cm_PingServer(cm_server_t *tsp)
  45 {
  46     long code;
  47     int wasDown = 0;
  48     cm_conn_t *connp;
  49     struct rx_connection * rxconnp;
  50     long secs;
  51     long usecs;
  52     Capabilities caps = {0, 0};
  53     char hoststr[16];
  54     cm_req_t req;
  55
  56     lock_ObtainMutex(&tsp->mx);
  57     if (tsp->flags & CM_SERVERFLAG_PINGING) {
  58         tsp->waitCount++;
  59         osi_SleepM((LONG_PTR)tsp, &tsp->mx);
  60         lock_ObtainMutex(&tsp->mx);
  61         tsp->waitCount--;
  62         if (tsp->waitCount == 0)
  63             tsp->flags &= ~CM_SERVERFLAG_PINGING;
  64         else
  65             osi_Wakeup((LONG_PTR)tsp);
  66         lock_ReleaseMutex(&tsp->mx);
  67         return;
  68     }
  69     tsp->flags |= CM_SERVERFLAG_PINGING;
  70     wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
  71     afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
  72     lock_ReleaseMutex(&tsp->mx);
  73
  74     code = cm_ConnByServer(tsp, cm_rootUserp, &connp);
  75     if (code == 0) {
  76         /* now call the appropriate ping call.  Drop the timeout if
  77         * the server is known to be down, so that we don't waste a
  78         * lot of time retiming out down servers.
  79         */
  80
  81         osi_Log4(afsd_logp, "cm_PingServer server %s (%s) was %s with caps 0x%x",
  82                   osi_LogSaveString(afsd_logp, hoststr),
  83                   tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
  84                   wasDown ? "down" : "up",
  85                   tsp->capabilities);
  86
  87         rxconnp = cm_GetRxConn(connp);
  88         if (wasDown)
  89             rx_SetConnDeadTime(rxconnp, 10);
  90         if (tsp->type == CM_SERVER_VLDB) {
  91             code = VL_ProbeServer(rxconnp);
  92         }
  93         else {
  94             /* file server */
  95             code = RXAFS_GetCapabilities(rxconnp, &caps);
  96             if (code == RXGEN_OPCODE)
  97                 code = RXAFS_GetTime(rxconnp, &secs, &usecs);
  98         }
  99         if (wasDown)
 100             rx_SetConnDeadTime(rxconnp, ConnDeadtimeout);
 101         rx_PutConnection(rxconnp);
 102         cm_PutConn(connp);
 103     }   /* got an unauthenticated connection to this server */
 104
 105     lock_ObtainMutex(&tsp->mx);
 106     if (code >= 0) {
 107         /* mark server as up */
 108         tsp->flags &= ~CM_SERVERFLAG_DOWN;
 109         tsp->downTime = 0;
 110
 111         /* we currently handle 32-bits of capabilities */
 112         if (caps.Capabilities_len > 0) {
 113             tsp->capabilities = caps.Capabilities_val[0];
 114             free(caps.Capabilities_val);
 115             caps.Capabilities_len = 0;
 116             caps.Capabilities_val = 0;
 117         } else {
 118             tsp->capabilities = 0;
 119         }
 120
 121         osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is up with caps 0x%x",
 122                   osi_LogSaveString(afsd_logp, hoststr),
 123                   tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 124                   tsp->capabilities);
 125
 126         /* Now update the volume status if necessary */
 127         if (wasDown) {
 128             cm_server_vols_t * tsrvp;
 129             cm_volume_t * volp;
 130             int i;
 131
 132             for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
 133                 for (i=0; i<NUM_SERVER_VOLS; i++) {
 134                     if (tsrvp->ids[i] != 0) {
 135                         cm_InitReq(&req);
 136
 137                         lock_ReleaseMutex(&tsp->mx);
 138                         code = cm_GetVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
 139                                                 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
 140                         lock_ObtainMutex(&tsp->mx);
 141                         if (code == 0) {
 142                             cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
 143                             cm_PutVolume(volp);
 144                         }
 145                     }
 146                 }
 147             }
 148         }
 149     } else {
 150         /* mark server as down */
 151         if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
 152             tsp->flags |= CM_SERVERFLAG_DOWN;
 153             tsp->downTime = osi_Time();
 154         }
 155         if (code != VRESTARTING)
 156             cm_ForceNewConnections(tsp);
 157
 158         osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is down with caps 0x%x",
 159                   osi_LogSaveString(afsd_logp, hoststr),
 160                   tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 161                   tsp->capabilities);
 162
 163         /* Now update the volume status if necessary */
 164         if (!wasDown) {
 165             cm_server_vols_t * tsrvp;
 166             cm_volume_t * volp;
 167             int i;
 168
 169             for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
 170                 for (i=0; i<NUM_SERVER_VOLS; i++) {
 171                     if (tsrvp->ids[i] != 0) {
 172                         cm_InitReq(&req);
 173
 174                         code = cm_GetVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
 175                                                 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
 176                         if (code == 0) {
 177                             cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
 178                             cm_PutVolume(volp);
 179                         }
 180                     }
 181                 }
 182             }
 183         }
 184     }
 185
 186     if (tsp->waitCount == 0)
 187         tsp->flags &= ~CM_SERVERFLAG_PINGING;
 188     else
 189         osi_Wakeup((LONG_PTR)tsp);
 190     lock_ReleaseMutex(&tsp->mx);
 191 }
 192
 193
 194 void cm_CheckServers(long flags, cm_cell_t *cellp)
 195 {
 196     /* ping all file servers, up or down, with unauthenticated connection,
 197      * to find out whether we have all our callbacks from the server still.
 198      * Also, ping down VLDBs.
 199      */
 200     cm_server_t *tsp;
 201     int doPing;
 202     int isDown;
 203     int isFS;
 204
 205     lock_ObtainWrite(&cm_serverLock);
 206     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
 207         cm_GetServerNoLock(tsp);
 208         lock_ReleaseWrite(&cm_serverLock);
 209
 210         /* now process the server */
 211         lock_ObtainMutex(&tsp->mx);
 212
 213         doPing = 0;
 214         isDown = tsp->flags & CM_SERVERFLAG_DOWN;
 215         isFS   = tsp->type == CM_SERVER_FILE;
 216
 217         /* only do the ping if the cell matches the requested cell, or we're
 218          * matching all cells (cellp == NULL), and if we've requested to ping
 219          * this type of {up, down} servers.
 220          */
 221         if ((cellp == NULL || cellp == tsp->cellp) &&
 222              ((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
 223                (!isDown && (flags & CM_FLAG_CHECKUPSERVERS))) &&
 224              ((!(flags & CM_FLAG_CHECKVLDBSERVERS) ||
 225                !isFS && (flags & CM_FLAG_CHECKVLDBSERVERS)) &&
 226               (!(flags & CM_FLAG_CHECKFILESERVERS) ||
 227                  isFS && (flags & CM_FLAG_CHECKFILESERVERS)))) {
 228             doPing = 1;
 229         }       /* we're supposed to check this up/down server */
 230         lock_ReleaseMutex(&tsp->mx);
 231
 232         /* at this point, we've adjusted the server state, so do the ping and
 233          * adjust things.
 234          */
 235         if (doPing)
 236             cm_PingServer(tsp);
 237
 238         /* also, run the GC function for connections on all of the
 239          * server's connections.
 240          */
 241         cm_GCConnections(tsp);
 242
 243         lock_ObtainWrite(&cm_serverLock);
 244         cm_PutServerNoLock(tsp);
 245     }
 246     lock_ReleaseWrite(&cm_serverLock);
 247 }
 248
 249 void cm_InitServer(void)
 250 {
 251     static osi_once_t once;
 252
 253     if (osi_Once(&once)) {
 254         lock_InitializeRWLock(&cm_serverLock, "cm_serverLock");
 255         osi_EndOnce(&once);
 256     }
 257 }
 258
 259 void cm_GetServer(cm_server_t *serverp)
 260 {
 261     lock_ObtainWrite(&cm_serverLock);
 262     serverp->refCount++;
 263     lock_ReleaseWrite(&cm_serverLock);
 264 }
 265
 266 void cm_GetServerNoLock(cm_server_t *serverp)
 267 {
 268     serverp->refCount++;
 269 }
 270
 271 void cm_PutServer(cm_server_t *serverp)
 272 {
 273     lock_ObtainWrite(&cm_serverLock);
 274     osi_assertx(serverp->refCount-- > 0, "cm_server_t refCount 0");
 275     lock_ReleaseWrite(&cm_serverLock);
 276 }
 277
 278 void cm_PutServerNoLock(cm_server_t *serverp)
 279 {
 280     osi_assertx(serverp->refCount-- > 0, "cm_server_t refCount 0");
 281 }
 282
 283 void cm_SetServerNo64Bit(cm_server_t * serverp, int no64bit)
 284 {
 285     lock_ObtainMutex(&serverp->mx);
 286     if (no64bit)
 287         serverp->flags |= CM_SERVERFLAG_NO64BIT;
 288     else
 289         serverp->flags &= ~CM_SERVERFLAG_NO64BIT;
 290     lock_ReleaseMutex(&serverp->mx);
 291 }
 292
 293 void cm_SetServerNoInlineBulk(cm_server_t * serverp, int no)
 294 {
 295     lock_ObtainMutex(&serverp->mx);
 296     if (no)
 297         serverp->flags |= CM_SERVERFLAG_NOINLINEBULK;
 298     else
 299         serverp->flags &= ~CM_SERVERFLAG_NOINLINEBULK;
 300     lock_ReleaseMutex(&serverp->mx);
 301 }
 302
 303 void cm_SetServerPrefs(cm_server_t * serverp)
 304 {
 305     unsigned long       serverAddr;     /* in host byte order */
 306     unsigned long       myAddr, myNet, mySubnet;/* in host byte order */
 307     unsigned long       netMask;
 308     int                 i;
 309
 310     int cm_noIPAddr;         /* number of client network interfaces */
 311     int cm_IPAddr[CM_MAXINTERFACE_ADDR];    /* client's IP address in host order */
 312     int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
 313     int cm_NetMtu[CM_MAXINTERFACE_ADDR];    /* client's MTU sizes */
 314     int cm_NetFlags[CM_MAXINTERFACE_ADDR];  /* network flags */
 315     long code;
 316
 317     /* get network related info */
 318     cm_noIPAddr = CM_MAXINTERFACE_ADDR;
 319     code = syscfg_GetIFInfo(&cm_noIPAddr,
 320                             cm_IPAddr, cm_SubnetMask,
 321                             cm_NetMtu, cm_NetFlags);
 322
 323     serverAddr = ntohl(serverp->addr.sin_addr.s_addr);
 324     serverp->ipRank  = CM_IPRANK_LOW;   /* default setings */
 325
 326     for ( i=0; i < cm_noIPAddr; i++)
 327     {
 328         /* loop through all the client's IP address and compare
 329         ** each of them against the server's IP address */
 330
 331         myAddr = cm_IPAddr[i];
 332         if ( IN_CLASSA(myAddr) )
 333             netMask = IN_CLASSA_NET;
 334         else if ( IN_CLASSB(myAddr) )
 335             netMask = IN_CLASSB_NET;
 336         else if ( IN_CLASSC(myAddr) )
 337             netMask = IN_CLASSC_NET;
 338         else
 339             netMask = 0;
 340
 341         myNet    =  myAddr & netMask;
 342         mySubnet =  myAddr & cm_SubnetMask[i];
 343
 344         if ( (serverAddr & netMask) == myNet )
 345         {
 346             if ( (serverAddr & cm_SubnetMask[i]) == mySubnet)
 347             {
 348                 if ( serverAddr == myAddr )
 349                     serverp->ipRank = min(serverp->ipRank,
 350                                            CM_IPRANK_TOP);/* same machine */
 351                 else serverp->ipRank = min(serverp->ipRank,
 352                                             CM_IPRANK_HI); /* same subnet */
 353             }
 354             else serverp->ipRank = min(serverp->ipRank,CM_IPRANK_MED);
 355             /* same net */
 356         }
 357         /* random between 0..15*/
 358         serverp->ipRank += min(serverp->ipRank, rand() % 0x000f);
 359     } /* and of for loop */
 360 }
 361
 362 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp) {
 363     cm_server_t *tsp;
 364
 365     osi_assertx(socketp->sin_family == AF_INET, "unexpected socket family");
 366
 367     tsp = malloc(sizeof(*tsp));
 368     if (tsp) {
 369         memset(tsp, 0, sizeof(*tsp));
 370         tsp->type = type;
 371         tsp->cellp = cellp;
 372         tsp->refCount = 1;
 373         lock_InitializeMutex(&tsp->mx, "cm_server_t mutex");
 374         tsp->addr = *socketp;
 375         tsp->flags = CM_SERVERFLAG_DOWN;        /* assume down; ping will mark up if available */
 376
 377         cm_SetServerPrefs(tsp);
 378
 379         lock_ObtainWrite(&cm_serverLock);       /* get server lock */
 380         tsp->allNextp = cm_allServersp;
 381         cm_allServersp = tsp;
 382         lock_ReleaseWrite(&cm_serverLock);      /* release server lock */
 383
 384         cm_PingServer(tsp);                     /* Obtain Capabilities and check up/down state */
 385     }
 386     return tsp;
 387 }
 388
 389 cm_server_t *
 390 cm_FindServerByIP(afs_uint32 ipaddr, int type)
 391 {
 392     cm_server_t *tsp;
 393
 394     lock_ObtainRead(&cm_serverLock);
 395     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
 396         if (tsp->type == type &&
 397             tsp->addr.sin_addr.S_un.S_addr == ipaddr)
 398             break;
 399     }
 400     lock_ReleaseRead(&cm_serverLock);
 401
 402     return tsp;
 403 }
 404
 405 /* find a server based on its properties */
 406 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
 407 {
 408     cm_server_t *tsp;
 409
 410     osi_assertx(addrp->sin_family == AF_INET, "unexpected socket value");
 411
 412     lock_ObtainWrite(&cm_serverLock);
 413     for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
 414         if (tsp->type == type &&
 415             tsp->addr.sin_addr.s_addr == addrp->sin_addr.s_addr)
 416             break;
 417     }
 418
 419     /* bump ref count if we found the server */
 420     if (tsp)
 421         cm_GetServerNoLock(tsp);
 422
 423     /* drop big table lock */
 424     lock_ReleaseWrite(&cm_serverLock);
 425
 426     /* return what we found */
 427     return tsp;
 428 }
 429
 430 cm_server_vols_t *cm_NewServerVols(void) {
 431     cm_server_vols_t *tsvp;
 432
 433     tsvp = malloc(sizeof(*tsvp));
 434     if (tsvp)
 435         memset(tsvp, 0, sizeof(*tsvp));
 436
 437     return tsvp;
 438 }
 439
 440 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp, afs_uint32 volID)
 441 {
 442     cm_serverRef_t *tsrp;
 443     cm_server_vols_t **tsrvpp = NULL;
 444     afs_uint32 *slotp = NULL;
 445     int found = 0;
 446
 447     cm_GetServer(serverp);
 448     tsrp = malloc(sizeof(*tsrp));
 449     tsrp->server = serverp;
 450     tsrp->status = srv_not_busy;
 451     tsrp->next = NULL;
 452     tsrp->volID = volID;
 453     tsrp->refCount = 1;
 454
 455     /* if we have a non-zero volID, we need to add it to the list
 456      * of volumes maintained by the server.  There are two phases:
 457      * (1) see if the volID is already in the list and (2) insert
 458      * it into the first empty slot if it is not.
 459      */
 460     if (volID) {
 461         lock_ObtainMutex(&serverp->mx);
 462
 463         tsrvpp = &serverp->vols;
 464         while (*tsrvpp) {
 465             int i;
 466
 467             for (i=0; i<NUM_SERVER_VOLS; i++) {
 468                 if ((*tsrvpp)->ids[i] == volID) {
 469                     found = 1;
 470                     break;
 471                 } else if (!slotp && (*tsrvpp)->ids[i] == 0) {
 472                     slotp = &(*tsrvpp)->ids[i];
 473                 }
 474             }
 475
 476             if (found)
 477                 break;
 478
 479             tsrvpp = &(*tsrvpp)->nextp;
 480         }
 481
 482         if (!found) {
 483             if (slotp) {
 484                 *slotp = volID;
 485             } else {
 486                 /* if we didn't find an empty slot in a current
 487                  * page we must need a new page */
 488                 *tsrvpp = cm_NewServerVols();
 489                 if (*tsrvpp)
 490                     (*tsrvpp)->ids[0] = volID;
 491             }
 492         }
 493
 494         lock_ReleaseMutex(&serverp->mx);
 495     }
 496
 497     return tsrp;
 498 }
 499
 500 LONG_PTR cm_ChecksumServerList(cm_serverRef_t *serversp)
 501 {
 502     LONG_PTR sum = 0;
 503     int first = 1;
 504     cm_serverRef_t *tsrp;
 505
 506     lock_ObtainWrite(&cm_serverLock);
 507     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
 508         if (first)
 509             first = 0;
 510         else
 511             sum <<= 1;
 512         sum ^= (LONG_PTR) tsrp->server;
 513     }
 514
 515     lock_ReleaseWrite(&cm_serverLock);
 516     return sum;
 517 }
 518
 519 /*
 520 ** Insert a server into the server list keeping the list sorted in
 521 ** asending order of ipRank.
 522 **
 523 ** The refCount of the cm_serverRef_t is increased
 524 */
 525 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
 526 {
 527     cm_serverRef_t      *current=*list;
 528     unsigned short ipRank = element->server->ipRank;
 529
 530     lock_ObtainWrite(&cm_serverLock);
 531     element->refCount++;                /* increase refCount */
 532
 533     /* insertion into empty list  or at the beginning of the list */
 534     if ( !current || (current->server->ipRank > ipRank) )
 535     {
 536         element->next = *list;
 537         *list = element;
 538         lock_ReleaseWrite(&cm_serverLock);
 539         return ;
 540     }
 541
 542     while ( current->next ) /* find appropriate place to insert */
 543     {
 544         if ( current->next->server->ipRank > ipRank )
 545             break;
 546         else current = current->next;
 547     }
 548     element->next = current->next;
 549     current->next = element;
 550     lock_ReleaseWrite(&cm_serverLock);
 551 }
 552 /*
 553 ** Re-sort the server list with the modified rank
 554 ** returns 0 if element was changed successfully.
 555 ** returns 1 if  list remained unchanged.
 556 */
 557 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t*    server)
 558 {
 559     cm_serverRef_t  **current=list;
 560     cm_serverRef_t      *element=0;
 561
 562     /* if there is max of one element in the list, nothing to sort */
 563     if ( (!*current) || !((*current)->next)  )
 564         return 1;               /* list unchanged: return success */
 565
 566     lock_ObtainWrite(&cm_serverLock);
 567     /* if the server is on the list, delete it from list */
 568     while ( *current )
 569     {
 570         if ( (*current)->server == server)
 571         {
 572             element = (*current);
 573             *current = (*current)->next; /* delete it */
 574             break;
 575         }
 576         current = & ( (*current)->next);
 577     }
 578     lock_ReleaseWrite(&cm_serverLock);
 579
 580     /* if this volume is not replicated on this server  */
 581     if (!element)
 582         return 1;       /* server is not on list */
 583
 584     /* re-insert deleted element into the list with modified rank*/
 585     cm_InsertServerList(list, element);
 586
 587     /* reduce refCount which was increased by cm_InsertServerList */
 588     lock_ObtainWrite(&cm_serverLock);
 589     element->refCount--;
 590     lock_ReleaseWrite(&cm_serverLock);
 591     return 0;
 592 }
 593 /*
 594 ** If there are more than one server on the list and the first n servers on
 595 ** the list have the same rank( n>1), then randomise among the first n servers.
 596 */
 597 void cm_RandomizeServer(cm_serverRef_t** list)
 598 {
 599     int                 count, picked;
 600     cm_serverRef_t*     tsrp = *list, *lastTsrp;
 601     unsigned short      lowestRank;
 602
 603     /* an empty list or a list with only one element */
 604     if ( !tsrp || ! tsrp->next )
 605         return ;
 606
 607     lock_ObtainWrite(&cm_serverLock);
 608
 609     /* count the number of servers with the lowest rank */
 610     lowestRank = tsrp->server->ipRank;
 611     for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
 612     {
 613         if ( tsrp->server->ipRank != lowestRank)
 614             break;
 615         else
 616             count++;
 617     }
 618
 619     /* if there is only one server with the lowest rank, we are done */
 620     if ( count <= 1 ) {
 621         lock_ReleaseWrite(&cm_serverLock);
 622         return ;
 623     }
 624
 625     picked = rand() % count;
 626     if ( !picked ) {
 627         lock_ReleaseWrite(&cm_serverLock);
 628         return ;
 629     }
 630
 631     tsrp = *list;
 632     while (--picked >= 0)
 633     {
 634         lastTsrp = tsrp;
 635         tsrp = tsrp->next;
 636     }
 637     lastTsrp->next = tsrp->next;  /* delete random element from list*/
 638     tsrp->next     = *list; /* insert element at the beginning of list */
 639     *list          = tsrp;
 640     lock_ReleaseWrite(&cm_serverLock);
 641 }
 642
 643 /* call cm_FreeServer while holding a write lock on cm_serverLock */
 644 void cm_FreeServer(cm_server_t* serverp)
 645 {
 646     cm_server_vols_t * tsrvp, *nextp;
 647
 648     cm_PutServerNoLock(serverp);
 649     if (serverp->refCount == 0)
 650     {
 651         /* we need to check to ensure that all of the connections
 652          * for this server have a 0 refCount; otherwise, they will
 653          * not be garbage collected
 654          */
 655         cm_GCConnections(serverp);  /* connsp */
 656
 657         if (!(serverp->flags & CM_SERVERFLAG_PREF_SET)) {
 658             lock_FinalizeMutex(&serverp->mx);
 659             if ( cm_allServersp == serverp )
 660                 cm_allServersp = serverp->allNextp;
 661             else {
 662                 cm_server_t *tsp;
 663
 664                 for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
 665                     if ( tsp->allNextp == serverp ) {
 666                         tsp->allNextp = serverp->allNextp;
 667                         break;
 668                     }
 669                 }
 670             }
 671
 672             /* free the volid list */
 673             for ( tsrvp = serverp->vols; tsrvp; tsrvp = nextp) {
 674                 nextp = tsrvp->nextp;
 675                 free(tsrvp);
 676             }
 677
 678             free(serverp);
 679         }
 680     }
 681 }
 682
 683 void cm_RemoveVolumeFromServer(cm_server_t * serverp, afs_uint32 volID)
 684 {
 685     cm_server_vols_t * tsrvp;
 686     int i;
 687
 688     if (volID == 0)
 689         return;
 690
 691     for (tsrvp = serverp->vols; tsrvp; tsrvp = tsrvp->nextp) {
 692         for (i=0; i<NUM_SERVER_VOLS; i++) {
 693             if (tsrvp->ids[i] == volID) {
 694                 tsrvp->ids[i] = 0;;
 695                 break;
 696             }
 697         }
 698     }
 699 }
 700
 701 void cm_FreeServerList(cm_serverRef_t** list, afs_uint32 flags)
 702 {
 703     cm_serverRef_t  **current = list;
 704     cm_serverRef_t  **nextp = 0;
 705     cm_serverRef_t  * next = 0;
 706
 707     lock_ObtainWrite(&cm_serverLock);
 708
 709     while (*current)
 710     {
 711         nextp = &(*current)->next;
 712         if (--((*current)->refCount) == 0) {
 713             next = *nextp;
 714
 715             if ((*current)->volID)
 716                 cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
 717             cm_FreeServer((*current)->server);
 718             free(*current);
 719             *current = next;
 720         } else {
 721             if (flags & CM_FREESERVERLIST_DELETE) {
 722                 (*current)->status = srv_deleted;
 723                 if ((*current)->volID)
 724                     cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
 725             }
 726             current = nextp;
 727         }
 728     }
 729
 730     lock_ReleaseWrite(&cm_serverLock);
 731 }