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