545f686e7fb508f3fc0bae85a259f913e91fdae0
[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
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             free(caps.Capabilities_val);
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                     free(caps[i].Capabilities_val);
384                     caps[i].Capabilities_len = 0;
385                     caps[i].Capabilities_val = 0;
386                 } else {
387                     tsp->capabilities = 0;
388                 }
389
390                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
391                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
392                           osi_LogSaveString(afsd_logp, hoststr), 
393                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
394                           tsp->capabilities);
395
396                 /* Now update the volume status if necessary */
397                 if (wasDown) {
398                     cm_server_vols_t * tsrvp;
399                     cm_volume_t * volp;
400                     int i;
401
402                     for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
403                         for (i=0; i<NUM_SERVER_VOLS; i++) {
404                             if (tsrvp->ids[i] != 0) {
405                                 cm_InitReq(&req);
406
407                                 lock_ReleaseMutex(&tsp->mx);
408                                 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
409                                                          &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
410                                 lock_ObtainMutex(&tsp->mx);
411                                 if (code == 0) {
412                                     cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
413                                     cm_PutVolume(volp);
414                                 }
415                             }
416                         }
417                     }
418                 }
419             } else {
420                 /* mark server as down */
421                 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
422                     tsp->flags |= CM_SERVERFLAG_DOWN;
423                     tsp->downTime = time(NULL);
424                 }
425                 if (code != VRESTARTING) {
426                     lock_ReleaseMutex(&tsp->mx);
427                     cm_ForceNewConnections(tsp);
428                     lock_ObtainMutex(&tsp->mx);
429                 }
430                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
431                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
432                           osi_LogSaveString(afsd_logp, hoststr), 
433                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
434                           tsp->capabilities);
435
436                 /* Now update the volume status if necessary */
437                 if (!wasDown) {
438                     cm_server_vols_t * tsrvp;
439                     cm_volume_t * volp;
440                     int i;
441
442                     for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
443                         for (i=0; i<NUM_SERVER_VOLS; i++) {
444                             if (tsrvp->ids[i] != 0) {
445                                 cm_InitReq(&req);
446
447                                 lock_ReleaseMutex(&tsp->mx);
448                                 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
449                                                          &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
450                                 lock_ObtainMutex(&tsp->mx);
451                                 if (code == 0) {
452                                     cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
453                                     cm_PutVolume(volp);
454                                 }
455                             }
456                         }
457                     }
458                 }
459             }
460
461             if (tsp->waitCount == 0)
462                 tsp->flags &= ~CM_SERVERFLAG_PINGING;
463             else 
464                 osi_Wakeup((LONG_PTR)tsp);
465             
466             lock_ReleaseMutex(&tsp->mx);
467
468             cm_PutServer(tsp);
469         }
470
471         /* 
472          * At this point we have handled any responses that did not indicate
473          * that RXAFS_GetCapabilities is not supported.
474          */
475         for ( i=0, j=0; i<nconns; i++) {
476             if (results[i] == RXGEN_OPCODE) {
477                 if (i != j) {
478                     conns[j] = conns[i];
479                     rxconns[j] = rxconns[i];
480                     serversp[j] = serversp[i];
481                 }
482                 j++;
483             }
484         }
485         nconns = j;
486
487         if (nconns) {
488             /* Perform the multi call */
489             start = time(NULL);
490             multi_Rx(rxconns,nconns)
491             {
492                 secs = usecs = 0;
493                 multi_RXAFS_GetTime(&secs, &usecs);
494                 end = time(NULL);
495                 results[multi_i]=multi_error;
496                 if ((start == end) && !multi_error)
497                     deltas[multi_i] = end - secs;
498             } multi_End;
499         }
500
501         /* Process Results of servers that only support RXAFS_GetTime */
502         for (i=0; i<nconns; i++) {
503             /* Leave the servers that did not support GetCapabilities alone */
504             if (conntimer[i])
505                 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
506             rx_PutConnection(rxconns[i]);
507             cm_PutConn(conns[i]);
508
509             tsp = serversp[i];
510             cm_GCConnections(tsp);
511
512             lock_ObtainMutex(&tsp->mx);
513             wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
514
515             if (results[i] >= 0)  {
516                 /* mark server as up */
517                 tsp->flags &= ~CM_SERVERFLAG_DOWN;
518                 tsp->downTime = 0;
519                 tsp->capabilities = 0;
520
521                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
522                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
523                           osi_LogSaveString(afsd_logp, hoststr), 
524                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
525                           tsp->capabilities);
526
527                 /* Now update the volume status if necessary */
528                 if (wasDown) {
529                     cm_server_vols_t * tsrvp;
530                     cm_volume_t * volp;
531                     int i;
532
533                     for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
534                         for (i=0; i<NUM_SERVER_VOLS; i++) {
535                             if (tsrvp->ids[i] != 0) {
536                                 cm_InitReq(&req);
537
538                                 lock_ReleaseMutex(&tsp->mx);
539                                 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
540                                                          &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
541                                 lock_ObtainMutex(&tsp->mx);
542                                 if (code == 0) {
543                                     cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
544                                     cm_PutVolume(volp);
545                                 }
546                             }
547                         }
548                     }
549                 }
550             } else {
551                 /* mark server as down */
552                 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
553                     tsp->flags |= CM_SERVERFLAG_DOWN;
554                     tsp->downTime = time(NULL);
555                 }
556                 if (code != VRESTARTING) {
557                     lock_ReleaseMutex(&tsp->mx);
558                     cm_ForceNewConnections(tsp);
559                     lock_ObtainMutex(&tsp->mx);
560                 }
561                 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
562                 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
563                           osi_LogSaveString(afsd_logp, hoststr), 
564                           tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
565                           tsp->capabilities);
566
567                 /* Now update the volume status if necessary */
568                 if (!wasDown) {
569                     cm_server_vols_t * tsrvp;
570                     cm_volume_t * volp;
571                     int i;
572
573                     for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
574                         for (i=0; i<NUM_SERVER_VOLS; i++) {
575                             if (tsrvp->ids[i] != 0) {
576                                 cm_InitReq(&req);
577
578                                 lock_ReleaseMutex(&tsp->mx);
579                                 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
580                                                          &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
581                                 lock_ObtainMutex(&tsp->mx);
582                                 if (code == 0) {
583                                     cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
584                                     cm_PutVolume(volp);
585                                 }
586                             }
587                         }
588                     }
589                 }
590             }
591
592             if (tsp->waitCount == 0)
593                 tsp->flags &= ~CM_SERVERFLAG_PINGING;
594             else 
595                 osi_Wakeup((LONG_PTR)tsp);
596             
597             lock_ReleaseMutex(&tsp->mx);
598
599             cm_PutServer(tsp);
600         }
601     }
602
603     if ((flags & CM_FLAG_CHECKVLDBSERVERS) || 
604         !(flags & (CM_FLAG_CHECKFILESERVERS|CM_FLAG_CHECKVLDBSERVERS)))
605     {
606         lock_ObtainRead(&cm_serverLock);
607         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 /* find a server based on its properties */
945 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
946 {
947     cm_server_t *tsp;
948
949     osi_assertx(addrp->sin_family == AF_INET, "unexpected socket value");
950         
951     lock_ObtainRead(&cm_serverLock);
952     for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
953         if (tsp->type == type &&
954             tsp->addr.sin_addr.s_addr == addrp->sin_addr.s_addr) 
955             break;
956     }       
957
958     /* bump ref count if we found the server */
959     if (tsp) 
960         cm_GetServerNoLock(tsp);
961
962     /* drop big table lock */
963     lock_ReleaseRead(&cm_serverLock);
964         
965     /* return what we found */
966     return tsp;
967 }       
968
969 cm_server_vols_t *cm_NewServerVols(void) {
970     cm_server_vols_t *tsvp;
971
972     tsvp = malloc(sizeof(*tsvp));
973     if (tsvp)
974         memset(tsvp, 0, sizeof(*tsvp));
975
976     return tsvp;
977 }
978
979 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp, afs_uint32 volID)
980 {
981     cm_serverRef_t *tsrp;
982     cm_server_vols_t **tsrvpp = NULL;
983     afs_uint32 *slotp = NULL;
984     int found = 0;
985
986     cm_GetServer(serverp);
987     tsrp = malloc(sizeof(*tsrp));
988     tsrp->server = serverp;
989     tsrp->status = srv_not_busy;
990     tsrp->next = NULL;
991     tsrp->volID = volID;
992     tsrp->refCount = 1;
993
994     /* if we have a non-zero volID, we need to add it to the list
995      * of volumes maintained by the server.  There are two phases:
996      * (1) see if the volID is already in the list and (2) insert
997      * it into the first empty slot if it is not.
998      */
999     if (volID) {
1000         lock_ObtainMutex(&serverp->mx);
1001
1002         tsrvpp = &serverp->vols;
1003         while (*tsrvpp) {
1004             int i;
1005
1006             for (i=0; i<NUM_SERVER_VOLS; i++) {
1007                 if ((*tsrvpp)->ids[i] == volID) {
1008                     found = 1;
1009                     break;
1010                 } else if (!slotp && (*tsrvpp)->ids[i] == 0) {
1011                     slotp = &(*tsrvpp)->ids[i];
1012                 }
1013             }
1014
1015             if (found)
1016                 break;
1017
1018             tsrvpp = &(*tsrvpp)->nextp;
1019         }
1020
1021         if (!found) {
1022             if (slotp) {
1023                 *slotp = volID;
1024             } else {
1025                 /* if we didn't find an empty slot in a current
1026                  * page we must need a new page */
1027                 *tsrvpp = cm_NewServerVols();
1028                 if (*tsrvpp)
1029                     (*tsrvpp)->ids[0] = volID;
1030             }
1031         }
1032
1033         lock_ReleaseMutex(&serverp->mx);
1034     }
1035
1036     return tsrp;
1037 }
1038
1039 LONG_PTR cm_ChecksumServerList(cm_serverRef_t *serversp)
1040 {
1041     LONG_PTR sum = 0;
1042     int first = 1;
1043     cm_serverRef_t *tsrp;
1044
1045     lock_ObtainRead(&cm_serverLock);
1046     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
1047         if (tsrp->status == srv_deleted)
1048             continue;
1049         if (first)
1050             first = 0;
1051         else
1052             sum <<= 1;
1053         sum ^= (LONG_PTR) tsrp->server;
1054     }
1055
1056     lock_ReleaseRead(&cm_serverLock);
1057     return sum;
1058 }
1059
1060 /*
1061 ** Insert a server into the server list keeping the list sorted in 
1062 ** ascending order of ipRank. 
1063 ** 
1064 ** The refCount of the cm_serverRef_t is increased
1065 */
1066 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
1067 {
1068     cm_serverRef_t      *current=*list;
1069     unsigned short ipRank = element->server->ipRank;
1070
1071     lock_ObtainWrite(&cm_serverLock);
1072     element->refCount++;                /* increase refCount */
1073
1074     /* insertion into empty list  or at the beginning of the list */
1075     if ( !current || (current->server->ipRank > ipRank) )
1076     {
1077         element->next = *list;
1078         *list = element;
1079         lock_ReleaseWrite(&cm_serverLock);
1080         return ;        
1081     }
1082         
1083     while ( current->next ) /* find appropriate place to insert */
1084     {
1085         if ( current->next->server->ipRank > ipRank )
1086             break;
1087         else current = current->next;
1088     }
1089     element->next = current->next;
1090     current->next = element;
1091     lock_ReleaseWrite(&cm_serverLock);
1092 }       
1093 /*
1094 ** Re-sort the server list with the modified rank
1095 ** returns 0 if element was changed successfully. 
1096 ** returns 1 if  list remained unchanged.
1097 */
1098 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t*    server)
1099 {
1100     cm_serverRef_t  **current=list;
1101     cm_serverRef_t      *element=0;
1102
1103     /* if there is max of one element in the list, nothing to sort */
1104     if ( (!*current) || !((*current)->next)  )
1105         return 1;               /* list unchanged: return success */
1106
1107     lock_ObtainWrite(&cm_serverLock);
1108     /* if the server is on the list, delete it from list */
1109     while ( *current )
1110     {
1111         if ( (*current)->server == server)
1112         {
1113             element = (*current);
1114             *current = (*current)->next; /* delete it */
1115             break;
1116         }
1117         current = & ( (*current)->next);        
1118     }
1119     lock_ReleaseWrite(&cm_serverLock);
1120
1121     /* if this volume is not replicated on this server  */
1122     if (!element)
1123         return 1;       /* server is not on list */
1124
1125     /* re-insert deleted element into the list with modified rank*/
1126     cm_InsertServerList(list, element);
1127
1128     /* reduce refCount which was increased by cm_InsertServerList */
1129     lock_ObtainWrite(&cm_serverLock);
1130     element->refCount--;
1131     lock_ReleaseWrite(&cm_serverLock);
1132     return 0;
1133 }
1134 /*
1135 ** If there are more than one server on the list and the first n servers on 
1136 ** the list have the same rank( n>1), then randomise among the first n servers.
1137 */
1138 void cm_RandomizeServer(cm_serverRef_t** list)
1139 {
1140     int                 count, picked;
1141     cm_serverRef_t*     tsrp = *list, *lastTsrp;
1142     unsigned short      lowestRank;
1143
1144     /* an empty list or a list with only one element */
1145     if ( !tsrp || ! tsrp->next )
1146         return ; 
1147
1148     lock_ObtainWrite(&cm_serverLock);
1149
1150     /* count the number of servers with the lowest rank */
1151     lowestRank = tsrp->server->ipRank;
1152     for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
1153     {
1154         if ( tsrp->server->ipRank != lowestRank)
1155             break;
1156         else
1157             count++;
1158     }           
1159
1160     /* if there is only one server with the lowest rank, we are done */
1161     if ( count <= 1 ) {
1162         lock_ReleaseWrite(&cm_serverLock);
1163         return ;
1164     }   
1165
1166     picked = rand() % count;
1167     if ( !picked ) {
1168         lock_ReleaseWrite(&cm_serverLock);
1169         return ;
1170     }   
1171
1172     tsrp = *list;
1173     while (--picked >= 0)
1174     {
1175         lastTsrp = tsrp;
1176         tsrp = tsrp->next;
1177     }
1178     lastTsrp->next = tsrp->next;  /* delete random element from list*/
1179     tsrp->next     = *list; /* insert element at the beginning of list */
1180     *list          = tsrp;
1181     lock_ReleaseWrite(&cm_serverLock);
1182 }       
1183
1184 /* call cm_FreeServer while holding a write lock on cm_serverLock */
1185 void cm_FreeServer(cm_server_t* serverp)
1186 {
1187     cm_server_vols_t * tsrvp, *nextp;
1188     int delserver = 0;
1189
1190     cm_PutServerNoLock(serverp);
1191     if (serverp->refCount == 0)
1192     {
1193         /* 
1194          * we need to check to ensure that all of the connections
1195          * for this server have a 0 refCount; otherwise, they will
1196          * not be garbage collected 
1197          *
1198          * must drop the cm_serverLock because cm_GCConnections
1199          * obtains the cm_connLock and that comes first in the 
1200          * lock hierarchy.  
1201          */
1202         lock_ReleaseWrite(&cm_serverLock);
1203         cm_GCConnections(serverp);  /* connsp */
1204         lock_ObtainWrite(&cm_serverLock);
1205     }
1206
1207
1208     /* 
1209      * Once we have the cm_serverLock locked check to make
1210      * sure the refCount is still zero before removing the 
1211      * server entirely.
1212      */
1213     if (serverp->refCount == 0) {
1214         if (!(serverp->flags & CM_SERVERFLAG_PREF_SET)) {
1215             switch (serverp->type) {
1216             case CM_SERVER_VLDB:
1217                 cm_numVldbServers--;
1218                 break;      
1219             case CM_SERVER_FILE:
1220                 cm_numFileServers--;
1221                 break;
1222             }
1223
1224             lock_FinalizeMutex(&serverp->mx);
1225             if ( cm_allServersp == serverp )
1226                 cm_allServersp = serverp->allNextp;
1227             else {
1228                 cm_server_t *tsp;
1229
1230                 for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
1231                     if ( tsp->allNextp == serverp ) {
1232                         tsp->allNextp = serverp->allNextp;
1233                         break;
1234                     }
1235                 }
1236             }
1237
1238             /* free the volid list */
1239             for ( tsrvp = serverp->vols; tsrvp; tsrvp = nextp) {
1240                 nextp = tsrvp->nextp;
1241                 free(tsrvp);
1242             }
1243
1244             free(serverp);
1245         }
1246     }
1247 }
1248
1249 /* Called with cm_serverLock write locked */
1250 void cm_RemoveVolumeFromServer(cm_server_t * serverp, afs_uint32 volID)
1251 {
1252     cm_server_vols_t * tsrvp;
1253     int i;
1254
1255     if (volID == 0)
1256         return;
1257
1258     for (tsrvp = serverp->vols; tsrvp; tsrvp = tsrvp->nextp) {
1259         for (i=0; i<NUM_SERVER_VOLS; i++) {
1260             if (tsrvp->ids[i] == volID) {
1261                 tsrvp->ids[i] = 0;;
1262                 break;
1263             }
1264         }
1265     }
1266 }
1267
1268 void cm_FreeServerList(cm_serverRef_t** list, afs_uint32 flags)
1269 {
1270     cm_serverRef_t  **current = list;
1271     cm_serverRef_t  **nextp = 0;
1272     cm_serverRef_t  * next = 0;
1273
1274         if (*list == NULL)
1275                 return;
1276
1277     lock_ObtainWrite(&cm_serverLock);
1278
1279     while (*current)
1280     {
1281         nextp = &(*current)->next;
1282         if (--((*current)->refCount) == 0) {
1283             next = *nextp;
1284
1285             if ((*current)->volID)
1286                 cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1287             cm_FreeServer((*current)->server);
1288             free(*current);
1289             *current = next;
1290         } else {
1291             if (flags & CM_FREESERVERLIST_DELETE) {
1292                 (*current)->status = srv_deleted;
1293                 if ((*current)->volID)
1294                     cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1295             }
1296             current = nextp;
1297         }
1298     }
1299   
1300     lock_ReleaseWrite(&cm_serverLock);
1301 }
1302
1303 /* dump all servers to a file. 
1304  * cookie is used to identify this batch for easy parsing, 
1305  * and it a string provided by a caller 
1306  */
1307 int cm_DumpServers(FILE *outputFile, char *cookie, int lock)
1308 {
1309     int zilch;
1310     cm_server_t *tsp;
1311     char output[1024];
1312     char uuidstr[128];
1313     char hoststr[16];
1314
1315     if (lock)
1316         lock_ObtainRead(&cm_serverLock);
1317   
1318     sprintf(output, "%s - dumping servers - cm_numFileServers=%d, cm_numVldbServers=%d\r\n", 
1319             cookie, cm_numFileServers, cm_numVldbServers);
1320     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1321   
1322     for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp)
1323     {
1324         char * type;
1325         char * down;
1326
1327         switch (tsp->type) {
1328         case CM_SERVER_VLDB:
1329             type = "vldb";
1330             break;
1331         case CM_SERVER_FILE:
1332             type = "file";
1333             break;
1334         default:
1335             type = "unknown";
1336         }
1337
1338         afsUUID_to_string(&tsp->uuid, uuidstr, sizeof(uuidstr));
1339         afs_inet_ntoa_r(tsp->addr.sin_addr.s_addr, hoststr);
1340         down = ctime(&tsp->downTime);
1341         down[strlen(down)-1] = '\0';
1342
1343         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",
1344                  cookie, tsp, tsp->cellp ? tsp->cellp->name : "", hoststr, uuidstr, type, 
1345                  tsp->capabilities, tsp->flags, tsp->waitCount, tsp->ipRank, 
1346                  (tsp->flags & CM_SERVERFLAG_DOWN) ?  down : "up",
1347                  tsp->refCount);
1348         WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1349     }
1350     sprintf(output, "%s - Done dumping servers.\r\n", cookie);
1351     WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1352   
1353     if (lock)
1354         lock_ReleaseRead(&cm_serverLock);
1355
1356     return (0);     
1357 }
1358
1359
1360