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