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