2 * Copyright 2000, International Business Machines Corporation and others.
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
10 #include <afs/param.h>
18 #include <sys/socket.h>
28 osi_rwlock_t cm_serverLock;
30 cm_server_t *cm_allServersp;
33 cm_ForceNewConnectionsAllServers(void)
37 lock_ObtainRead(&cm_serverLock);
38 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
39 cm_GetServerNoLock(tsp);
40 cm_ForceNewConnections(tsp);
41 cm_PutServerNoLock(tsp);
43 lock_ReleaseRead(&cm_serverLock);
47 cm_PingServer(cm_server_t *tsp)
52 struct rx_connection * callp;
55 Capabilities caps = {0, 0};
58 lock_ObtainMutex(&tsp->mx);
59 if (tsp->flags & CM_SERVERFLAG_PINGING) {
61 osi_SleepM((LONG_PTR)tsp, &tsp->mx);
62 lock_ObtainMutex(&tsp->mx);
64 if (tsp->waitCount == 0)
65 tsp->flags &= ~CM_SERVERFLAG_PINGING;
67 osi_Wakeup((LONG_PTR)tsp);
68 lock_ReleaseMutex(&tsp->mx);
71 tsp->flags |= CM_SERVERFLAG_PINGING;
72 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
73 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
74 lock_ReleaseMutex(&tsp->mx);
76 code = cm_ConnByServer(tsp, cm_rootUserp, &connp);
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.
83 osi_Log4(afsd_logp, "cm_PingServer server %s (%s) was %s with caps 0x%x",
84 osi_LogSaveString(afsd_logp, hoststr),
85 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
86 wasDown ? "down" : "up",
90 rx_SetConnDeadTime(connp->callp, 10);
91 if (tsp->type == CM_SERVER_VLDB) {
92 code = VL_ProbeServer(connp->callp);
96 callp = cm_GetRxConn(connp);
97 code = RXAFS_GetCapabilities(callp, &caps);
98 if (code == RXGEN_OPCODE)
99 code = RXAFS_GetTime(callp, &secs, &usecs);
100 rx_PutConnection(callp);
103 rx_SetConnDeadTime(connp->callp, ConnDeadtimeout);
105 } /* got an unauthenticated connection to this server */
107 lock_ObtainMutex(&tsp->mx);
109 /* mark server as up */
110 tsp->flags &= ~CM_SERVERFLAG_DOWN;
112 /* we currently handle 32-bits of capabilities */
113 if (caps.Capabilities_len > 0) {
114 tsp->capabilities = caps.Capabilities_val[0];
115 free(caps.Capabilities_val);
116 caps.Capabilities_len = 0;
117 caps.Capabilities_val = 0;
119 tsp->capabilities = 0;
122 osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is up with caps 0x%x",
123 osi_LogSaveString(afsd_logp, hoststr),
124 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
127 /* mark server as down */
128 tsp->flags |= CM_SERVERFLAG_DOWN;
129 if (code != VRESTARTING)
130 cm_ForceNewConnections(tsp);
132 osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is down with caps 0x%x",
133 osi_LogSaveString(afsd_logp, hoststr),
134 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
138 if (tsp->waitCount == 0)
139 tsp->flags &= ~CM_SERVERFLAG_PINGING;
141 osi_Wakeup((LONG_PTR)tsp);
142 lock_ReleaseMutex(&tsp->mx);
146 void cm_CheckServers(long flags, cm_cell_t *cellp)
148 /* ping all file servers, up or down, with unauthenticated connection,
149 * to find out whether we have all our callbacks from the server still.
150 * Also, ping down VLDBs.
156 lock_ObtainWrite(&cm_serverLock);
157 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
158 cm_GetServerNoLock(tsp);
159 lock_ReleaseWrite(&cm_serverLock);
161 /* now process the server */
162 lock_ObtainMutex(&tsp->mx);
165 isDown = tsp->flags & CM_SERVERFLAG_DOWN;
167 /* only do the ping if the cell matches the requested cell, or we're
168 * matching all cells (cellp == NULL), and if we've requested to ping
169 * this type of {up, down} servers.
171 if ((cellp == NULL || cellp == tsp->cellp) &&
172 ((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
173 (!isDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
175 } /* we're supposed to check this up/down server */
176 lock_ReleaseMutex(&tsp->mx);
178 /* at this point, we've adjusted the server state, so do the ping and
184 /* also, run the GC function for connections on all of the
185 * server's connections.
187 cm_GCConnections(tsp);
189 lock_ObtainWrite(&cm_serverLock);
190 cm_PutServerNoLock(tsp);
192 lock_ReleaseWrite(&cm_serverLock);
195 void cm_InitServer(void)
197 static osi_once_t once;
199 if (osi_Once(&once)) {
200 lock_InitializeRWLock(&cm_serverLock, "cm_serverLock");
205 void cm_GetServer(cm_server_t *serverp)
207 lock_ObtainWrite(&cm_serverLock);
209 lock_ReleaseWrite(&cm_serverLock);
212 void cm_GetServerNoLock(cm_server_t *serverp)
217 void cm_PutServer(cm_server_t *serverp)
219 lock_ObtainWrite(&cm_serverLock);
220 osi_assert(serverp->refCount-- > 0);
221 lock_ReleaseWrite(&cm_serverLock);
224 void cm_PutServerNoLock(cm_server_t *serverp)
226 osi_assert(serverp->refCount-- > 0);
229 void cm_SetServerNo64Bit(cm_server_t * serverp, int no64bit)
231 lock_ObtainMutex(&serverp->mx);
233 serverp->flags |= CM_SERVERFLAG_NO64BIT;
235 serverp->flags &= ~CM_SERVERFLAG_NO64BIT;
236 lock_ReleaseMutex(&serverp->mx);
239 void cm_SetServerNoInlineBulk(cm_server_t * serverp, int no)
241 lock_ObtainMutex(&serverp->mx);
243 serverp->flags |= CM_SERVERFLAG_NOINLINEBULK;
245 serverp->flags &= ~CM_SERVERFLAG_NOINLINEBULK;
246 lock_ReleaseMutex(&serverp->mx);
249 void cm_SetServerPrefs(cm_server_t * serverp)
251 unsigned long serverAddr; /* in host byte order */
252 unsigned long myAddr, myNet, mySubnet;/* in host byte order */
253 unsigned long netMask;
256 int cm_noIPAddr; /* number of client network interfaces */
257 int cm_IPAddr[CM_MAXINTERFACE_ADDR]; /* client's IP address in host order */
258 int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
259 int cm_NetMtu[CM_MAXINTERFACE_ADDR]; /* client's MTU sizes */
260 int cm_NetFlags[CM_MAXINTERFACE_ADDR]; /* network flags */
263 /* get network related info */
264 cm_noIPAddr = CM_MAXINTERFACE_ADDR;
265 code = syscfg_GetIFInfo(&cm_noIPAddr,
266 cm_IPAddr, cm_SubnetMask,
267 cm_NetMtu, cm_NetFlags);
269 serverAddr = ntohl(serverp->addr.sin_addr.s_addr);
270 serverp->ipRank = CM_IPRANK_LOW; /* default setings */
272 for ( i=0; i < cm_noIPAddr; i++)
274 /* loop through all the client's IP address and compare
275 ** each of them against the server's IP address */
277 myAddr = cm_IPAddr[i];
278 if ( IN_CLASSA(myAddr) )
279 netMask = IN_CLASSA_NET;
280 else if ( IN_CLASSB(myAddr) )
281 netMask = IN_CLASSB_NET;
282 else if ( IN_CLASSC(myAddr) )
283 netMask = IN_CLASSC_NET;
287 myNet = myAddr & netMask;
288 mySubnet = myAddr & cm_SubnetMask[i];
290 if ( (serverAddr & netMask) == myNet )
292 if ( (serverAddr & cm_SubnetMask[i]) == mySubnet)
294 if ( serverAddr == myAddr )
295 serverp->ipRank = min(serverp->ipRank,
296 CM_IPRANK_TOP);/* same machine */
297 else serverp->ipRank = min(serverp->ipRank,
298 CM_IPRANK_HI); /* same subnet */
300 else serverp->ipRank = min(serverp->ipRank,CM_IPRANK_MED);
303 /* random between 0..15*/
304 serverp->ipRank += min(serverp->ipRank, rand() % 0x000f);
305 } /* and of for loop */
308 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp) {
311 osi_assert(socketp->sin_family == AF_INET);
313 tsp = malloc(sizeof(*tsp));
314 memset(tsp, 0, sizeof(*tsp));
318 lock_InitializeMutex(&tsp->mx, "cm_server_t mutex");
319 tsp->addr = *socketp;
320 tsp->flags = CM_SERVERFLAG_DOWN; /* assume down; ping will mark up if available */
322 cm_SetServerPrefs(tsp);
324 lock_ObtainWrite(&cm_serverLock); /* get server lock */
325 tsp->allNextp = cm_allServersp;
326 cm_allServersp = tsp;
327 lock_ReleaseWrite(&cm_serverLock); /* release server lock */
329 cm_PingServer(tsp); /* Obtain Capabilities and check up/down state */
333 /* find a server based on its properties */
334 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
338 osi_assert(addrp->sin_family == AF_INET);
340 lock_ObtainWrite(&cm_serverLock);
341 for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
342 if (tsp->type == type &&
343 tsp->addr.sin_addr.s_addr == addrp->sin_addr.s_addr)
347 /* bump ref count if we found the server */
349 cm_GetServerNoLock(tsp);
351 /* drop big table lock */
352 lock_ReleaseWrite(&cm_serverLock);
354 /* return what we found */
358 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp)
360 cm_serverRef_t *tsrp;
362 cm_GetServer(serverp);
363 tsrp = malloc(sizeof(*tsrp));
364 tsrp->server = serverp;
365 tsrp->status = not_busy;
372 LONG_PTR cm_ChecksumServerList(cm_serverRef_t *serversp)
376 cm_serverRef_t *tsrp;
378 lock_ObtainWrite(&cm_serverLock);
379 for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
384 sum ^= (LONG_PTR) tsrp->server;
387 lock_ReleaseWrite(&cm_serverLock);
392 ** Insert a server into the server list keeping the list sorted in
393 ** asending order of ipRank.
395 ** The refCount of the cm_serverRef_t is increased
397 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
399 cm_serverRef_t *current=*list;
400 unsigned short ipRank = element->server->ipRank;
402 lock_ObtainWrite(&cm_serverLock);
403 element->refCount++; /* increase refCount */
405 /* insertion into empty list or at the beginning of the list */
406 if ( !current || (current->server->ipRank > ipRank) )
408 element->next = *list;
410 lock_ReleaseWrite(&cm_serverLock);
414 while ( current->next ) /* find appropriate place to insert */
416 if ( current->next->server->ipRank > ipRank )
418 else current = current->next;
420 element->next = current->next;
421 current->next = element;
422 lock_ReleaseWrite(&cm_serverLock);
425 ** Re-sort the server list with the modified rank
426 ** returns 0 if element was changed successfully.
427 ** returns 1 if list remained unchanged.
429 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t* server)
431 cm_serverRef_t **current=list;
432 cm_serverRef_t *element=0;
434 /* if there is max of one element in the list, nothing to sort */
435 if ( (!*current) || !((*current)->next) )
436 return 1; /* list unchanged: return success */
438 lock_ObtainWrite(&cm_serverLock);
439 /* if the server is on the list, delete it from list */
442 if ( (*current)->server == server)
444 element = (*current);
445 *current = (*current)->next; /* delete it */
448 current = & ( (*current)->next);
450 lock_ReleaseWrite(&cm_serverLock);
452 /* if this volume is not replicated on this server */
454 return 1; /* server is not on list */
456 /* re-insert deleted element into the list with modified rank*/
457 cm_InsertServerList(list, element);
459 /* reduce refCount which was increased by cm_InsertServerList */
460 lock_ObtainWrite(&cm_serverLock);
462 lock_ReleaseWrite(&cm_serverLock);
466 ** If there are more than one server on the list and the first n servers on
467 ** the list have the same rank( n>1), then randomise among the first n servers.
469 void cm_RandomizeServer(cm_serverRef_t** list)
472 cm_serverRef_t* tsrp = *list, *lastTsrp;
473 unsigned short lowestRank;
475 /* an empty list or a list with only one element */
476 if ( !tsrp || ! tsrp->next )
479 lock_ObtainWrite(&cm_serverLock);
481 /* count the number of servers with the lowest rank */
482 lowestRank = tsrp->server->ipRank;
483 for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
485 if ( tsrp->server->ipRank != lowestRank)
491 /* if there is only one server with the lowest rank, we are done */
493 lock_ReleaseWrite(&cm_serverLock);
497 picked = rand() % count;
499 lock_ReleaseWrite(&cm_serverLock);
504 while (--picked >= 0)
509 lastTsrp->next = tsrp->next; /* delete random element from list*/
510 tsrp->next = *list; /* insert element at the beginning of list */
512 lock_ReleaseWrite(&cm_serverLock);
515 /* call cm_FreeServer while holding a write lock on cm_serverLock */
516 void cm_FreeServer(cm_server_t* serverp)
518 cm_PutServerNoLock(serverp);
519 if (serverp->refCount == 0)
521 /* we need to check to ensure that all of the connections
522 * for this server have a 0 refCount; otherwise, they will
523 * not be garbage collected
525 cm_GCConnections(serverp); /* connsp */
527 if (!(serverp->flags & CM_SERVERFLAG_PREF_SET)) {
528 lock_FinalizeMutex(&serverp->mx);
529 if ( cm_allServersp == serverp )
530 cm_allServersp = serverp->allNextp;
534 for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
535 if ( tsp->allNextp == serverp ) {
536 tsp->allNextp = serverp->allNextp;
546 void cm_FreeServerList(cm_serverRef_t** list)
548 cm_serverRef_t **current = list;
549 cm_serverRef_t **nextp = 0;
550 cm_serverRef_t * next = 0;
552 lock_ObtainWrite(&cm_serverLock);
556 nextp = &(*current)->next;
557 if (--((*current)->refCount) == 0) {
559 cm_FreeServer((*current)->server);
567 lock_ReleaseWrite(&cm_serverLock);