efefdf5af451fe1f1e6500e32e118ba150fa5457
[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 <osi.h>
23 #include <rx/rx.h>
24
25 osi_rwlock_t cm_serverLock;
26
27 cm_server_t *cm_allServersp;
28
29 void
30 cm_ForceNewConnectionsAllServers(void)
31 {
32     cm_server_t *tsp;
33
34     lock_ObtainWrite(&cm_serverLock);
35     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
36         cm_GetServerNoLock(tsp);
37         cm_ForceNewConnections(tsp);
38         cm_PutServerNoLock(tsp);
39     }
40     lock_ReleaseWrite(&cm_serverLock);
41 }
42
43 void 
44 cm_PingServer(cm_server_t *tsp)
45 {
46     long code;
47     int wasDown = 0;
48     cm_conn_t *connp;
49     struct rx_connection * rxconnp;
50     long secs;
51     long usecs;
52     Capabilities caps = {0, 0};
53     char hoststr[16];
54     cm_req_t req;
55
56     lock_ObtainMutex(&tsp->mx);
57     if (tsp->flags & CM_SERVERFLAG_PINGING) {
58         tsp->waitCount++;
59         osi_SleepM((LONG_PTR)tsp, &tsp->mx);
60         lock_ObtainMutex(&tsp->mx);
61         tsp->waitCount--;
62         if (tsp->waitCount == 0)
63             tsp->flags &= ~CM_SERVERFLAG_PINGING;
64         else 
65             osi_Wakeup((LONG_PTR)tsp);
66         lock_ReleaseMutex(&tsp->mx);
67         return;
68     }
69     tsp->flags |= CM_SERVERFLAG_PINGING;
70     wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
71     afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
72     lock_ReleaseMutex(&tsp->mx);
73
74     code = cm_ConnByServer(tsp, cm_rootUserp, &connp);
75     if (code == 0) {
76         /* now call the appropriate ping call.  Drop the timeout if
77         * the server is known to be down, so that we don't waste a
78         * lot of time retiming out down servers.
79         */
80
81         osi_Log4(afsd_logp, "cm_PingServer server %s (%s) was %s with caps 0x%x",
82                   osi_LogSaveString(afsd_logp, hoststr), 
83                   tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
84                   wasDown ? "down" : "up",
85                   tsp->capabilities);
86
87         rxconnp = cm_GetRxConn(connp);
88         if (wasDown)
89             rx_SetConnDeadTime(rxconnp, 10);
90         if (tsp->type == CM_SERVER_VLDB) {
91             code = VL_ProbeServer(rxconnp);
92         }
93         else {
94             /* file server */
95             code = RXAFS_GetCapabilities(rxconnp, &caps);
96             if (code == RXGEN_OPCODE)
97                 code = RXAFS_GetTime(rxconnp, &secs, &usecs);
98         }
99         if (wasDown)
100             rx_SetConnDeadTime(rxconnp, ConnDeadtimeout);
101         rx_PutConnection(rxconnp);
102         cm_PutConn(connp);
103     }   /* got an unauthenticated connection to this server */
104
105     lock_ObtainMutex(&tsp->mx);
106     if (code >= 0) {
107         /* mark server as up */
108         tsp->flags &= ~CM_SERVERFLAG_DOWN;
109         tsp->downTime = 0;
110
111         /* we currently handle 32-bits of capabilities */
112         if (caps.Capabilities_len > 0) {
113             tsp->capabilities = caps.Capabilities_val[0];
114             free(caps.Capabilities_val);
115             caps.Capabilities_len = 0;
116             caps.Capabilities_val = 0;
117         } else {
118             tsp->capabilities = 0;
119         }
120
121         osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is up with caps 0x%x",
122                   osi_LogSaveString(afsd_logp, hoststr), 
123                   tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
124                   tsp->capabilities);
125
126         /* Now update the volume status if necessary */
127         if (wasDown) {
128             cm_server_vols_t * tsrvp;
129             cm_volume_t * volp;
130             int i;
131
132             for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
133                 for (i=0; i<NUM_SERVER_VOLS; i++) {
134                     if (tsrvp->ids[i] != 0) {
135                         cm_InitReq(&req);
136
137                         lock_ReleaseMutex(&tsp->mx);
138                         code = cm_GetVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
139                                                 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
140                         lock_ObtainMutex(&tsp->mx);
141                         if (code == 0) {
142                             cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
143                             cm_PutVolume(volp);
144                         }
145                     }
146                 }
147             }
148         }
149     } else {
150         /* mark server as down */
151         if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
152             tsp->flags |= CM_SERVERFLAG_DOWN;
153             tsp->downTime = osi_Time();
154         }
155         if (code != VRESTARTING)
156             cm_ForceNewConnections(tsp);
157
158         osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is down with caps 0x%x",
159                   osi_LogSaveString(afsd_logp, hoststr), 
160                   tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
161                   tsp->capabilities);
162
163         /* Now update the volume status if necessary */
164         if (!wasDown) {
165             cm_server_vols_t * tsrvp;
166             cm_volume_t * volp;
167             int i;
168
169             for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
170                 for (i=0; i<NUM_SERVER_VOLS; i++) {
171                     if (tsrvp->ids[i] != 0) {
172                         cm_InitReq(&req);
173
174                         code = cm_GetVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
175                                                 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
176                         if (code == 0) {
177                             cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
178                             cm_PutVolume(volp);
179                         }
180                     }
181                 }
182             }
183         }
184     }
185
186     if (tsp->waitCount == 0)
187         tsp->flags &= ~CM_SERVERFLAG_PINGING;
188     else 
189         osi_Wakeup((LONG_PTR)tsp);
190     lock_ReleaseMutex(&tsp->mx);
191 }
192
193
194 void cm_CheckServers(long flags, cm_cell_t *cellp)
195 {
196     /* ping all file servers, up or down, with unauthenticated connection,
197      * to find out whether we have all our callbacks from the server still.
198      * Also, ping down VLDBs.
199      */
200     cm_server_t *tsp;
201     int doPing;
202     int isDown;
203     int isFS;
204
205     lock_ObtainWrite(&cm_serverLock);
206     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
207         cm_GetServerNoLock(tsp);
208         lock_ReleaseWrite(&cm_serverLock);
209
210         /* now process the server */
211         lock_ObtainMutex(&tsp->mx);
212
213         doPing = 0;
214         isDown = tsp->flags & CM_SERVERFLAG_DOWN;
215         isFS   = tsp->type == CM_SERVER_FILE;
216
217         /* only do the ping if the cell matches the requested cell, or we're
218          * matching all cells (cellp == NULL), and if we've requested to ping
219          * this type of {up, down} servers.
220          */
221         if ((cellp == NULL || cellp == tsp->cellp) &&
222              ((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
223                (!isDown && (flags & CM_FLAG_CHECKUPSERVERS))) &&
224              ((!(flags & CM_FLAG_CHECKVLDBSERVERS) || 
225                !isFS && (flags & CM_FLAG_CHECKVLDBSERVERS)) &&
226               (!(flags & CM_FLAG_CHECKFILESERVERS) || 
227                  isFS && (flags & CM_FLAG_CHECKFILESERVERS)))) {
228             doPing = 1;
229         }       /* we're supposed to check this up/down server */
230         lock_ReleaseMutex(&tsp->mx);
231
232         /* at this point, we've adjusted the server state, so do the ping and
233          * adjust things.
234          */
235         if (doPing) 
236             cm_PingServer(tsp);
237
238         /* also, run the GC function for connections on all of the
239          * server's connections.
240          */
241         cm_GCConnections(tsp);
242
243         lock_ObtainWrite(&cm_serverLock);
244         cm_PutServerNoLock(tsp);
245     }
246     lock_ReleaseWrite(&cm_serverLock);
247 }       
248
249 void cm_InitServer(void)
250 {
251     static osi_once_t once;
252         
253     if (osi_Once(&once)) {
254         lock_InitializeRWLock(&cm_serverLock, "cm_serverLock");
255         osi_EndOnce(&once);
256     }
257 }
258
259 void cm_GetServer(cm_server_t *serverp)
260 {
261     lock_ObtainWrite(&cm_serverLock);
262     serverp->refCount++;
263     lock_ReleaseWrite(&cm_serverLock);
264 }
265
266 void cm_GetServerNoLock(cm_server_t *serverp)
267 {
268     serverp->refCount++;
269 }
270
271 void cm_PutServer(cm_server_t *serverp)
272 {
273     lock_ObtainWrite(&cm_serverLock);
274     osi_assertx(serverp->refCount-- > 0, "cm_server_t refCount 0");
275     lock_ReleaseWrite(&cm_serverLock);
276 }
277
278 void cm_PutServerNoLock(cm_server_t *serverp)
279 {
280     osi_assertx(serverp->refCount-- > 0, "cm_server_t refCount 0");
281 }
282
283 void cm_SetServerNo64Bit(cm_server_t * serverp, int no64bit)
284 {
285     lock_ObtainMutex(&serverp->mx);
286     if (no64bit)
287         serverp->flags |= CM_SERVERFLAG_NO64BIT;
288     else
289         serverp->flags &= ~CM_SERVERFLAG_NO64BIT;
290     lock_ReleaseMutex(&serverp->mx);
291 }
292
293 void cm_SetServerNoInlineBulk(cm_server_t * serverp, int no)
294 {
295     lock_ObtainMutex(&serverp->mx);
296     if (no)
297         serverp->flags |= CM_SERVERFLAG_NOINLINEBULK;
298     else
299         serverp->flags &= ~CM_SERVERFLAG_NOINLINEBULK;
300     lock_ReleaseMutex(&serverp->mx);
301 }
302
303 void cm_SetServerPrefs(cm_server_t * serverp)
304 {
305     unsigned long       serverAddr;     /* in host byte order */
306     unsigned long       myAddr, myNet, mySubnet;/* in host byte order */
307     unsigned long       netMask;
308     int                 i;
309
310     int cm_noIPAddr;         /* number of client network interfaces */
311     int cm_IPAddr[CM_MAXINTERFACE_ADDR];    /* client's IP address in host order */
312     int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
313     int cm_NetMtu[CM_MAXINTERFACE_ADDR];    /* client's MTU sizes */
314     int cm_NetFlags[CM_MAXINTERFACE_ADDR];  /* network flags */
315     long code;
316
317     /* get network related info */
318     cm_noIPAddr = CM_MAXINTERFACE_ADDR;
319     code = syscfg_GetIFInfo(&cm_noIPAddr,
320                             cm_IPAddr, cm_SubnetMask,
321                             cm_NetMtu, cm_NetFlags);
322
323     serverAddr = ntohl(serverp->addr.sin_addr.s_addr);
324     serverp->ipRank  = CM_IPRANK_LOW;   /* default setings */
325
326     for ( i=0; i < cm_noIPAddr; i++)
327     {
328         /* loop through all the client's IP address and compare
329         ** each of them against the server's IP address */
330
331         myAddr = cm_IPAddr[i];
332         if ( IN_CLASSA(myAddr) )
333             netMask = IN_CLASSA_NET;
334         else if ( IN_CLASSB(myAddr) )
335             netMask = IN_CLASSB_NET;
336         else if ( IN_CLASSC(myAddr) )
337             netMask = IN_CLASSC_NET;
338         else
339             netMask = 0;
340
341         myNet    =  myAddr & netMask;
342         mySubnet =  myAddr & cm_SubnetMask[i];
343
344         if ( (serverAddr & netMask) == myNet ) 
345         {
346             if ( (serverAddr & cm_SubnetMask[i]) == mySubnet)
347             {
348                 if ( serverAddr == myAddr ) 
349                     serverp->ipRank = min(serverp->ipRank,
350                                            CM_IPRANK_TOP);/* same machine */
351                 else serverp->ipRank = min(serverp->ipRank,
352                                             CM_IPRANK_HI); /* same subnet */
353             }
354             else serverp->ipRank = min(serverp->ipRank,CM_IPRANK_MED);
355             /* same net */
356         }       
357         /* random between 0..15*/
358         serverp->ipRank += min(serverp->ipRank, rand() % 0x000f);
359     } /* and of for loop */
360 }
361
362 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp) {
363     cm_server_t *tsp;
364
365     osi_assertx(socketp->sin_family == AF_INET, "unexpected socket family");
366
367     tsp = malloc(sizeof(*tsp));
368     if (tsp) {
369         memset(tsp, 0, sizeof(*tsp));
370         tsp->type = type;
371         tsp->cellp = cellp;
372         tsp->refCount = 1;
373         lock_InitializeMutex(&tsp->mx, "cm_server_t mutex");
374         tsp->addr = *socketp;
375         tsp->flags = CM_SERVERFLAG_DOWN;        /* assume down; ping will mark up if available */
376
377         cm_SetServerPrefs(tsp); 
378
379         lock_ObtainWrite(&cm_serverLock);       /* get server lock */
380         tsp->allNextp = cm_allServersp;
381         cm_allServersp = tsp;
382         lock_ReleaseWrite(&cm_serverLock);      /* release server lock */
383
384         cm_PingServer(tsp);                     /* Obtain Capabilities and check up/down state */
385     }
386     return tsp;
387 }
388
389 cm_server_t *
390 cm_FindServerByIP(afs_uint32 ipaddr, int type)
391 {
392     cm_server_t *tsp;
393
394     lock_ObtainRead(&cm_serverLock);
395     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
396         if (tsp->type == type &&
397             tsp->addr.sin_addr.S_un.S_addr == ipaddr)
398             break;
399     }
400     lock_ReleaseRead(&cm_serverLock);
401
402     return tsp;
403 }
404
405 /* find a server based on its properties */
406 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
407 {
408     cm_server_t *tsp;
409
410     osi_assertx(addrp->sin_family == AF_INET, "unexpected socket value");
411         
412     lock_ObtainWrite(&cm_serverLock);
413     for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
414         if (tsp->type == type &&
415             tsp->addr.sin_addr.s_addr == addrp->sin_addr.s_addr) 
416             break;
417     }       
418
419     /* bump ref count if we found the server */
420     if (tsp) 
421         cm_GetServerNoLock(tsp);
422
423     /* drop big table lock */
424     lock_ReleaseWrite(&cm_serverLock);
425         
426     /* return what we found */
427     return tsp;
428 }       
429
430 cm_server_vols_t *cm_NewServerVols(void) {
431     cm_server_vols_t *tsvp;
432
433     tsvp = malloc(sizeof(*tsvp));
434     if (tsvp)
435         memset(tsvp, 0, sizeof(*tsvp));
436
437     return tsvp;
438 }
439
440 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp, afs_uint32 volID)
441 {
442     cm_serverRef_t *tsrp;
443     cm_server_vols_t **tsrvpp = NULL;
444     afs_uint32 *slotp = NULL;
445     int found = 0;
446
447     cm_GetServer(serverp);
448     tsrp = malloc(sizeof(*tsrp));
449     tsrp->server = serverp;
450     tsrp->status = srv_not_busy;
451     tsrp->next = NULL;
452     tsrp->volID = volID;
453     tsrp->refCount = 1;
454
455     /* if we have a non-zero volID, we need to add it to the list
456      * of volumes maintained by the server.  There are two phases:
457      * (1) see if the volID is already in the list and (2) insert
458      * it into the first empty slot if it is not.
459      */
460     if (volID) {
461         lock_ObtainMutex(&serverp->mx);
462
463         tsrvpp = &serverp->vols;
464         while (*tsrvpp) {
465             int i;
466
467             for (i=0; i<NUM_SERVER_VOLS; i++) {
468                 if ((*tsrvpp)->ids[i] == volID) {
469                     found = 1;
470                     break;
471                 } else if (!slotp && (*tsrvpp)->ids[i] == 0) {
472                     slotp = &(*tsrvpp)->ids[i];
473                 }
474             }
475
476             if (found)
477                 break;
478
479             tsrvpp = &(*tsrvpp)->nextp;
480         }
481
482         if (!found) {
483             if (slotp) {
484                 *slotp = volID;
485             } else {
486                 /* if we didn't find an empty slot in a current
487                  * page we must need a new page */
488                 *tsrvpp = cm_NewServerVols();
489                 if (*tsrvpp)
490                     (*tsrvpp)->ids[0] = volID;
491             }
492         }
493
494         lock_ReleaseMutex(&serverp->mx);
495     }
496
497     return tsrp;
498 }
499
500 LONG_PTR cm_ChecksumServerList(cm_serverRef_t *serversp)
501 {
502     LONG_PTR sum = 0;
503     int first = 1;
504     cm_serverRef_t *tsrp;
505
506     lock_ObtainWrite(&cm_serverLock);
507     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
508         if (first)
509             first = 0;
510         else
511             sum <<= 1;
512         sum ^= (LONG_PTR) tsrp->server;
513     }
514
515     lock_ReleaseWrite(&cm_serverLock);
516     return sum;
517 }
518
519 /*
520 ** Insert a server into the server list keeping the list sorted in 
521 ** asending order of ipRank. 
522 ** 
523 ** The refCount of the cm_serverRef_t is increased
524 */
525 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
526 {
527     cm_serverRef_t      *current=*list;
528     unsigned short ipRank = element->server->ipRank;
529
530     lock_ObtainWrite(&cm_serverLock);
531     element->refCount++;                /* increase refCount */
532
533     /* insertion into empty list  or at the beginning of the list */
534     if ( !current || (current->server->ipRank > ipRank) )
535     {
536         element->next = *list;
537         *list = element;
538         lock_ReleaseWrite(&cm_serverLock);
539         return ;        
540     }
541         
542     while ( current->next ) /* find appropriate place to insert */
543     {
544         if ( current->next->server->ipRank > ipRank )
545             break;
546         else current = current->next;
547     }
548     element->next = current->next;
549     current->next = element;
550     lock_ReleaseWrite(&cm_serverLock);
551 }       
552 /*
553 ** Re-sort the server list with the modified rank
554 ** returns 0 if element was changed successfully. 
555 ** returns 1 if  list remained unchanged.
556 */
557 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t*    server)
558 {
559     cm_serverRef_t  **current=list;
560     cm_serverRef_t      *element=0;
561
562     /* if there is max of one element in the list, nothing to sort */
563     if ( (!*current) || !((*current)->next)  )
564         return 1;               /* list unchanged: return success */
565
566     lock_ObtainWrite(&cm_serverLock);
567     /* if the server is on the list, delete it from list */
568     while ( *current )
569     {
570         if ( (*current)->server == server)
571         {
572             element = (*current);
573             *current = (*current)->next; /* delete it */
574             break;
575         }
576         current = & ( (*current)->next);        
577     }
578     lock_ReleaseWrite(&cm_serverLock);
579
580     /* if this volume is not replicated on this server  */
581     if (!element)
582         return 1;       /* server is not on list */
583
584     /* re-insert deleted element into the list with modified rank*/
585     cm_InsertServerList(list, element);
586
587     /* reduce refCount which was increased by cm_InsertServerList */
588     lock_ObtainWrite(&cm_serverLock);
589     element->refCount--;
590     lock_ReleaseWrite(&cm_serverLock);
591     return 0;
592 }
593 /*
594 ** If there are more than one server on the list and the first n servers on 
595 ** the list have the same rank( n>1), then randomise among the first n servers.
596 */
597 void cm_RandomizeServer(cm_serverRef_t** list)
598 {
599     int                 count, picked;
600     cm_serverRef_t*     tsrp = *list, *lastTsrp;
601     unsigned short      lowestRank;
602
603     /* an empty list or a list with only one element */
604     if ( !tsrp || ! tsrp->next )
605         return ; 
606
607     lock_ObtainWrite(&cm_serverLock);
608
609     /* count the number of servers with the lowest rank */
610     lowestRank = tsrp->server->ipRank;
611     for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
612     {
613         if ( tsrp->server->ipRank != lowestRank)
614             break;
615         else
616             count++;
617     }           
618
619     /* if there is only one server with the lowest rank, we are done */
620     if ( count <= 1 ) {
621         lock_ReleaseWrite(&cm_serverLock);
622         return ;
623     }   
624
625     picked = rand() % count;
626     if ( !picked ) {
627         lock_ReleaseWrite(&cm_serverLock);
628         return ;
629     }   
630
631     tsrp = *list;
632     while (--picked >= 0)
633     {
634         lastTsrp = tsrp;
635         tsrp = tsrp->next;
636     }
637     lastTsrp->next = tsrp->next;  /* delete random element from list*/
638     tsrp->next     = *list; /* insert element at the beginning of list */
639     *list          = tsrp;
640     lock_ReleaseWrite(&cm_serverLock);
641 }       
642
643 /* call cm_FreeServer while holding a write lock on cm_serverLock */
644 void cm_FreeServer(cm_server_t* serverp)
645 {
646     cm_server_vols_t * tsrvp, *nextp;
647
648     cm_PutServerNoLock(serverp);
649     if (serverp->refCount == 0)
650     {
651         /* we need to check to ensure that all of the connections
652          * for this server have a 0 refCount; otherwise, they will
653          * not be garbage collected 
654          */
655         cm_GCConnections(serverp);  /* connsp */
656
657         if (!(serverp->flags & CM_SERVERFLAG_PREF_SET)) {
658             lock_FinalizeMutex(&serverp->mx);
659             if ( cm_allServersp == serverp )
660                 cm_allServersp = serverp->allNextp;
661             else {
662                 cm_server_t *tsp;
663
664                 for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
665                     if ( tsp->allNextp == serverp ) {
666                         tsp->allNextp = serverp->allNextp;
667                         break;
668                     }
669                 }
670             }
671
672             /* free the volid list */
673             for ( tsrvp = serverp->vols; tsrvp; tsrvp = nextp) {
674                 nextp = tsrvp->nextp;
675                 free(tsrvp);
676             }
677
678             free(serverp);
679         }
680     }
681 }
682
683 void cm_RemoveVolumeFromServer(cm_server_t * serverp, afs_uint32 volID)
684 {
685     cm_server_vols_t * tsrvp;
686     int i;
687
688     if (volID == 0)
689         return;
690
691     for (tsrvp = serverp->vols; tsrvp; tsrvp = tsrvp->nextp) {
692         for (i=0; i<NUM_SERVER_VOLS; i++) {
693             if (tsrvp->ids[i] == volID) {
694                 tsrvp->ids[i] = 0;;
695                 break;
696             }
697         }
698     }
699 }
700
701 void cm_FreeServerList(cm_serverRef_t** list, afs_uint32 flags)
702 {
703     cm_serverRef_t  **current = list;
704     cm_serverRef_t  **nextp = 0;
705     cm_serverRef_t  * next = 0;
706
707     lock_ObtainWrite(&cm_serverLock);
708
709     while (*current)
710     {
711         nextp = &(*current)->next;
712         if (--((*current)->refCount) == 0) {
713             next = *nextp;
714
715             if ((*current)->volID)
716                 cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
717             cm_FreeServer((*current)->server);
718             free(*current);
719             *current = next;
720         } else {
721             if (flags & CM_FREESERVERLIST_DELETE) {
722                 (*current)->status = srv_deleted;
723                 if ((*current)->volID)
724                     cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
725             }
726             current = nextp;
727         }
728     }
729   
730     lock_ReleaseWrite(&cm_serverLock);
731 }