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>
21 #include <WINNT\syscfg.h>
25 osi_rwlock_t cm_serverLock;
26 osi_rwlock_t cm_syscfgLock;
28 cm_server_t *cm_allServersp;
29 afs_uint32 cm_numFileServers = 0;
30 afs_uint32 cm_numVldbServers = 0;
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 * rxconnp;
55 Capabilities caps = {0, 0};
59 lock_ObtainMutex(&tsp->mx);
60 if (tsp->flags & CM_SERVERFLAG_PINGING) {
62 osi_SleepM((LONG_PTR)tsp, &tsp->mx);
63 lock_ObtainMutex(&tsp->mx);
65 if (tsp->waitCount == 0)
66 tsp->flags &= ~CM_SERVERFLAG_PINGING;
68 osi_Wakeup((LONG_PTR)tsp);
69 lock_ReleaseMutex(&tsp->mx);
72 tsp->flags |= CM_SERVERFLAG_PINGING;
73 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
74 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
75 lock_ReleaseMutex(&tsp->mx);
77 code = cm_ConnByServer(tsp, cm_rootUserp, &connp);
79 /* now call the appropriate ping call. Drop the timeout if
80 * the server is known to be down, so that we don't waste a
81 * lot of time retiming out down servers.
84 osi_Log4(afsd_logp, "cm_PingServer server %s (%s) was %s with caps 0x%x",
85 osi_LogSaveString(afsd_logp, hoststr),
86 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
87 wasDown ? "down" : "up",
90 rxconnp = cm_GetRxConn(connp);
92 rx_SetConnDeadTime(rxconnp, 10);
93 if (tsp->type == CM_SERVER_VLDB) {
94 code = VL_ProbeServer(rxconnp);
98 code = RXAFS_GetCapabilities(rxconnp, &caps);
99 if (code == RXGEN_OPCODE)
100 code = RXAFS_GetTime(rxconnp, &secs, &usecs);
103 rx_SetConnDeadTime(rxconnp, ConnDeadtimeout);
104 rx_PutConnection(rxconnp);
106 } /* got an unauthenticated connection to this server */
108 lock_ObtainMutex(&tsp->mx);
110 /* mark server as up */
111 tsp->flags &= ~CM_SERVERFLAG_DOWN;
114 /* we currently handle 32-bits of capabilities */
115 if (caps.Capabilities_len > 0) {
116 tsp->capabilities = caps.Capabilities_val[0];
117 free(caps.Capabilities_val);
118 caps.Capabilities_len = 0;
119 caps.Capabilities_val = 0;
121 tsp->capabilities = 0;
124 osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is up with caps 0x%x",
125 osi_LogSaveString(afsd_logp, hoststr),
126 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
129 /* Now update the volume status if necessary */
131 cm_server_vols_t * tsrvp;
135 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
136 for (i=0; i<NUM_SERVER_VOLS; i++) {
137 if (tsrvp->ids[i] != 0) {
140 lock_ReleaseMutex(&tsp->mx);
141 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
142 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
143 lock_ObtainMutex(&tsp->mx);
145 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
153 /* mark server as down */
154 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
155 tsp->flags |= CM_SERVERFLAG_DOWN;
156 tsp->downTime = time(NULL);
158 if (code != VRESTARTING)
159 cm_ForceNewConnections(tsp);
161 osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is down with caps 0x%x",
162 osi_LogSaveString(afsd_logp, hoststr),
163 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
166 /* Now update the volume status if necessary */
168 cm_server_vols_t * tsrvp;
172 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
173 for (i=0; i<NUM_SERVER_VOLS; i++) {
174 if (tsrvp->ids[i] != 0) {
177 lock_ReleaseMutex(&tsp->mx);
178 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
179 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
180 lock_ObtainMutex(&tsp->mx);
182 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
191 if (tsp->waitCount == 0)
192 tsp->flags &= ~CM_SERVERFLAG_PINGING;
194 osi_Wakeup((LONG_PTR)tsp);
195 lock_ReleaseMutex(&tsp->mx);
198 #define MULTI_CHECKSERVERS 1
199 #ifndef MULTI_CHECKSERVERS
200 void cm_CheckServers(afs_uint32 flags, cm_cell_t *cellp)
202 /* ping all file servers, up or down, with unauthenticated connection,
203 * to find out whether we have all our callbacks from the server still.
204 * Also, ping down VLDBs.
211 lock_ObtainRead(&cm_serverLock);
212 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
213 cm_GetServerNoLock(tsp);
214 lock_ReleaseRead(&cm_serverLock);
216 /* now process the server */
217 lock_ObtainMutex(&tsp->mx);
220 isDown = tsp->flags & CM_SERVERFLAG_DOWN;
221 isFS = tsp->type == CM_SERVER_FILE;
223 /* only do the ping if the cell matches the requested cell, or we're
224 * matching all cells (cellp == NULL), and if we've requested to ping
225 * this type of {up, down} servers.
227 if ((cellp == NULL || cellp == tsp->cellp) &&
228 ((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
229 (!isDown && (flags & CM_FLAG_CHECKUPSERVERS))) &&
230 ((!(flags & CM_FLAG_CHECKVLDBSERVERS) ||
231 !isFS && (flags & CM_FLAG_CHECKVLDBSERVERS)) &&
232 (!(flags & CM_FLAG_CHECKFILESERVERS) ||
233 isFS && (flags & CM_FLAG_CHECKFILESERVERS)))) {
235 } /* we're supposed to check this up/down server */
236 lock_ReleaseMutex(&tsp->mx);
238 /* at this point, we've adjusted the server state, so do the ping and
244 /* also, run the GC function for connections on all of the
245 * server's connections.
247 cm_GCConnections(tsp);
249 lock_ObtainRead(&cm_serverLock);
250 cm_PutServerNoLock(tsp);
252 lock_ReleaseRead(&cm_serverLock);
254 #else /* MULTI_CHECKSERVERS */
255 void cm_CheckServers(afs_uint32 flags, cm_cell_t *cellp)
258 * The goal of this function is to probe simultaneously
259 * probe all of the up/down servers (vldb/file) as
260 * specified by flags in the minimum number of RPCs.
261 * Effectively that means use one multi_RXAFS_GetCapabilities()
262 * followed by possibly one multi_RXAFS_GetTime() and
263 * one multi_VL_ProbeServer().
265 * To make this work we must construct the list of vldb
266 * and file servers that are to be probed as well as the
267 * associated data structures.
270 int srvAddrCount = 0;
271 struct srvAddr **addrs = NULL;
272 cm_conn_t **conns = NULL;
273 struct rx_connection **rxconns = NULL;
275 afs_int32 i, j, nconns = 0;
276 afs_int32 *conntimer, *results;
277 Capabilities *caps = NULL;
278 cm_server_t ** serversp, *tsp;
279 afs_uint32 isDown, wasDown;
281 time_t start, end, *deltas;
288 j = max(cm_numFileServers,cm_numVldbServers);
289 conns = (cm_conn_t **)malloc(j * sizeof(cm_conn_t *));
290 rxconns = (struct rx_connection **)malloc(j * sizeof(struct rx_connection *));
291 conntimer = (afs_int32 *)malloc(j * sizeof (afs_int32));
292 deltas = (time_t *)malloc(j * sizeof (time_t));
293 results = (afs_int32 *)malloc(j * sizeof (afs_int32));
294 serversp = (cm_server_t **)malloc(j * sizeof(cm_server_t *));
295 caps = (Capabilities *)malloc(j * sizeof(Capabilities));
297 memset(caps, 0, j * sizeof(Capabilities));
299 if ((flags & CM_FLAG_CHECKFILESERVERS) ||
300 !(flags & (CM_FLAG_CHECKFILESERVERS|CM_FLAG_CHECKVLDBSERVERS)))
302 lock_ObtainRead(&cm_serverLock);
304 for (nconns=0, tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
305 if (tsp->type != CM_SERVER_FILE ||
306 tsp->cellp == NULL || /* SetPref only */
307 cellp && cellp != tsp->cellp)
310 cm_GetServerNoLock(tsp);
311 lock_ReleaseRead(&cm_serverLock);
313 lock_ObtainMutex(&tsp->mx);
314 isDown = tsp->flags & CM_SERVERFLAG_DOWN;
316 if ((tsp->flags & CM_SERVERFLAG_PINGING) ||
317 !((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
318 (!isDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
319 lock_ReleaseMutex(&tsp->mx);
320 lock_ObtainRead(&cm_serverLock);
321 cm_PutServerNoLock(tsp);
325 tsp->flags |= CM_SERVERFLAG_PINGING;
326 lock_ReleaseMutex(&tsp->mx);
328 serversp[nconns] = tsp;
329 code = cm_ConnByServer(tsp, cm_rootUserp, &conns[nconns]);
331 lock_ObtainRead(&cm_serverLock);
332 cm_PutServerNoLock(tsp);
335 lock_ObtainRead(&cm_serverLock);
336 rxconns[nconns] = cm_GetRxConn(conns[nconns]);
337 if (conntimer[nconns] = (isDown ? 1 : 0))
338 rx_SetConnDeadTime(rxconns[nconns], 10);
342 lock_ReleaseRead(&cm_serverLock);
345 /* Perform the multi call */
347 multi_Rx(rxconns,nconns)
349 multi_RXAFS_GetCapabilities(&caps[multi_i]);
350 results[multi_i]=multi_error;
354 /* Process results of servers that support RXAFS_GetCapabilities */
355 for (i=0; i<nconns; i++) {
356 /* Leave the servers that did not support GetCapabilities alone */
357 if (results[i] == RXGEN_OPCODE)
361 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
362 rx_PutConnection(rxconns[i]);
363 cm_PutConn(conns[i]);
366 cm_GCConnections(tsp);
368 lock_ObtainMutex(&tsp->mx);
369 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
371 if (results[i] >= 0) {
372 /* mark server as up */
373 tsp->flags &= ~CM_SERVERFLAG_DOWN;
376 /* we currently handle 32-bits of capabilities */
377 if (caps[i].Capabilities_len > 0) {
378 tsp->capabilities = caps[i].Capabilities_val[0];
379 free(caps[i].Capabilities_val);
380 caps[i].Capabilities_len = 0;
381 caps[i].Capabilities_val = 0;
383 tsp->capabilities = 0;
386 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
387 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
388 osi_LogSaveString(afsd_logp, hoststr),
389 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
392 /* Now update the volume status if necessary */
394 cm_server_vols_t * tsrvp;
398 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
399 for (i=0; i<NUM_SERVER_VOLS; i++) {
400 if (tsrvp->ids[i] != 0) {
403 lock_ReleaseMutex(&tsp->mx);
404 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
405 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
406 lock_ObtainMutex(&tsp->mx);
408 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
416 /* mark server as down */
417 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
418 tsp->flags |= CM_SERVERFLAG_DOWN;
419 tsp->downTime = time(NULL);
421 if (code != VRESTARTING)
422 cm_ForceNewConnections(tsp);
424 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
425 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
426 osi_LogSaveString(afsd_logp, hoststr),
427 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
430 /* Now update the volume status if necessary */
432 cm_server_vols_t * tsrvp;
436 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
437 for (i=0; i<NUM_SERVER_VOLS; i++) {
438 if (tsrvp->ids[i] != 0) {
441 lock_ReleaseMutex(&tsp->mx);
442 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
443 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
444 lock_ObtainMutex(&tsp->mx);
446 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
455 if (tsp->waitCount == 0)
456 tsp->flags &= ~CM_SERVERFLAG_PINGING;
458 osi_Wakeup((LONG_PTR)tsp);
460 lock_ReleaseMutex(&tsp->mx);
466 * At this point we have handled any responses that did not indicate
467 * that RXAFS_GetCapabilities is not supported.
469 for ( i=0, j=0; i<nconns; i++) {
470 if (results[i] == RXGEN_OPCODE) {
473 rxconns[j] = rxconns[i];
474 serversp[j] = serversp[i];
482 /* Perform the multi call */
484 multi_Rx(rxconns,nconns)
487 multi_RXAFS_GetTime(&secs, &usecs);
489 results[multi_i]=multi_error;
490 if ((start == end) && !multi_error)
491 deltas[multi_i] = end - secs;
495 /* Process Results of servers that only support RXAFS_GetTime */
496 for (i=0; i<nconns; i++) {
497 /* Leave the servers that did not support GetCapabilities alone */
499 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
500 rx_PutConnection(rxconns[i]);
501 cm_PutConn(conns[i]);
504 cm_GCConnections(tsp);
506 lock_ObtainMutex(&tsp->mx);
507 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
509 if (results[i] >= 0) {
510 /* mark server as up */
511 tsp->flags &= ~CM_SERVERFLAG_DOWN;
513 tsp->capabilities = 0;
515 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
516 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
517 osi_LogSaveString(afsd_logp, hoststr),
518 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
521 /* Now update the volume status if necessary */
523 cm_server_vols_t * tsrvp;
527 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
528 for (i=0; i<NUM_SERVER_VOLS; i++) {
529 if (tsrvp->ids[i] != 0) {
532 lock_ReleaseMutex(&tsp->mx);
533 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
534 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
535 lock_ObtainMutex(&tsp->mx);
537 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
545 /* mark server as down */
546 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
547 tsp->flags |= CM_SERVERFLAG_DOWN;
548 tsp->downTime = time(NULL);
550 if (code != VRESTARTING)
551 cm_ForceNewConnections(tsp);
553 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
554 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
555 osi_LogSaveString(afsd_logp, hoststr),
556 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
559 /* Now update the volume status if necessary */
561 cm_server_vols_t * tsrvp;
565 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
566 for (i=0; i<NUM_SERVER_VOLS; i++) {
567 if (tsrvp->ids[i] != 0) {
570 lock_ReleaseMutex(&tsp->mx);
571 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
572 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
573 lock_ObtainMutex(&tsp->mx);
575 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
584 if (tsp->waitCount == 0)
585 tsp->flags &= ~CM_SERVERFLAG_PINGING;
587 osi_Wakeup((LONG_PTR)tsp);
589 lock_ReleaseMutex(&tsp->mx);
595 if ((flags & CM_FLAG_CHECKVLDBSERVERS) ||
596 !(flags & (CM_FLAG_CHECKFILESERVERS|CM_FLAG_CHECKVLDBSERVERS)))
598 lock_ObtainRead(&cm_serverLock);
600 for (nconns=0, tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
601 if (tsp->type != CM_SERVER_VLDB ||
602 tsp->cellp == NULL || /* SetPref only */
603 cellp && cellp != tsp->cellp)
606 cm_GetServerNoLock(tsp);
607 lock_ReleaseRead(&cm_serverLock);
609 lock_ObtainMutex(&tsp->mx);
610 isDown = tsp->flags & CM_SERVERFLAG_DOWN;
612 if ((tsp->flags & CM_SERVERFLAG_PINGING) ||
613 !((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
614 (!isDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
615 lock_ReleaseMutex(&tsp->mx);
616 lock_ObtainRead(&cm_serverLock);
617 cm_PutServerNoLock(tsp);
621 tsp->flags |= CM_SERVERFLAG_PINGING;
622 lock_ReleaseMutex(&tsp->mx);
624 serversp[nconns] = tsp;
625 code = cm_ConnByServer(tsp, cm_rootUserp, &conns[nconns]);
627 lock_ObtainRead(&cm_serverLock);
628 cm_PutServerNoLock(tsp);
631 lock_ObtainRead(&cm_serverLock);
632 rxconns[nconns] = cm_GetRxConn(conns[nconns]);
633 conntimer[nconns] = (isDown ? 1 : 0);
635 rx_SetConnDeadTime(rxconns[nconns], 10);
639 lock_ReleaseRead(&cm_serverLock);
642 /* Perform the multi call */
644 multi_Rx(rxconns,nconns)
646 multi_VL_ProbeServer();
647 results[multi_i]=multi_error;
651 /* Process results of servers that support RXAFS_GetCapabilities */
652 for (i=0; i<nconns; i++) {
654 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
655 rx_PutConnection(rxconns[i]);
656 cm_PutConn(conns[i]);
659 cm_GCConnections(tsp);
661 lock_ObtainMutex(&tsp->mx);
662 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
664 if (results[i] >= 0) {
665 /* mark server as up */
666 tsp->flags &= ~CM_SERVERFLAG_DOWN;
668 tsp->capabilities = 0;
670 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
671 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
672 osi_LogSaveString(afsd_logp, hoststr),
673 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
676 /* Now update the volume status if necessary */
678 cm_server_vols_t * tsrvp;
682 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
683 for (i=0; i<NUM_SERVER_VOLS; i++) {
684 if (tsrvp->ids[i] != 0) {
687 lock_ReleaseMutex(&tsp->mx);
688 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
689 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
690 lock_ObtainMutex(&tsp->mx);
692 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
700 /* mark server as down */
701 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
702 tsp->flags |= CM_SERVERFLAG_DOWN;
703 tsp->downTime = time(NULL);
705 if (code != VRESTARTING)
706 cm_ForceNewConnections(tsp);
708 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
709 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
710 osi_LogSaveString(afsd_logp, hoststr),
711 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
714 /* Now update the volume status if necessary */
716 cm_server_vols_t * tsrvp;
720 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
721 for (i=0; i<NUM_SERVER_VOLS; i++) {
722 if (tsrvp->ids[i] != 0) {
725 lock_ReleaseMutex(&tsp->mx);
726 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
727 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
728 lock_ObtainMutex(&tsp->mx);
730 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
739 if (tsp->waitCount == 0)
740 tsp->flags &= ~CM_SERVERFLAG_PINGING;
742 osi_Wakeup((LONG_PTR)tsp);
744 lock_ReleaseMutex(&tsp->mx);
758 #endif /* MULTI_CHECKSERVERS */
760 void cm_InitServer(void)
762 static osi_once_t once;
764 if (osi_Once(&once)) {
765 lock_InitializeRWLock(&cm_serverLock, "cm_serverLock");
766 lock_InitializeRWLock(&cm_syscfgLock, "cm_syscfgLock");
771 /* Protected by cm_syscfgLock (rw) */
772 int cm_noIPAddr; /* number of client network interfaces */
773 int cm_IPAddr[CM_MAXINTERFACE_ADDR]; /* client's IP address in host order */
774 int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
775 int cm_NetMtu[CM_MAXINTERFACE_ADDR]; /* client's MTU sizes */
776 int cm_NetFlags[CM_MAXINTERFACE_ADDR]; /* network flags */
777 int cm_LanAdapterChangeDetected = 1;
779 void cm_SetLanAdapterChangeDetected(void)
781 lock_ObtainWrite(&cm_syscfgLock);
782 cm_LanAdapterChangeDetected = 1;
783 lock_ReleaseWrite(&cm_syscfgLock);
786 void cm_GetServer(cm_server_t *serverp)
788 lock_ObtainRead(&cm_serverLock);
789 InterlockedIncrement(&serverp->refCount);
790 lock_ReleaseRead(&cm_serverLock);
793 void cm_GetServerNoLock(cm_server_t *serverp)
795 InterlockedIncrement(&serverp->refCount);
798 void cm_PutServer(cm_server_t *serverp)
801 lock_ObtainRead(&cm_serverLock);
802 refCount = InterlockedDecrement(&serverp->refCount);
803 osi_assertx(refCount >= 0, "cm_server_t refCount underflow");
804 lock_ReleaseRead(&cm_serverLock);
807 void cm_PutServerNoLock(cm_server_t *serverp)
809 afs_int32 refCount = InterlockedDecrement(&serverp->refCount);
810 osi_assertx(refCount >= 0, "cm_server_t refCount underflow");
813 void cm_SetServerNo64Bit(cm_server_t * serverp, int no64bit)
815 lock_ObtainMutex(&serverp->mx);
817 serverp->flags |= CM_SERVERFLAG_NO64BIT;
819 serverp->flags &= ~CM_SERVERFLAG_NO64BIT;
820 lock_ReleaseMutex(&serverp->mx);
823 void cm_SetServerNoInlineBulk(cm_server_t * serverp, int no)
825 lock_ObtainMutex(&serverp->mx);
827 serverp->flags |= CM_SERVERFLAG_NOINLINEBULK;
829 serverp->flags &= ~CM_SERVERFLAG_NOINLINEBULK;
830 lock_ReleaseMutex(&serverp->mx);
833 void cm_SetServerPrefs(cm_server_t * serverp)
835 unsigned long serverAddr; /* in host byte order */
836 unsigned long myAddr, myNet, mySubnet;/* in host byte order */
837 unsigned long netMask;
842 lock_ObtainRead(&cm_syscfgLock);
843 if (cm_LanAdapterChangeDetected) {
844 lock_ConvertRToW(&cm_syscfgLock);
846 if (cm_LanAdapterChangeDetected) {
847 /* get network related info */
848 cm_noIPAddr = CM_MAXINTERFACE_ADDR;
849 code = syscfg_GetIFInfo(&cm_noIPAddr,
850 cm_IPAddr, cm_SubnetMask,
851 cm_NetMtu, cm_NetFlags);
852 cm_LanAdapterChangeDetected = 0;
854 lock_ConvertWToR(&cm_syscfgLock);
857 serverAddr = ntohl(serverp->addr.sin_addr.s_addr);
858 serverp->ipRank = CM_IPRANK_LOW; /* default setings */
860 for ( i=0; i < cm_noIPAddr; i++)
862 /* loop through all the client's IP address and compare
863 ** each of them against the server's IP address */
865 myAddr = cm_IPAddr[i];
866 if ( IN_CLASSA(myAddr) )
867 netMask = IN_CLASSA_NET;
868 else if ( IN_CLASSB(myAddr) )
869 netMask = IN_CLASSB_NET;
870 else if ( IN_CLASSC(myAddr) )
871 netMask = IN_CLASSC_NET;
875 myNet = myAddr & netMask;
876 mySubnet = myAddr & cm_SubnetMask[i];
878 if ( (serverAddr & netMask) == myNet )
880 if ( (serverAddr & cm_SubnetMask[i]) == mySubnet)
882 if ( serverAddr == myAddr )
883 serverp->ipRank = min(serverp->ipRank,
884 CM_IPRANK_TOP);/* same machine */
885 else serverp->ipRank = min(serverp->ipRank,
886 CM_IPRANK_HI); /* same subnet */
888 else serverp->ipRank = min(serverp->ipRank,CM_IPRANK_MED);
891 /* random between 0..15*/
892 serverp->ipRank += min(serverp->ipRank, rand() % 0x000f);
893 } /* and of for loop */
894 lock_ReleaseRead(&cm_syscfgLock);
897 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp, afs_uint32 flags) {
900 osi_assertx(socketp->sin_family == AF_INET, "unexpected socket family");
902 tsp = malloc(sizeof(*tsp));
904 memset(tsp, 0, sizeof(*tsp));
908 lock_InitializeMutex(&tsp->mx, "cm_server_t mutex");
909 tsp->addr = *socketp;
911 cm_SetServerPrefs(tsp);
913 lock_ObtainWrite(&cm_serverLock); /* get server lock */
914 tsp->allNextp = cm_allServersp;
915 cm_allServersp = tsp;
926 lock_ReleaseWrite(&cm_serverLock); /* release server lock */
928 if ( !(flags & CM_FLAG_NOPROBE) ) {
929 tsp->flags = CM_SERVERFLAG_DOWN; /* assume down; ping will mark up if available */
930 cm_PingServer(tsp); /* Obtain Capabilities and check up/down state */
937 cm_FindServerByIP(afs_uint32 ipaddr, int type)
941 lock_ObtainRead(&cm_serverLock);
942 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
943 if (tsp->type == type &&
944 tsp->addr.sin_addr.S_un.S_addr == ipaddr)
947 lock_ReleaseRead(&cm_serverLock);
952 /* find a server based on its properties */
953 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
957 osi_assertx(addrp->sin_family == AF_INET, "unexpected socket value");
959 lock_ObtainRead(&cm_serverLock);
960 for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
961 if (tsp->type == type &&
962 tsp->addr.sin_addr.s_addr == addrp->sin_addr.s_addr)
966 /* bump ref count if we found the server */
968 cm_GetServerNoLock(tsp);
970 /* drop big table lock */
971 lock_ReleaseRead(&cm_serverLock);
973 /* return what we found */
977 cm_server_vols_t *cm_NewServerVols(void) {
978 cm_server_vols_t *tsvp;
980 tsvp = malloc(sizeof(*tsvp));
982 memset(tsvp, 0, sizeof(*tsvp));
987 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp, afs_uint32 volID)
989 cm_serverRef_t *tsrp;
990 cm_server_vols_t **tsrvpp = NULL;
991 afs_uint32 *slotp = NULL;
994 cm_GetServer(serverp);
995 tsrp = malloc(sizeof(*tsrp));
996 tsrp->server = serverp;
997 tsrp->status = srv_not_busy;
1002 /* if we have a non-zero volID, we need to add it to the list
1003 * of volumes maintained by the server. There are two phases:
1004 * (1) see if the volID is already in the list and (2) insert
1005 * it into the first empty slot if it is not.
1008 lock_ObtainMutex(&serverp->mx);
1010 tsrvpp = &serverp->vols;
1014 for (i=0; i<NUM_SERVER_VOLS; i++) {
1015 if ((*tsrvpp)->ids[i] == volID) {
1018 } else if (!slotp && (*tsrvpp)->ids[i] == 0) {
1019 slotp = &(*tsrvpp)->ids[i];
1026 tsrvpp = &(*tsrvpp)->nextp;
1033 /* if we didn't find an empty slot in a current
1034 * page we must need a new page */
1035 *tsrvpp = cm_NewServerVols();
1037 (*tsrvpp)->ids[0] = volID;
1041 lock_ReleaseMutex(&serverp->mx);
1047 LONG_PTR cm_ChecksumServerList(cm_serverRef_t *serversp)
1051 cm_serverRef_t *tsrp;
1053 lock_ObtainRead(&cm_serverLock);
1054 for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
1059 sum ^= (LONG_PTR) tsrp->server;
1062 lock_ReleaseRead(&cm_serverLock);
1067 ** Insert a server into the server list keeping the list sorted in
1068 ** ascending order of ipRank.
1070 ** The refCount of the cm_serverRef_t is increased
1072 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
1074 cm_serverRef_t *current=*list;
1075 unsigned short ipRank = element->server->ipRank;
1077 lock_ObtainWrite(&cm_serverLock);
1078 element->refCount++; /* increase refCount */
1080 /* insertion into empty list or at the beginning of the list */
1081 if ( !current || (current->server->ipRank > ipRank) )
1083 element->next = *list;
1085 lock_ReleaseWrite(&cm_serverLock);
1089 while ( current->next ) /* find appropriate place to insert */
1091 if ( current->next->server->ipRank > ipRank )
1093 else current = current->next;
1095 element->next = current->next;
1096 current->next = element;
1097 lock_ReleaseWrite(&cm_serverLock);
1100 ** Re-sort the server list with the modified rank
1101 ** returns 0 if element was changed successfully.
1102 ** returns 1 if list remained unchanged.
1104 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t* server)
1106 cm_serverRef_t **current=list;
1107 cm_serverRef_t *element=0;
1109 /* if there is max of one element in the list, nothing to sort */
1110 if ( (!*current) || !((*current)->next) )
1111 return 1; /* list unchanged: return success */
1113 lock_ObtainWrite(&cm_serverLock);
1114 /* if the server is on the list, delete it from list */
1117 if ( (*current)->server == server)
1119 element = (*current);
1120 *current = (*current)->next; /* delete it */
1123 current = & ( (*current)->next);
1125 lock_ReleaseWrite(&cm_serverLock);
1127 /* if this volume is not replicated on this server */
1129 return 1; /* server is not on list */
1131 /* re-insert deleted element into the list with modified rank*/
1132 cm_InsertServerList(list, element);
1134 /* reduce refCount which was increased by cm_InsertServerList */
1135 lock_ObtainWrite(&cm_serverLock);
1136 element->refCount--;
1137 lock_ReleaseWrite(&cm_serverLock);
1141 ** If there are more than one server on the list and the first n servers on
1142 ** the list have the same rank( n>1), then randomise among the first n servers.
1144 void cm_RandomizeServer(cm_serverRef_t** list)
1147 cm_serverRef_t* tsrp = *list, *lastTsrp;
1148 unsigned short lowestRank;
1150 /* an empty list or a list with only one element */
1151 if ( !tsrp || ! tsrp->next )
1154 lock_ObtainWrite(&cm_serverLock);
1156 /* count the number of servers with the lowest rank */
1157 lowestRank = tsrp->server->ipRank;
1158 for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
1160 if ( tsrp->server->ipRank != lowestRank)
1166 /* if there is only one server with the lowest rank, we are done */
1168 lock_ReleaseWrite(&cm_serverLock);
1172 picked = rand() % count;
1174 lock_ReleaseWrite(&cm_serverLock);
1179 while (--picked >= 0)
1184 lastTsrp->next = tsrp->next; /* delete random element from list*/
1185 tsrp->next = *list; /* insert element at the beginning of list */
1187 lock_ReleaseWrite(&cm_serverLock);
1190 /* call cm_FreeServer while holding a write lock on cm_serverLock */
1191 void cm_FreeServer(cm_server_t* serverp)
1193 cm_server_vols_t * tsrvp, *nextp;
1195 cm_PutServerNoLock(serverp);
1196 if (serverp->refCount == 0)
1198 /* we need to check to ensure that all of the connections
1199 * for this server have a 0 refCount; otherwise, they will
1200 * not be garbage collected
1202 cm_GCConnections(serverp); /* connsp */
1204 if (!(serverp->flags & CM_SERVERFLAG_PREF_SET)) {
1205 switch (serverp->type) {
1206 case CM_SERVER_VLDB:
1207 cm_numVldbServers--;
1209 case CM_SERVER_FILE:
1210 cm_numFileServers--;
1214 lock_FinalizeMutex(&serverp->mx);
1215 if ( cm_allServersp == serverp )
1216 cm_allServersp = serverp->allNextp;
1220 for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
1221 if ( tsp->allNextp == serverp ) {
1222 tsp->allNextp = serverp->allNextp;
1228 /* free the volid list */
1229 for ( tsrvp = serverp->vols; tsrvp; tsrvp = nextp) {
1230 nextp = tsrvp->nextp;
1239 void cm_RemoveVolumeFromServer(cm_server_t * serverp, afs_uint32 volID)
1241 cm_server_vols_t * tsrvp;
1247 for (tsrvp = serverp->vols; tsrvp; tsrvp = tsrvp->nextp) {
1248 for (i=0; i<NUM_SERVER_VOLS; i++) {
1249 if (tsrvp->ids[i] == volID) {
1257 void cm_FreeServerList(cm_serverRef_t** list, afs_uint32 flags)
1259 cm_serverRef_t **current = list;
1260 cm_serverRef_t **nextp = 0;
1261 cm_serverRef_t * next = 0;
1263 lock_ObtainWrite(&cm_serverLock);
1267 nextp = &(*current)->next;
1268 if (--((*current)->refCount) == 0) {
1271 if ((*current)->volID)
1272 cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1273 cm_FreeServer((*current)->server);
1277 if (flags & CM_FREESERVERLIST_DELETE) {
1278 (*current)->status = srv_deleted;
1279 if ((*current)->volID)
1280 cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1286 lock_ReleaseWrite(&cm_serverLock);