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