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, maxconns;
 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     maxconns = max(cm_numFileServers,cm_numVldbServers);
 293     conns = (cm_conn_t **)malloc(maxconns * sizeof(cm_conn_t *));
 294     rxconns = (struct rx_connection **)malloc(maxconns * sizeof(struct rx_connection *));
 295     conntimer = (afs_int32 *)malloc(maxconns * sizeof (afs_int32));
 296     deltas = (time_t *)malloc(maxconns * sizeof (time_t));
 297     results = (afs_int32 *)malloc(maxconns * sizeof (afs_int32));
 298     serversp = (cm_server_t **)malloc(maxconns * sizeof(cm_server_t *));
 299     caps = (Capabilities *)malloc(maxconns * sizeof(Capabilities));
 300
 301     memset(caps, 0, maxconns * 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 && nconns < maxconns; tsp = tsp->allNextp, nconns++) {
 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         lock_ReleaseRead(&cm_serverLock);
 345
 346         if (nconns) {
 347             /* Perform the multi call */
 348             start = time(NULL);
 349             multi_Rx(rxconns,nconns)
 350             {
 351                 multi_RXAFS_GetCapabilities(&caps[multi_i]);
 352                 results[multi_i]=multi_error;
 353             } multi_End;
 354         }
 355
 356         /* Process results of servers that support RXAFS_GetCapabilities */
 357         for (i=0; i<nconns; i++) {
 358             /* Leave the servers that did not support GetCapabilities alone */
 359             if (results[i] == RXGEN_OPCODE)
 360                 continue;
 361
 362             if (conntimer[i])
 363                 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
 364             rx_PutConnection(rxconns[i]);
 365             cm_PutConn(conns[i]);
 366
 367             tsp = serversp[i];
 368             cm_GCConnections(tsp);
 369
 370             lock_ObtainMutex(&tsp->mx);
 371             wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
 372
 373             if (results[i] >= 0)  {
 374                 /* mark server as up */
 375                 tsp->flags &= ~CM_SERVERFLAG_DOWN;
 376                 tsp->downTime = 0;
 377
 378                 /* we currently handle 32-bits of capabilities */
 379                 if (caps[i].Capabilities_len > 0) {
 380                     tsp->capabilities = caps[i].Capabilities_val[0];
 381                     free(caps[i].Capabilities_val);
 382                     caps[i].Capabilities_len = 0;
 383                     caps[i].Capabilities_val = 0;
 384                 } else {
 385                     tsp->capabilities = 0;
 386                 }
 387
 388                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
 389                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
 390                           osi_LogSaveString(afsd_logp, hoststr),
 391                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 392                           tsp->capabilities);
 393
 394                 /* Now update the volume status if necessary */
 395                 if (wasDown) {
 396                     cm_server_vols_t * tsrvp;
 397                     cm_volume_t * volp;
 398                     int i;
 399
 400                     for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
 401                         for (i=0; i<NUM_SERVER_VOLS; i++) {
 402                             if (tsrvp->ids[i] != 0) {
 403                                 cm_InitReq(&req);
 404
 405                                 lock_ReleaseMutex(&tsp->mx);
 406                                 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
 407                                                          &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
 408                                 lock_ObtainMutex(&tsp->mx);
 409                                 if (code == 0) {
 410                                     cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
 411                                     cm_PutVolume(volp);
 412                                 }
 413                             }
 414                         }
 415                     }
 416                 }
 417             } else {
 418                 /* mark server as down */
 419                 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
 420                     tsp->flags |= CM_SERVERFLAG_DOWN;
 421                     tsp->downTime = time(NULL);
 422                 }
 423                 if (code != VRESTARTING) {
 424                     lock_ReleaseMutex(&tsp->mx);
 425                     cm_ForceNewConnections(tsp);
 426                     lock_ObtainMutex(&tsp->mx);
 427                 }
 428                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
 429                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
 430                           osi_LogSaveString(afsd_logp, hoststr),
 431                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 432                           tsp->capabilities);
 433
 434                 /* Now update the volume status if necessary */
 435                 if (!wasDown) {
 436                     cm_server_vols_t * tsrvp;
 437                     cm_volume_t * volp;
 438                     int i;
 439
 440                     for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
 441                         for (i=0; i<NUM_SERVER_VOLS; i++) {
 442                             if (tsrvp->ids[i] != 0) {
 443                                 cm_InitReq(&req);
 444
 445                                 lock_ReleaseMutex(&tsp->mx);
 446                                 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
 447                                                          &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
 448                                 lock_ObtainMutex(&tsp->mx);
 449                                 if (code == 0) {
 450                                     cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
 451                                     cm_PutVolume(volp);
 452                                 }
 453                             }
 454                         }
 455                     }
 456                 }
 457             }
 458
 459             if (tsp->waitCount == 0)
 460                 tsp->flags &= ~CM_SERVERFLAG_PINGING;
 461             else
 462                 osi_Wakeup((LONG_PTR)tsp);
 463
 464             lock_ReleaseMutex(&tsp->mx);
 465
 466             cm_PutServer(tsp);
 467         }
 468
 469         /*
 470          * At this point we have handled any responses that did not indicate
 471          * that RXAFS_GetCapabilities is not supported.
 472          */
 473         for ( i=0, j=0; i<nconns; i++) {
 474             if (results[i] == RXGEN_OPCODE) {
 475                 if (i != j) {
 476                     conns[j] = conns[i];
 477                     rxconns[j] = rxconns[i];
 478                     serversp[j] = serversp[i];
 479                 }
 480                 j++;
 481             }
 482         }
 483         nconns = j;
 484
 485         if (nconns) {
 486             /* Perform the multi call */
 487             start = time(NULL);
 488             multi_Rx(rxconns,nconns)
 489             {
 490                 secs = usecs = 0;
 491                 multi_RXAFS_GetTime(&secs, &usecs);
 492                 end = time(NULL);
 493                 results[multi_i]=multi_error;
 494                 if ((start == end) && !multi_error)
 495                     deltas[multi_i] = end - secs;
 496             } multi_End;
 497         }
 498
 499         /* Process Results of servers that only support RXAFS_GetTime */
 500         for (i=0; i<nconns; i++) {
 501             /* Leave the servers that did not support GetCapabilities alone */
 502             if (conntimer[i])
 503                 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
 504             rx_PutConnection(rxconns[i]);
 505             cm_PutConn(conns[i]);
 506
 507             tsp = serversp[i];
 508             cm_GCConnections(tsp);
 509
 510             lock_ObtainMutex(&tsp->mx);
 511             wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
 512
 513             if (results[i] >= 0)  {
 514                 /* mark server as up */
 515                 tsp->flags &= ~CM_SERVERFLAG_DOWN;
 516                 tsp->downTime = 0;
 517                 tsp->capabilities = 0;
 518
 519                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
 520                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
 521                           osi_LogSaveString(afsd_logp, hoststr),
 522                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 523                           tsp->capabilities);
 524
 525                 /* Now update the volume status if necessary */
 526                 if (wasDown) {
 527                     cm_server_vols_t * tsrvp;
 528                     cm_volume_t * volp;
 529                     int i;
 530
 531                     for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
 532                         for (i=0; i<NUM_SERVER_VOLS; i++) {
 533                             if (tsrvp->ids[i] != 0) {
 534                                 cm_InitReq(&req);
 535
 536                                 lock_ReleaseMutex(&tsp->mx);
 537                                 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
 538                                                          &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
 539                                 lock_ObtainMutex(&tsp->mx);
 540                                 if (code == 0) {
 541                                     cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
 542                                     cm_PutVolume(volp);
 543                                 }
 544                             }
 545                         }
 546                     }
 547                 }
 548             } else {
 549                 /* mark server as down */
 550                 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
 551                     tsp->flags |= CM_SERVERFLAG_DOWN;
 552                     tsp->downTime = time(NULL);
 553                 }
 554                 if (code != VRESTARTING) {
 555                     lock_ReleaseMutex(&tsp->mx);
 556                     cm_ForceNewConnections(tsp);
 557                     lock_ObtainMutex(&tsp->mx);
 558                 }
 559                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
 560                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
 561                           osi_LogSaveString(afsd_logp, hoststr),
 562                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 563                           tsp->capabilities);
 564
 565                 /* Now update the volume status if necessary */
 566                 if (!wasDown) {
 567                     cm_server_vols_t * tsrvp;
 568                     cm_volume_t * volp;
 569                     int i;
 570
 571                     for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
 572                         for (i=0; i<NUM_SERVER_VOLS; i++) {
 573                             if (tsrvp->ids[i] != 0) {
 574                                 cm_InitReq(&req);
 575
 576                                 lock_ReleaseMutex(&tsp->mx);
 577                                 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
 578                                                          &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
 579                                 lock_ObtainMutex(&tsp->mx);
 580                                 if (code == 0) {
 581                                     cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
 582                                     cm_PutVolume(volp);
 583                                 }
 584                             }
 585                         }
 586                     }
 587                 }
 588             }
 589
 590             if (tsp->waitCount == 0)
 591                 tsp->flags &= ~CM_SERVERFLAG_PINGING;
 592             else
 593                 osi_Wakeup((LONG_PTR)tsp);
 594
 595             lock_ReleaseMutex(&tsp->mx);
 596
 597             cm_PutServer(tsp);
 598         }
 599     }
 600
 601     if ((flags & CM_FLAG_CHECKVLDBSERVERS) ||
 602         !(flags & (CM_FLAG_CHECKFILESERVERS|CM_FLAG_CHECKVLDBSERVERS)))
 603     {
 604         lock_ObtainRead(&cm_serverLock);
 605         for (nconns=0, tsp = cm_allServersp; tsp && nconns < maxconns; tsp = tsp->allNextp, nconns++) {
 606             if (tsp->type != CM_SERVER_VLDB ||
 607                 tsp->cellp == NULL ||           /* SetPref only */
 608                 cellp && cellp != tsp->cellp)
 609                 continue;
 610
 611             cm_GetServerNoLock(tsp);
 612             lock_ReleaseRead(&cm_serverLock);
 613
 614             lock_ObtainMutex(&tsp->mx);
 615             isDown = tsp->flags & CM_SERVERFLAG_DOWN;
 616
 617             if ((tsp->flags & CM_SERVERFLAG_PINGING) ||
 618                 !((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
 619                    (!isDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
 620                 lock_ReleaseMutex(&tsp->mx);
 621                 lock_ObtainRead(&cm_serverLock);
 622                 cm_PutServerNoLock(tsp);
 623                 continue;
 624             }
 625
 626             tsp->flags |= CM_SERVERFLAG_PINGING;
 627             lock_ReleaseMutex(&tsp->mx);
 628
 629             serversp[nconns] = tsp;
 630             code = cm_ConnByServer(tsp, cm_rootUserp, &conns[nconns]);
 631             if (code) {
 632                 lock_ObtainRead(&cm_serverLock);
 633                 cm_PutServerNoLock(tsp);
 634                 continue;
 635             }
 636             lock_ObtainRead(&cm_serverLock);
 637             rxconns[nconns] = cm_GetRxConn(conns[nconns]);
 638             conntimer[nconns] = (isDown ? 1 : 0);
 639             if (isDown)
 640                 rx_SetConnDeadTime(rxconns[nconns], 10);
 641         }
 642         lock_ReleaseRead(&cm_serverLock);
 643
 644         if (nconns) {
 645             /* Perform the multi call */
 646             start = time(NULL);
 647             multi_Rx(rxconns,nconns)
 648             {
 649                 multi_VL_ProbeServer();
 650                 results[multi_i]=multi_error;
 651             } multi_End;
 652         }
 653
 654         /* Process results of servers that support RXAFS_GetCapabilities */
 655         for (i=0; i<nconns; i++) {
 656             if (conntimer[i])
 657                 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
 658             rx_PutConnection(rxconns[i]);
 659             cm_PutConn(conns[i]);
 660
 661             tsp = serversp[i];
 662             cm_GCConnections(tsp);
 663
 664             lock_ObtainMutex(&tsp->mx);
 665             wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
 666
 667             if (results[i] >= 0)  {
 668                 /* mark server as up */
 669                 tsp->flags &= ~CM_SERVERFLAG_DOWN;
 670                 tsp->downTime = 0;
 671                 tsp->capabilities = 0;
 672
 673                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
 674                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
 675                           osi_LogSaveString(afsd_logp, hoststr),
 676                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 677                           tsp->capabilities);
 678
 679                 /* Now update the volume status if necessary */
 680                 if (wasDown) {
 681                     cm_server_vols_t * tsrvp;
 682                     cm_volume_t * volp;
 683                     int i;
 684
 685                     for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
 686                         for (i=0; i<NUM_SERVER_VOLS; i++) {
 687                             if (tsrvp->ids[i] != 0) {
 688                                 cm_InitReq(&req);
 689
 690                                 lock_ReleaseMutex(&tsp->mx);
 691                                 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
 692                                                          &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
 693                                 lock_ObtainMutex(&tsp->mx);
 694                                 if (code == 0) {
 695                                     cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
 696                                     cm_PutVolume(volp);
 697                                 }
 698                             }
 699                         }
 700                     }
 701                 }
 702             } else {
 703                 /* mark server as down */
 704                 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
 705                     tsp->flags |= CM_SERVERFLAG_DOWN;
 706                     tsp->downTime = time(NULL);
 707                 }
 708                 if (code != VRESTARTING) {
 709                     lock_ReleaseMutex(&tsp->mx);
 710                     cm_ForceNewConnections(tsp);
 711                     lock_ObtainMutex(&tsp->mx);
 712                 }
 713                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
 714                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
 715                           osi_LogSaveString(afsd_logp, hoststr),
 716                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
 717                           tsp->capabilities);
 718
 719                 /* Now update the volume status if necessary */
 720                 if (!wasDown) {
 721                     cm_server_vols_t * tsrvp;
 722                     cm_volume_t * volp;
 723                     int i;
 724
 725                     for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
 726                         for (i=0; i<NUM_SERVER_VOLS; i++) {
 727                             if (tsrvp->ids[i] != 0) {
 728                                 cm_InitReq(&req);
 729
 730                                 lock_ReleaseMutex(&tsp->mx);
 731                                 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
 732                                                          &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
 733                                 lock_ObtainMutex(&tsp->mx);
 734                                 if (code == 0) {
 735                                     cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
 736                                     cm_PutVolume(volp);
 737                                 }
 738                             }
 739                         }
 740                     }
 741                 }
 742             }
 743
 744             if (tsp->waitCount == 0)
 745                 tsp->flags &= ~CM_SERVERFLAG_PINGING;
 746             else
 747                 osi_Wakeup((LONG_PTR)tsp);
 748
 749             lock_ReleaseMutex(&tsp->mx);
 750
 751             cm_PutServer(tsp);
 752         }
 753     }
 754
 755     free(conns);
 756     free(rxconns);
 757     free(conntimer);
 758     free(deltas);
 759     free(results);
 760     free(serversp);
 761     free(caps);
 762 }
 763 #endif /* MULTI_CHECKSERVERS */
 764
 765 void cm_InitServer(void)
 766 {
 767     static osi_once_t once;
 768
 769     if (osi_Once(&once)) {
 770         lock_InitializeRWLock(&cm_serverLock, "cm_serverLock", LOCK_HIERARCHY_SERVER_GLOBAL);
 771         lock_InitializeRWLock(&cm_syscfgLock, "cm_syscfgLock", LOCK_HIERARCHY_SYSCFG_GLOBAL);
 772         osi_EndOnce(&once);
 773     }
 774 }
 775
 776 /* Protected by cm_syscfgLock (rw) */
 777 int cm_noIPAddr;         /* number of client network interfaces */
 778 int cm_IPAddr[CM_MAXINTERFACE_ADDR];    /* client's IP address in host order */
 779 int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
 780 int cm_NetMtu[CM_MAXINTERFACE_ADDR];    /* client's MTU sizes */
 781 int cm_NetFlags[CM_MAXINTERFACE_ADDR];  /* network flags */
 782 int cm_LanAdapterChangeDetected = 1;
 783
 784 void cm_SetLanAdapterChangeDetected(void)
 785 {
 786     lock_ObtainWrite(&cm_syscfgLock);
 787     cm_LanAdapterChangeDetected = 1;
 788     lock_ReleaseWrite(&cm_syscfgLock);
 789 }
 790
 791 void cm_GetServer(cm_server_t *serverp)
 792 {
 793     lock_ObtainRead(&cm_serverLock);
 794     InterlockedIncrement(&serverp->refCount);
 795     lock_ReleaseRead(&cm_serverLock);
 796 }
 797
 798 void cm_GetServerNoLock(cm_server_t *serverp)
 799 {
 800     InterlockedIncrement(&serverp->refCount);
 801 }
 802
 803 void cm_PutServer(cm_server_t *serverp)
 804 {
 805     afs_int32 refCount;
 806     lock_ObtainRead(&cm_serverLock);
 807     refCount = InterlockedDecrement(&serverp->refCount);
 808     osi_assertx(refCount >= 0, "cm_server_t refCount underflow");
 809     lock_ReleaseRead(&cm_serverLock);
 810 }
 811
 812 void cm_PutServerNoLock(cm_server_t *serverp)
 813 {
 814     afs_int32 refCount = InterlockedDecrement(&serverp->refCount);
 815     osi_assertx(refCount >= 0, "cm_server_t refCount underflow");
 816 }
 817
 818 void cm_SetServerNo64Bit(cm_server_t * serverp, int no64bit)
 819 {
 820     lock_ObtainMutex(&serverp->mx);
 821     if (no64bit)
 822         serverp->flags |= CM_SERVERFLAG_NO64BIT;
 823     else
 824         serverp->flags &= ~CM_SERVERFLAG_NO64BIT;
 825     lock_ReleaseMutex(&serverp->mx);
 826 }
 827
 828 void cm_SetServerNoInlineBulk(cm_server_t * serverp, int no)
 829 {
 830     lock_ObtainMutex(&serverp->mx);
 831     if (no)
 832         serverp->flags |= CM_SERVERFLAG_NOINLINEBULK;
 833     else
 834         serverp->flags &= ~CM_SERVERFLAG_NOINLINEBULK;
 835     lock_ReleaseMutex(&serverp->mx);
 836 }
 837
 838 void cm_SetServerPrefs(cm_server_t * serverp)
 839 {
 840     unsigned long       serverAddr;     /* in host byte order */
 841     unsigned long       myAddr, myNet, mySubnet;/* in host byte order */
 842     unsigned long       netMask;
 843     int                 i;
 844     long code;
 845     int writeLock = 0;
 846
 847     lock_ObtainRead(&cm_syscfgLock);
 848     if (cm_LanAdapterChangeDetected) {
 849         lock_ConvertRToW(&cm_syscfgLock);
 850         writeLock = 1;
 851         if (cm_LanAdapterChangeDetected) {
 852             /* get network related info */
 853             cm_noIPAddr = CM_MAXINTERFACE_ADDR;
 854             code = syscfg_GetIFInfo(&cm_noIPAddr,
 855                                      cm_IPAddr, cm_SubnetMask,
 856                                      cm_NetMtu, cm_NetFlags);
 857             cm_LanAdapterChangeDetected = 0;
 858         }
 859         lock_ConvertWToR(&cm_syscfgLock);
 860     }
 861
 862     serverAddr = ntohl(serverp->addr.sin_addr.s_addr);
 863     serverp->ipRank  = CM_IPRANK_LOW;   /* default setings */
 864
 865     for ( i=0; i < cm_noIPAddr; i++)
 866     {
 867         /* loop through all the client's IP address and compare
 868         ** each of them against the server's IP address */
 869
 870         myAddr = cm_IPAddr[i];
 871         if ( IN_CLASSA(myAddr) )
 872             netMask = IN_CLASSA_NET;
 873         else if ( IN_CLASSB(myAddr) )
 874             netMask = IN_CLASSB_NET;
 875         else if ( IN_CLASSC(myAddr) )
 876             netMask = IN_CLASSC_NET;
 877         else
 878             netMask = 0;
 879
 880         myNet    =  myAddr & netMask;
 881         mySubnet =  myAddr & cm_SubnetMask[i];
 882
 883         if ( (serverAddr & netMask) == myNet )
 884         {
 885             if ( (serverAddr & cm_SubnetMask[i]) == mySubnet)
 886             {
 887                 if ( serverAddr == myAddr )
 888                     serverp->ipRank = min(serverp->ipRank,
 889                                            CM_IPRANK_TOP);/* same machine */
 890                 else serverp->ipRank = min(serverp->ipRank,
 891                                             CM_IPRANK_HI); /* same subnet */
 892             }
 893             else serverp->ipRank = min(serverp->ipRank,CM_IPRANK_MED);
 894             /* same net */
 895         }
 896         /* random between 0..15*/
 897         serverp->ipRank += min(serverp->ipRank, rand() % 0x000f);
 898     } /* and of for loop */
 899     lock_ReleaseRead(&cm_syscfgLock);
 900 }
 901
 902 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp, afs_uint32 flags) {
 903     cm_server_t *tsp;
 904
 905     osi_assertx(socketp->sin_family == AF_INET, "unexpected socket family");
 906
 907     tsp = malloc(sizeof(*tsp));
 908     if (tsp) {
 909         memset(tsp, 0, sizeof(*tsp));
 910         tsp->type = type;
 911         tsp->cellp = cellp;
 912         tsp->refCount = 1;
 913         lock_InitializeMutex(&tsp->mx, "cm_server_t mutex", LOCK_HIERARCHY_SERVER);
 914         tsp->addr = *socketp;
 915
 916         cm_SetServerPrefs(tsp);
 917
 918         lock_ObtainWrite(&cm_serverLock);       /* get server lock */
 919         tsp->allNextp = cm_allServersp;
 920         cm_allServersp = tsp;
 921
 922         switch (type) {
 923         case CM_SERVER_VLDB:
 924             cm_numVldbServers++;
 925             break;
 926         case CM_SERVER_FILE:
 927             cm_numFileServers++;
 928             break;
 929         }
 930
 931         lock_ReleaseWrite(&cm_serverLock);      /* release server lock */
 932
 933         if ( !(flags & CM_FLAG_NOPROBE) ) {
 934             tsp->flags = CM_SERVERFLAG_DOWN;    /* assume down; ping will mark up if available */
 935             cm_PingServer(tsp);                 /* Obtain Capabilities and check up/down state */
 936         }
 937     }
 938     return tsp;
 939 }
 940
 941 cm_server_t *
 942 cm_FindServerByIP(afs_uint32 ipaddr, int type)
 943 {
 944     cm_server_t *tsp;
 945
 946     lock_ObtainRead(&cm_serverLock);
 947     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
 948         if (tsp->type == type &&
 949             tsp->addr.sin_addr.S_un.S_addr == ipaddr)
 950             break;
 951     }
 952     lock_ReleaseRead(&cm_serverLock);
 953
 954     return tsp;
 955 }
 956
 957 /* find a server based on its properties */
 958 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
 959 {
 960     cm_server_t *tsp;
 961
 962     osi_assertx(addrp->sin_family == AF_INET, "unexpected socket value");
 963
 964     lock_ObtainRead(&cm_serverLock);
 965     for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
 966         if (tsp->type == type &&
 967             tsp->addr.sin_addr.s_addr == addrp->sin_addr.s_addr)
 968             break;
 969     }
 970
 971     /* bump ref count if we found the server */
 972     if (tsp)
 973         cm_GetServerNoLock(tsp);
 974
 975     /* drop big table lock */
 976     lock_ReleaseRead(&cm_serverLock);
 977
 978     /* return what we found */
 979     return tsp;
 980 }
 981
 982 cm_server_vols_t *cm_NewServerVols(void) {
 983     cm_server_vols_t *tsvp;
 984
 985     tsvp = malloc(sizeof(*tsvp));
 986     if (tsvp)
 987         memset(tsvp, 0, sizeof(*tsvp));
 988
 989     return tsvp;
 990 }
 991
 992 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp, afs_uint32 volID)
 993 {
 994     cm_serverRef_t *tsrp;
 995     cm_server_vols_t **tsrvpp = NULL;
 996     afs_uint32 *slotp = NULL;
 997     int found = 0;
 998
 999     cm_GetServer(serverp);
1000     tsrp = malloc(sizeof(*tsrp));
1001     tsrp->server = serverp;
1002     tsrp->status = srv_not_busy;
1003     tsrp->next = NULL;
1004     tsrp->volID = volID;
1005     tsrp->refCount = 1;
1006
1007     /* if we have a non-zero volID, we need to add it to the list
1008      * of volumes maintained by the server.  There are two phases:
1009      * (1) see if the volID is already in the list and (2) insert
1010      * it into the first empty slot if it is not.
1011      */
1012     if (volID) {
1013         lock_ObtainMutex(&serverp->mx);
1014
1015         tsrvpp = &serverp->vols;
1016         while (*tsrvpp) {
1017             int i;
1018
1019             for (i=0; i<NUM_SERVER_VOLS; i++) {
1020                 if ((*tsrvpp)->ids[i] == volID) {
1021                     found = 1;
1022                     break;
1023                 } else if (!slotp && (*tsrvpp)->ids[i] == 0) {
1024                     slotp = &(*tsrvpp)->ids[i];
1025                 }
1026             }
1027
1028             if (found)
1029                 break;
1030
1031             tsrvpp = &(*tsrvpp)->nextp;
1032         }
1033
1034         if (!found) {
1035             if (slotp) {
1036                 *slotp = volID;
1037             } else {
1038                 /* if we didn't find an empty slot in a current
1039                  * page we must need a new page */
1040                 *tsrvpp = cm_NewServerVols();
1041                 if (*tsrvpp)
1042                     (*tsrvpp)->ids[0] = volID;
1043             }
1044         }
1045
1046         lock_ReleaseMutex(&serverp->mx);
1047     }
1048
1049     return tsrp;
1050 }
1051
1052 LONG_PTR cm_ChecksumServerList(cm_serverRef_t *serversp)
1053 {
1054     LONG_PTR sum = 0;
1055     int first = 1;
1056     cm_serverRef_t *tsrp;
1057
1058     lock_ObtainRead(&cm_serverLock);
1059     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
1060         if (first)
1061             first = 0;
1062         else
1063             sum <<= 1;
1064         sum ^= (LONG_PTR) tsrp->server;
1065     }
1066
1067     lock_ReleaseRead(&cm_serverLock);
1068     return sum;
1069 }
1070
1071 /*
1072 ** Insert a server into the server list keeping the list sorted in
1073 ** ascending order of ipRank.
1074 **
1075 ** The refCount of the cm_serverRef_t is increased
1076 */
1077 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
1078 {
1079     cm_serverRef_t      *current=*list;
1080     unsigned short ipRank = element->server->ipRank;
1081
1082     lock_ObtainWrite(&cm_serverLock);
1083     element->refCount++;                /* increase refCount */
1084
1085     /* insertion into empty list  or at the beginning of the list */
1086     if ( !current || (current->server->ipRank > ipRank) )
1087     {
1088         element->next = *list;
1089         *list = element;
1090         lock_ReleaseWrite(&cm_serverLock);
1091         return ;
1092     }
1093
1094     while ( current->next ) /* find appropriate place to insert */
1095     {
1096         if ( current->next->server->ipRank > ipRank )
1097             break;
1098         else current = current->next;
1099     }
1100     element->next = current->next;
1101     current->next = element;
1102     lock_ReleaseWrite(&cm_serverLock);
1103 }
1104 /*
1105 ** Re-sort the server list with the modified rank
1106 ** returns 0 if element was changed successfully.
1107 ** returns 1 if  list remained unchanged.
1108 */
1109 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t*    server)
1110 {
1111     cm_serverRef_t  **current=list;
1112     cm_serverRef_t      *element=0;
1113
1114     /* if there is max of one element in the list, nothing to sort */
1115     if ( (!*current) || !((*current)->next)  )
1116         return 1;               /* list unchanged: return success */
1117
1118     lock_ObtainWrite(&cm_serverLock);
1119     /* if the server is on the list, delete it from list */
1120     while ( *current )
1121     {
1122         if ( (*current)->server == server)
1123         {
1124             element = (*current);
1125             *current = (*current)->next; /* delete it */
1126             break;
1127         }
1128         current = & ( (*current)->next);
1129     }
1130     lock_ReleaseWrite(&cm_serverLock);
1131
1132     /* if this volume is not replicated on this server  */
1133     if (!element)
1134         return 1;       /* server is not on list */
1135
1136     /* re-insert deleted element into the list with modified rank*/
1137     cm_InsertServerList(list, element);
1138
1139     /* reduce refCount which was increased by cm_InsertServerList */
1140     lock_ObtainWrite(&cm_serverLock);
1141     element->refCount--;
1142     lock_ReleaseWrite(&cm_serverLock);
1143     return 0;
1144 }
1145 /*
1146 ** If there are more than one server on the list and the first n servers on
1147 ** the list have the same rank( n>1), then randomise among the first n servers.
1148 */
1149 void cm_RandomizeServer(cm_serverRef_t** list)
1150 {
1151     int                 count, picked;
1152     cm_serverRef_t*     tsrp = *list, *lastTsrp;
1153     unsigned short      lowestRank;
1154
1155     /* an empty list or a list with only one element */
1156     if ( !tsrp || ! tsrp->next )
1157         return ;
1158
1159     lock_ObtainWrite(&cm_serverLock);
1160
1161     /* count the number of servers with the lowest rank */
1162     lowestRank = tsrp->server->ipRank;
1163     for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
1164     {
1165         if ( tsrp->server->ipRank != lowestRank)
1166             break;
1167         else
1168             count++;
1169     }
1170
1171     /* if there is only one server with the lowest rank, we are done */
1172     if ( count <= 1 ) {
1173         lock_ReleaseWrite(&cm_serverLock);
1174         return ;
1175     }
1176
1177     picked = rand() % count;
1178     if ( !picked ) {
1179         lock_ReleaseWrite(&cm_serverLock);
1180         return ;
1181     }
1182
1183     tsrp = *list;
1184     while (--picked >= 0)
1185     {
1186         lastTsrp = tsrp;
1187         tsrp = tsrp->next;
1188     }
1189     lastTsrp->next = tsrp->next;  /* delete random element from list*/
1190     tsrp->next     = *list; /* insert element at the beginning of list */
1191     *list          = tsrp;
1192     lock_ReleaseWrite(&cm_serverLock);
1193 }
1194
1195 /* call cm_FreeServer while holding a write lock on cm_serverLock */
1196 void cm_FreeServer(cm_server_t* serverp)
1197 {
1198     cm_server_vols_t * tsrvp, *nextp;
1199     int delserver = 0;
1200
1201     cm_PutServerNoLock(serverp);
1202     if (serverp->refCount == 0)
1203     {
1204         /*
1205          * we need to check to ensure that all of the connections
1206          * for this server have a 0 refCount; otherwise, they will
1207          * not be garbage collected
1208          *
1209          * must drop the cm_serverLock because cm_GCConnections
1210          * obtains the cm_connLock and that comes first in the
1211          * lock hierarchy.
1212          */
1213         lock_ReleaseWrite(&cm_serverLock);
1214         cm_GCConnections(serverp);  /* connsp */
1215         lock_ObtainWrite(&cm_serverLock);
1216     }
1217
1218
1219     /*
1220      * Once we have the cm_serverLock locked check to make
1221      * sure the refCount is still zero before removing the
1222      * server entirely.
1223      */
1224     if (serverp->refCount == 0) {
1225         if (!(serverp->flags & CM_SERVERFLAG_PREF_SET)) {
1226             switch (serverp->type) {
1227             case CM_SERVER_VLDB:
1228                 cm_numVldbServers--;
1229                 break;
1230             case CM_SERVER_FILE:
1231                 cm_numFileServers--;
1232                 break;
1233             }
1234
1235             lock_FinalizeMutex(&serverp->mx);
1236             if ( cm_allServersp == serverp )
1237                 cm_allServersp = serverp->allNextp;
1238             else {
1239                 cm_server_t *tsp;
1240
1241                 for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
1242                     if ( tsp->allNextp == serverp ) {
1243                         tsp->allNextp = serverp->allNextp;
1244                         break;
1245                     }
1246                 }
1247             }
1248
1249             /* free the volid list */
1250             for ( tsrvp = serverp->vols; tsrvp; tsrvp = nextp) {
1251                 nextp = tsrvp->nextp;
1252                 free(tsrvp);
1253             }
1254
1255             free(serverp);
1256         }
1257     }
1258 }
1259
1260 void cm_RemoveVolumeFromServer(cm_server_t * serverp, afs_uint32 volID)
1261 {
1262     cm_server_vols_t * tsrvp;
1263     int i;
1264
1265     if (volID == 0)
1266         return;
1267
1268     for (tsrvp = serverp->vols; tsrvp; tsrvp = tsrvp->nextp) {
1269         for (i=0; i<NUM_SERVER_VOLS; i++) {
1270             if (tsrvp->ids[i] == volID) {
1271                 tsrvp->ids[i] = 0;;
1272                 break;
1273             }
1274         }
1275     }
1276 }
1277
1278 void cm_FreeServerList(cm_serverRef_t** list, afs_uint32 flags)
1279 {
1280     cm_serverRef_t  **current = list;
1281     cm_serverRef_t  **nextp = 0;
1282     cm_serverRef_t  * next = 0;
1283
1284     lock_ObtainWrite(&cm_serverLock);
1285
1286     while (*current)
1287     {
1288         nextp = &(*current)->next;
1289         if (--((*current)->refCount) == 0) {
1290             next = *nextp;
1291
1292             if ((*current)->volID)
1293                 cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1294             cm_FreeServer((*current)->server);
1295             free(*current);
1296             *current = next;
1297         } else {
1298             if (flags & CM_FREESERVERLIST_DELETE) {
1299                 (*current)->status = srv_deleted;
1300                 if ((*current)->volID)
1301                     cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1302             }
1303             current = nextp;
1304         }
1305     }
1306
1307     lock_ReleaseWrite(&cm_serverLock);
1308 }