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