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