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