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;
32 void cm_CheckServers(long flags, cm_cell_t *cellp)
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.
47 struct rx_connection * callp;
49 lock_ObtainWrite(&cm_serverLock);
50 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
51 cm_GetServerNoLock(tsp);
52 lock_ReleaseWrite(&cm_serverLock);
54 /* now process the server */
55 lock_ObtainMutex(&tsp->mx);
57 /* what time is it? */
60 serverType = tsp->type;
62 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
64 /* only do the ping if the cell matches the requested cell, or we're
65 * matching all cells (cellp == NULL), and if we've requested to ping
66 * this type of {up, down} servers.
68 if ((cellp == NULL || cellp == tsp->cellp) &&
69 ((wasDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
70 (!wasDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
73 } /* we're supposed to check this up/down server */
74 lock_ReleaseMutex(&tsp->mx);
76 /* at this point, we've adjusted the server state, so do the ping and
80 code = cm_ConnByServer(tsp, cm_rootUserp, &connp);
82 /* now call the appropriate ping call. Drop the timeout if
83 * the server is known to be down, so that we don't waste a
84 * lot of time retiming out down servers.
87 rx_SetConnDeadTime(connp->callp, 10);
88 if (serverType == CM_SERVER_VLDB) {
89 code = VL_ProbeServer(connp->callp);
93 callp = cm_GetRxConn(connp);
94 code = RXAFS_GetTime(callp, &secs, &usecs);
95 rx_PutConnection(callp);
98 rx_SetConnDeadTime(connp->callp, ConnDeadtimeout);
100 } /* got an unauthenticated connection to this server */
102 lock_ObtainMutex(&tsp->mx);
104 /* mark server as up */
105 tsp->flags &= ~CM_SERVERFLAG_DOWN;
108 /* mark server as down */
109 tsp->flags |= CM_SERVERFLAG_DOWN;
111 lock_ReleaseMutex(&tsp->mx);
114 /* also, run the GC function for connections on all of the
115 * server's connections.
117 cm_GCConnections(tsp);
119 lock_ObtainWrite(&cm_serverLock);
120 cm_PutServerNoLock(tsp);
122 lock_ReleaseWrite(&cm_serverLock);
125 void cm_InitServer(void)
127 static osi_once_t once;
129 if (osi_Once(&once)) {
130 lock_InitializeRWLock(&cm_serverLock, "cm_serverLock");
135 void cm_GetServer(cm_server_t *serverp)
137 lock_ObtainWrite(&cm_serverLock);
139 lock_ReleaseWrite(&cm_serverLock);
142 void cm_GetServerNoLock(cm_server_t *serverp)
147 void cm_PutServer(cm_server_t *serverp)
149 lock_ObtainWrite(&cm_serverLock);
150 osi_assert(serverp->refCount-- > 0);
151 lock_ReleaseWrite(&cm_serverLock);
154 void cm_PutServerNoLock(cm_server_t *serverp)
156 osi_assert(serverp->refCount-- > 0);
159 void cm_SetServerPrefs(cm_server_t * serverp)
161 unsigned long serverAddr; /* in host byte order */
162 unsigned long myAddr, myNet, mySubnet;/* in host byte order */
163 unsigned long netMask;
166 /* implement server prefs for fileservers only */
167 if ( serverp->type == CM_SERVER_FILE )
169 int cm_noIPAddr; /* number of client network interfaces */
170 int cm_IPAddr[CM_MAXINTERFACE_ADDR]; /* client's IP address in host order */
171 int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
172 int cm_NetMtu[CM_MAXINTERFACE_ADDR]; /* client's MTU sizes */
173 int cm_NetFlags[CM_MAXINTERFACE_ADDR]; /* network flags */
176 /* get network related info */
177 cm_noIPAddr = CM_MAXINTERFACE_ADDR;
178 code = syscfg_GetIFInfo(&cm_noIPAddr,
179 cm_IPAddr, cm_SubnetMask,
180 cm_NetMtu, cm_NetFlags);
182 serverAddr = ntohl(serverp->addr.sin_addr.s_addr);
183 serverp->ipRank = CM_IPRANK_LOW; /* default setings */
185 for ( i=0; i < cm_noIPAddr; i++)
187 /* loop through all the client's IP address and compare
188 ** each of them against the server's IP address */
190 myAddr = cm_IPAddr[i];
191 if ( IN_CLASSA(myAddr) )
192 netMask = IN_CLASSA_NET;
193 else if ( IN_CLASSB(myAddr) )
194 netMask = IN_CLASSB_NET;
195 else if ( IN_CLASSC(myAddr) )
196 netMask = IN_CLASSC_NET;
200 myNet = myAddr & netMask;
201 mySubnet = myAddr & cm_SubnetMask[i];
203 if ( (serverAddr & netMask) == myNet )
205 if ( (serverAddr & cm_SubnetMask[i]) == mySubnet)
207 if ( serverAddr == myAddr )
208 serverp->ipRank = min(serverp->ipRank,
209 CM_IPRANK_TOP);/* same machine */
210 else serverp->ipRank = min(serverp->ipRank,
211 CM_IPRANK_HI); /* same subnet */
213 else serverp->ipRank = min(serverp->ipRank,CM_IPRANK_MED);
216 /* random between 0..15*/
217 serverp->ipRank += min(serverp->ipRank, rand() % 0x000f);
218 } /* and of for loop */
221 serverp->ipRank = 10000 + (rand() % 0x00ff); /* VL server */
224 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp) {
227 osi_assert(socketp->sin_family == AF_INET);
229 tsp = malloc(sizeof(*tsp));
230 memset(tsp, 0, sizeof(*tsp));
234 lock_InitializeMutex(&tsp->mx, "cm_server_t mutex");
235 tsp->addr = *socketp;
237 cm_SetServerPrefs(tsp);
239 lock_ObtainWrite(&cm_serverLock); /* get server lock */
240 tsp->allNextp = cm_allServersp;
241 cm_allServersp = tsp;
242 lock_ReleaseWrite(&cm_serverLock); /* release server lock */
247 /* find a server based on its properties */
248 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
252 osi_assert(addrp->sin_family == AF_INET);
254 lock_ObtainWrite(&cm_serverLock);
255 for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
256 if (tsp->type == type &&
257 tsp->addr.sin_addr.s_addr == addrp->sin_addr.s_addr)
261 /* bump ref count if we found the server */
263 cm_GetServerNoLock(tsp);
265 /* drop big table lock */
266 lock_ReleaseWrite(&cm_serverLock);
268 /* return what we found */
272 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp)
274 cm_serverRef_t *tsrp;
276 cm_GetServer(serverp);
277 tsrp = malloc(sizeof(*tsrp));
278 tsrp->server = serverp;
279 tsrp->status = not_busy;
286 long cm_ChecksumServerList(cm_serverRef_t *serversp)
290 cm_serverRef_t *tsrp;
292 lock_ObtainWrite(&cm_serverLock);
293 for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
298 sum ^= (long) tsrp->server;
301 lock_ReleaseWrite(&cm_serverLock);
306 ** Insert a server into the server list keeping the list sorted in
307 ** asending order of ipRank.
309 ** The refCount of the cm_serverRef_t is increased
311 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
313 cm_serverRef_t *current=*list;
314 unsigned short ipRank = element->server->ipRank;
316 lock_ObtainWrite(&cm_serverLock);
317 element->refCount++; /* increase refCount */
319 /* insertion into empty list or at the beginning of the list */
320 if ( !current || (current->server->ipRank > ipRank) )
322 element->next = *list;
324 lock_ReleaseWrite(&cm_serverLock);
328 while ( current->next ) /* find appropriate place to insert */
330 if ( current->next->server->ipRank > ipRank )
332 else current = current->next;
334 element->next = current->next;
335 current->next = element;
336 lock_ReleaseWrite(&cm_serverLock);
339 ** Re-sort the server list with the modified rank
340 ** returns 0 if element was changed successfully.
341 ** returns 1 if list remained unchanged.
343 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t* server)
345 cm_serverRef_t **current=list;
346 cm_serverRef_t *element=0;
348 /* if there is max of one element in the list, nothing to sort */
349 if ( (!*current) || !((*current)->next) )
350 return 1; /* list unchanged: return success */
352 lock_ObtainWrite(&cm_serverLock);
353 /* if the server is on the list, delete it from list */
356 if ( (*current)->server == server)
358 element = (*current);
359 *current = (*current)->next; /* delete it */
362 current = & ( (*current)->next);
364 lock_ReleaseWrite(&cm_serverLock);
366 /* if this volume is not replicated on this server */
368 return 1; /* server is not on list */
370 /* re-insert deleted element into the list with modified rank*/
371 cm_InsertServerList(list, element);
373 /* reduce refCount which was increased by cm_InsertServerList */
374 lock_ObtainWrite(&cm_serverLock);
376 lock_ReleaseWrite(&cm_serverLock);
380 ** If there are more than one server on the list and the first n servers on
381 ** the list have the same rank( n>1), then randomise among the first n servers.
383 void cm_RandomizeServer(cm_serverRef_t** list)
386 cm_serverRef_t* tsrp = *list, *lastTsrp;
387 unsigned short lowestRank;
389 /* an empty list or a list with only one element */
390 if ( !tsrp || ! tsrp->next )
393 lock_ObtainWrite(&cm_serverLock);
395 /* count the number of servers with the lowest rank */
396 lowestRank = tsrp->server->ipRank;
397 for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
399 if ( tsrp->server->ipRank != lowestRank)
405 /* if there is only one server with the lowest rank, we are done */
407 lock_ReleaseWrite(&cm_serverLock);
411 picked = rand() % count;
413 lock_ReleaseWrite(&cm_serverLock);
418 while (--picked >= 0)
423 lastTsrp->next = tsrp->next; /* delete random element from list*/
424 tsrp->next = *list; /* insert element at the beginning of list */
426 lock_ReleaseWrite(&cm_serverLock);
429 /* call cm_FreeServer while holding a write lock on cm_serverLock */
430 void cm_FreeServer(cm_server_t* serverp)
432 cm_PutServerNoLock(serverp);
433 if (serverp->refCount == 0)
435 /* we need to check to ensure that all of the connections
436 * for this server have a 0 refCount; otherwise, they will
437 * not be garbage collected
439 cm_GCConnections(serverp); /* connsp */
441 lock_FinalizeMutex(&serverp->mx);
442 if ( cm_allServersp == serverp )
443 cm_allServersp = serverp->allNextp;
447 for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
448 if ( tsp->allNextp == serverp ) {
449 tsp->allNextp = serverp->allNextp;
457 void cm_FreeServerList(cm_serverRef_t** list)
459 cm_serverRef_t **current = list;
460 cm_serverRef_t **nextp = 0;
461 cm_serverRef_t * next = 0;
463 lock_ObtainWrite(&cm_serverLock);
467 nextp = &(*current)->next;
468 if (--((*current)->refCount) == 0) {
470 cm_FreeServer((*current)->server);
478 lock_ReleaseWrite(&cm_serverLock);