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