windows-afsd-service-20051121
[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 #ifndef DJGPP
14 #include <windows.h>
15 #include <winsock2.h>
16 #include <nb30.h>
17 #else
18 #include <sys/socket.h>
19 #endif /* !DJGPP */
20 #include <stdlib.h>
21 #include <malloc.h>
22 #include <string.h>
23
24 #include <osi.h>
25 #include <rx/rx.h>
26 #include "afsd.h"
27
28 osi_rwlock_t cm_serverLock;
29
30 cm_server_t *cm_allServersp;
31
32 void cm_CheckServers(long flags, cm_cell_t *cellp)
33 {
34     /* ping all file servers, up or down, with unauthenticated connection,
35      * to find out whether we have all our callbacks from the server still.
36      * Also, ping down VLDBs.
37      */
38     cm_server_t *tsp;
39     long code;
40     long secs;
41     long usecs;
42     int doPing;
43     int serverType;
44     int wasDown;
45     cm_conn_t *connp;
46     struct rx_connection * callp;
47
48     lock_ObtainWrite(&cm_serverLock);
49     for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
50         cm_GetServerNoLock(tsp);
51         lock_ReleaseWrite(&cm_serverLock);
52
53         /* now process the server */
54         lock_ObtainMutex(&tsp->mx);
55
56         serverType = tsp->type;
57         doPing = 0;
58         wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
59
60         /* only do the ping if the cell matches the requested cell, or we're
61          * matching all cells (cellp == NULL), and if we've requested to ping
62          * this type of {up, down} servers.
63          */
64         if ((cellp == NULL || cellp == tsp->cellp) &&
65              ((wasDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
66                (!wasDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
67
68             doPing = 1;
69         }       /* we're supposed to check this up/down server */
70         lock_ReleaseMutex(&tsp->mx);
71
72         /* at this point, we've adjusted the server state, so do the ping and
73          * adjust things.
74          */
75         if (doPing) {
76             code = cm_ConnByServer(tsp, cm_rootUserp, &connp);
77             if (code == 0) {
78                 /* now call the appropriate ping call.  Drop the timeout if
79                  * the server is known to be down, so that we don't waste a
80                  * lot of time retiming out down servers.
81                  */
82                 if (wasDown)
83                     rx_SetConnDeadTime(connp->callp, 10);
84                 if (serverType == CM_SERVER_VLDB) {
85                     code = VL_ProbeServer(connp->callp);
86                 }
87                 else {
88                     /* file server */
89                     callp = cm_GetRxConn(connp);
90                     code = RXAFS_GetTime(callp, &secs, &usecs);
91                     rx_PutConnection(callp);
92                 }
93                 if (wasDown)
94                     rx_SetConnDeadTime(connp->callp, ConnDeadtimeout);
95                 cm_PutConn(connp);
96             }   /* got an unauthenticated connection to this server */
97
98             lock_ObtainMutex(&tsp->mx);
99             if (code >= 0) {
100                 /* mark server as up */
101                 tsp->flags &= ~CM_SERVERFLAG_DOWN;
102             }
103             else {
104                 /* mark server as down */
105                 tsp->flags |= CM_SERVERFLAG_DOWN;
106                 if (code != VRESTARTING)
107                     cm_ForceNewConnections(tsp);
108             }
109             lock_ReleaseMutex(&tsp->mx);
110         }
111
112         /* also, run the GC function for connections on all of the
113          * server's connections.
114          */
115         cm_GCConnections(tsp);
116
117         lock_ObtainWrite(&cm_serverLock);
118         cm_PutServerNoLock(tsp);
119     }
120     lock_ReleaseWrite(&cm_serverLock);
121 }       
122
123 void cm_InitServer(void)
124 {
125     static osi_once_t once;
126         
127     if (osi_Once(&once)) {
128         lock_InitializeRWLock(&cm_serverLock, "cm_serverLock");
129         osi_EndOnce(&once);
130     }
131 }
132
133 void cm_GetServer(cm_server_t *serverp)
134 {
135     lock_ObtainWrite(&cm_serverLock);
136     serverp->refCount++;
137     lock_ReleaseWrite(&cm_serverLock);
138 }
139
140 void cm_GetServerNoLock(cm_server_t *serverp)
141 {
142     serverp->refCount++;
143 }
144
145 void cm_PutServer(cm_server_t *serverp)
146 {
147     lock_ObtainWrite(&cm_serverLock);
148     osi_assert(serverp->refCount-- > 0);
149     lock_ReleaseWrite(&cm_serverLock);
150 }
151
152 void cm_PutServerNoLock(cm_server_t *serverp)
153 {
154     osi_assert(serverp->refCount-- > 0);
155 }
156
157 void cm_SetServerPrefs(cm_server_t * serverp)
158 {
159     unsigned long       serverAddr;     /* in host byte order */
160     unsigned long       myAddr, myNet, mySubnet;/* in host byte order */
161     unsigned long       netMask;
162     int                 i;
163
164     int cm_noIPAddr;         /* number of client network interfaces */
165     int cm_IPAddr[CM_MAXINTERFACE_ADDR];    /* client's IP address in host order */
166     int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
167     int cm_NetMtu[CM_MAXINTERFACE_ADDR];    /* client's MTU sizes */
168     int cm_NetFlags[CM_MAXINTERFACE_ADDR];  /* network flags */
169     long code;
170
171     /* get network related info */
172     cm_noIPAddr = CM_MAXINTERFACE_ADDR;
173     code = syscfg_GetIFInfo(&cm_noIPAddr,
174                             cm_IPAddr, cm_SubnetMask,
175                             cm_NetMtu, cm_NetFlags);
176
177     serverAddr = ntohl(serverp->addr.sin_addr.s_addr);
178     serverp->ipRank  = CM_IPRANK_LOW;   /* default setings */
179
180     for ( i=0; i < cm_noIPAddr; i++)
181     {
182         /* loop through all the client's IP address and compare
183         ** each of them against the server's IP address */
184
185         myAddr = cm_IPAddr[i];
186         if ( IN_CLASSA(myAddr) )
187             netMask = IN_CLASSA_NET;
188         else if ( IN_CLASSB(myAddr) )
189             netMask = IN_CLASSB_NET;
190         else if ( IN_CLASSC(myAddr) )
191             netMask = IN_CLASSC_NET;
192         else
193             netMask = 0;
194
195         myNet    =  myAddr & netMask;
196         mySubnet =  myAddr & cm_SubnetMask[i];
197
198         if ( (serverAddr & netMask) == myNet ) 
199         {
200             if ( (serverAddr & cm_SubnetMask[i]) == mySubnet)
201             {
202                 if ( serverAddr == myAddr ) 
203                     serverp->ipRank = min(serverp->ipRank,
204                                            CM_IPRANK_TOP);/* same machine */
205                 else serverp->ipRank = min(serverp->ipRank,
206                                             CM_IPRANK_HI); /* same subnet */
207             }
208             else serverp->ipRank = min(serverp->ipRank,CM_IPRANK_MED);
209             /* same net */
210         }       
211         /* random between 0..15*/
212         serverp->ipRank += min(serverp->ipRank, rand() % 0x000f);
213     } /* and of for loop */
214 }
215
216 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp) {
217     cm_server_t *tsp;
218
219     osi_assert(socketp->sin_family == AF_INET);
220
221     tsp = malloc(sizeof(*tsp));
222     memset(tsp, 0, sizeof(*tsp));
223     tsp->type = type;
224     tsp->cellp = cellp;
225     tsp->refCount = 1;
226     lock_InitializeMutex(&tsp->mx, "cm_server_t mutex");
227     tsp->addr = *socketp;
228
229     cm_SetServerPrefs(tsp); 
230
231     lock_ObtainWrite(&cm_serverLock); /* get server lock */
232     tsp->allNextp = cm_allServersp;
233     cm_allServersp = tsp;
234     lock_ReleaseWrite(&cm_serverLock); /* release server lock */
235
236     return tsp;
237 }
238
239 /* find a server based on its properties */
240 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
241 {
242     cm_server_t *tsp;
243
244     osi_assert(addrp->sin_family == AF_INET);
245         
246     lock_ObtainWrite(&cm_serverLock);
247     for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
248         if (tsp->type == type &&
249             tsp->addr.sin_addr.s_addr == addrp->sin_addr.s_addr) 
250             break;
251     }       
252
253     /* bump ref count if we found the server */
254     if (tsp) 
255         cm_GetServerNoLock(tsp);
256
257     /* drop big table lock */
258     lock_ReleaseWrite(&cm_serverLock);
259         
260     /* return what we found */
261     return tsp;
262 }       
263
264 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp)
265 {
266     cm_serverRef_t *tsrp;
267
268     cm_GetServer(serverp);
269     tsrp = malloc(sizeof(*tsrp));
270     tsrp->server = serverp;
271     tsrp->status = not_busy;
272     tsrp->next = NULL;
273     tsrp->refCount = 1;
274
275     return tsrp;
276 }
277
278 LONG_PTR cm_ChecksumServerList(cm_serverRef_t *serversp)
279 {
280     LONG_PTR sum = 0;
281     int first = 1;
282     cm_serverRef_t *tsrp;
283
284     lock_ObtainWrite(&cm_serverLock);
285     for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
286         if (first)
287             first = 0;
288         else
289             sum <<= 1;
290         sum ^= (LONG_PTR) tsrp->server;
291     }
292
293     lock_ReleaseWrite(&cm_serverLock);
294     return sum;
295 }
296
297 /*
298 ** Insert a server into the server list keeping the list sorted in 
299 ** asending order of ipRank. 
300 ** 
301 ** The refCount of the cm_serverRef_t is increased
302 */
303 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
304 {
305     cm_serverRef_t      *current=*list;
306     unsigned short ipRank = element->server->ipRank;
307
308     lock_ObtainWrite(&cm_serverLock);
309     element->refCount++;                /* increase refCount */
310
311     /* insertion into empty list  or at the beginning of the list */
312     if ( !current || (current->server->ipRank > ipRank) )
313     {
314         element->next = *list;
315         *list = element;
316         lock_ReleaseWrite(&cm_serverLock);
317         return ;        
318     }
319         
320     while ( current->next ) /* find appropriate place to insert */
321     {
322         if ( current->next->server->ipRank > ipRank )
323             break;
324         else current = current->next;
325     }
326     element->next = current->next;
327     current->next = element;
328     lock_ReleaseWrite(&cm_serverLock);
329 }       
330 /*
331 ** Re-sort the server list with the modified rank
332 ** returns 0 if element was changed successfully. 
333 ** returns 1 if  list remained unchanged.
334 */
335 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t*    server)
336 {
337     cm_serverRef_t  **current=list;
338     cm_serverRef_t      *element=0;
339
340     /* if there is max of one element in the list, nothing to sort */
341     if ( (!*current) || !((*current)->next)  )
342         return 1;               /* list unchanged: return success */
343
344     lock_ObtainWrite(&cm_serverLock);
345     /* if the server is on the list, delete it from list */
346     while ( *current )
347     {
348         if ( (*current)->server == server)
349         {
350             element = (*current);
351             *current = (*current)->next; /* delete it */
352             break;
353         }
354         current = & ( (*current)->next);        
355     }
356     lock_ReleaseWrite(&cm_serverLock);
357
358     /* if this volume is not replicated on this server  */
359     if (!element)
360         return 1;       /* server is not on list */
361
362     /* re-insert deleted element into the list with modified rank*/
363     cm_InsertServerList(list, element);
364
365     /* reduce refCount which was increased by cm_InsertServerList */
366     lock_ObtainWrite(&cm_serverLock);
367     element->refCount--;
368     lock_ReleaseWrite(&cm_serverLock);
369     return 0;
370 }
371 /*
372 ** If there are more than one server on the list and the first n servers on 
373 ** the list have the same rank( n>1), then randomise among the first n servers.
374 */
375 void cm_RandomizeServer(cm_serverRef_t** list)
376 {
377     int                 count, picked;
378     cm_serverRef_t*     tsrp = *list, *lastTsrp;
379     unsigned short      lowestRank;
380
381     /* an empty list or a list with only one element */
382     if ( !tsrp || ! tsrp->next )
383         return ; 
384
385     lock_ObtainWrite(&cm_serverLock);
386
387     /* count the number of servers with the lowest rank */
388     lowestRank = tsrp->server->ipRank;
389     for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
390     {
391         if ( tsrp->server->ipRank != lowestRank)
392             break;
393         else
394             count++;
395     }           
396
397     /* if there is only one server with the lowest rank, we are done */
398     if ( count <= 1 ) {
399         lock_ReleaseWrite(&cm_serverLock);
400         return ;
401     }   
402
403     picked = rand() % count;
404     if ( !picked ) {
405         lock_ReleaseWrite(&cm_serverLock);
406         return ;
407     }   
408
409     tsrp = *list;
410     while (--picked >= 0)
411     {
412         lastTsrp = tsrp;
413         tsrp = tsrp->next;
414     }
415     lastTsrp->next = tsrp->next;  /* delete random element from list*/
416     tsrp->next     = *list; /* insert element at the beginning of list */
417     *list          = tsrp;
418     lock_ReleaseWrite(&cm_serverLock);
419 }       
420
421 /* call cm_FreeServer while holding a write lock on cm_serverLock */
422 void cm_FreeServer(cm_server_t* serverp)
423 {
424     cm_PutServerNoLock(serverp);
425     if (serverp->refCount == 0)
426     {
427         /* we need to check to ensure that all of the connections
428          * for this server have a 0 refCount; otherwise, they will
429          * not be garbage collected 
430          */
431         cm_GCConnections(serverp);  /* connsp */
432
433         if (!(serverp->flags & CM_SERVERFLAG_PREF_SET)) {
434             lock_FinalizeMutex(&serverp->mx);
435             if ( cm_allServersp == serverp )
436                 cm_allServersp = serverp->allNextp;
437             else {
438                 cm_server_t *tsp;
439
440                 for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
441                     if ( tsp->allNextp == serverp ) {
442                         tsp->allNextp = serverp->allNextp;
443                         break;
444                     }
445                 }
446             }
447             free(serverp);
448         }
449     }
450 }
451
452 void cm_FreeServerList(cm_serverRef_t** list)
453 {
454     cm_serverRef_t  **current = list;
455     cm_serverRef_t  **nextp = 0;
456     cm_serverRef_t  * next = 0;
457
458     lock_ObtainWrite(&cm_serverLock);
459
460     while (*current)
461     {
462         nextp = &(*current)->next;
463         if (--((*current)->refCount) == 0) {
464             next = *nextp;
465             cm_FreeServer((*current)->server);
466             free(*current);
467             *current = next;
468         } else {
469            current = nextp;
470         }
471     }
472   
473     lock_ReleaseWrite(&cm_serverLock);
474 }
475