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