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>
22 #include <WINNT/afsreg.h>
26 osi_rwlock_t cm_serverLock;
27 osi_rwlock_t cm_syscfgLock;
29 cm_server_t *cm_allServersp;
30 afs_uint32 cm_numFileServers = 0;
31 afs_uint32 cm_numVldbServers = 0;
34 cm_ForceNewConnectionsAllServers(void)
38 lock_ObtainRead(&cm_serverLock);
39 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
40 cm_GetServerNoLock(tsp);
41 lock_ReleaseRead(&cm_serverLock);
42 cm_ForceNewConnections(tsp);
43 lock_ObtainRead(&cm_serverLock);
44 cm_PutServerNoLock(tsp);
46 lock_ReleaseRead(&cm_serverLock);
50 cm_PingServer(cm_server_t *tsp)
55 struct rx_connection * rxconnp;
58 Capabilities caps = {0, 0};
62 lock_ObtainMutex(&tsp->mx);
63 if (tsp->flags & CM_SERVERFLAG_PINGING) {
65 osi_SleepM((LONG_PTR)tsp, &tsp->mx);
66 lock_ObtainMutex(&tsp->mx);
68 if (tsp->waitCount == 0)
69 tsp->flags &= ~CM_SERVERFLAG_PINGING;
71 osi_Wakeup((LONG_PTR)tsp);
72 lock_ReleaseMutex(&tsp->mx);
75 tsp->flags |= CM_SERVERFLAG_PINGING;
76 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
77 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
78 lock_ReleaseMutex(&tsp->mx);
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 osi_Log4(afsd_logp, "cm_PingServer server %s (%s) was %s with caps 0x%x",
88 osi_LogSaveString(afsd_logp, hoststr),
89 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
90 wasDown ? "down" : "up",
93 rxconnp = cm_GetRxConn(connp);
95 rx_SetConnDeadTime(rxconnp, 10);
96 if (tsp->type == CM_SERVER_VLDB) {
97 code = VL_ProbeServer(rxconnp);
101 code = RXAFS_GetCapabilities(rxconnp, &caps);
102 if (code == RXGEN_OPCODE)
103 code = RXAFS_GetTime(rxconnp, &secs, &usecs);
106 rx_SetConnDeadTime(rxconnp, ConnDeadtimeout);
107 rx_PutConnection(rxconnp);
109 } /* got an unauthenticated connection to this server */
111 lock_ObtainMutex(&tsp->mx);
113 /* mark server as up */
114 tsp->flags &= ~CM_SERVERFLAG_DOWN;
117 /* we currently handle 32-bits of capabilities */
118 if (caps.Capabilities_len > 0) {
119 tsp->capabilities = caps.Capabilities_val[0];
120 xdr_free(caps.Capabilities_val, caps.Capabilities_len);
121 caps.Capabilities_len = 0;
122 caps.Capabilities_val = 0;
124 tsp->capabilities = 0;
127 osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is up with caps 0x%x",
128 osi_LogSaveString(afsd_logp, hoststr),
129 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
132 /* Now update the volume status if necessary */
134 cm_server_vols_t * tsrvp;
138 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
139 for (i=0; i<NUM_SERVER_VOLS; i++) {
140 if (tsrvp->ids[i] != 0) {
143 lock_ReleaseMutex(&tsp->mx);
144 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
145 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
146 lock_ObtainMutex(&tsp->mx);
148 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
156 /* mark server as down */
157 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
158 tsp->flags |= CM_SERVERFLAG_DOWN;
159 tsp->downTime = time(NULL);
161 if (code != VRESTARTING) {
162 lock_ReleaseMutex(&tsp->mx);
163 cm_ForceNewConnections(tsp);
164 lock_ObtainMutex(&tsp->mx);
166 osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is down with caps 0x%x",
167 osi_LogSaveString(afsd_logp, hoststr),
168 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
171 /* Now update the volume status if necessary */
173 cm_server_vols_t * tsrvp;
177 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
178 for (i=0; i<NUM_SERVER_VOLS; i++) {
179 if (tsrvp->ids[i] != 0) {
182 lock_ReleaseMutex(&tsp->mx);
183 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
184 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
185 lock_ObtainMutex(&tsp->mx);
187 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
196 if (tsp->waitCount == 0)
197 tsp->flags &= ~CM_SERVERFLAG_PINGING;
199 osi_Wakeup((LONG_PTR)tsp);
200 lock_ReleaseMutex(&tsp->mx);
203 static void cm_CheckServersSingular(afs_uint32 flags, cm_cell_t *cellp)
205 /* ping all file servers, up or down, with unauthenticated connection,
206 * to find out whether we have all our callbacks from the server still.
207 * Also, ping down VLDBs.
214 lock_ObtainRead(&cm_serverLock);
215 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
216 cm_GetServerNoLock(tsp);
217 lock_ReleaseRead(&cm_serverLock);
219 /* now process the server */
220 lock_ObtainMutex(&tsp->mx);
223 isDown = tsp->flags & CM_SERVERFLAG_DOWN;
224 isFS = tsp->type == CM_SERVER_FILE;
226 /* only do the ping if the cell matches the requested cell, or we're
227 * matching all cells (cellp == NULL), and if we've requested to ping
228 * this type of {up, down} servers.
230 if ((cellp == NULL || cellp == tsp->cellp) &&
231 ((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
232 (!isDown && (flags & CM_FLAG_CHECKUPSERVERS))) &&
233 ((!(flags & CM_FLAG_CHECKVLDBSERVERS) ||
234 !isFS && (flags & CM_FLAG_CHECKVLDBSERVERS)) &&
235 (!(flags & CM_FLAG_CHECKFILESERVERS) ||
236 isFS && (flags & CM_FLAG_CHECKFILESERVERS)))) {
238 } /* we're supposed to check this up/down server */
239 lock_ReleaseMutex(&tsp->mx);
241 /* at this point, we've adjusted the server state, so do the ping and
247 /* also, run the GC function for connections on all of the
248 * server's connections.
250 cm_GCConnections(tsp);
252 lock_ObtainRead(&cm_serverLock);
253 cm_PutServerNoLock(tsp);
255 lock_ReleaseRead(&cm_serverLock);
258 static void cm_CheckServersMulti(afs_uint32 flags, cm_cell_t *cellp)
261 * The goal of this function is to probe simultaneously
262 * probe all of the up/down servers (vldb/file) as
263 * specified by flags in the minimum number of RPCs.
264 * Effectively that means use one multi_RXAFS_GetCapabilities()
265 * followed by possibly one multi_RXAFS_GetTime() and
266 * one multi_VL_ProbeServer().
268 * To make this work we must construct the list of vldb
269 * and file servers that are to be probed as well as the
270 * associated data structures.
273 int srvAddrCount = 0;
274 struct srvAddr **addrs = NULL;
275 cm_conn_t **conns = NULL;
276 struct rx_connection **rxconns = NULL;
278 afs_int32 i, j, nconns = 0, maxconns;
279 afs_int32 *conntimer, *results;
280 Capabilities *caps = NULL;
281 cm_server_t ** serversp, *tsp;
282 afs_uint32 isDown, wasDown;
284 time_t start, end, *deltas;
290 maxconns = max(cm_numFileServers,cm_numVldbServers);
294 conns = (cm_conn_t **)malloc(maxconns * sizeof(cm_conn_t *));
295 rxconns = (struct rx_connection **)malloc(maxconns * sizeof(struct rx_connection *));
296 conntimer = (afs_int32 *)malloc(maxconns * sizeof (afs_int32));
297 deltas = (time_t *)malloc(maxconns * sizeof (time_t));
298 results = (afs_int32 *)malloc(maxconns * sizeof (afs_int32));
299 serversp = (cm_server_t **)malloc(maxconns * sizeof(cm_server_t *));
300 caps = (Capabilities *)malloc(maxconns * sizeof(Capabilities));
302 memset(caps, 0, maxconns * sizeof(Capabilities));
304 if ((flags & CM_FLAG_CHECKFILESERVERS) ||
305 !(flags & (CM_FLAG_CHECKFILESERVERS|CM_FLAG_CHECKVLDBSERVERS)))
307 lock_ObtainRead(&cm_serverLock);
308 for (nconns=0, tsp = cm_allServersp; tsp && nconns < maxconns; tsp = tsp->allNextp) {
309 if (tsp->type != CM_SERVER_FILE ||
310 tsp->cellp == NULL || /* SetPref only */
311 cellp && cellp != tsp->cellp)
314 cm_GetServerNoLock(tsp);
315 lock_ReleaseRead(&cm_serverLock);
317 lock_ObtainMutex(&tsp->mx);
318 isDown = tsp->flags & CM_SERVERFLAG_DOWN;
320 if ((tsp->flags & CM_SERVERFLAG_PINGING) ||
321 !((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
322 (!isDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
323 lock_ReleaseMutex(&tsp->mx);
324 lock_ObtainRead(&cm_serverLock);
325 cm_PutServerNoLock(tsp);
329 tsp->flags |= CM_SERVERFLAG_PINGING;
330 lock_ReleaseMutex(&tsp->mx);
332 serversp[nconns] = tsp;
333 code = cm_ConnByServer(tsp, cm_rootUserp, &conns[nconns]);
335 lock_ObtainRead(&cm_serverLock);
336 cm_PutServerNoLock(tsp);
339 lock_ObtainRead(&cm_serverLock);
340 rxconns[nconns] = cm_GetRxConn(conns[nconns]);
341 if (conntimer[nconns] = (isDown ? 1 : 0))
342 rx_SetConnDeadTime(rxconns[nconns], 10);
346 lock_ReleaseRead(&cm_serverLock);
349 /* Perform the multi call */
351 multi_Rx(rxconns,nconns)
353 multi_RXAFS_GetCapabilities(&caps[multi_i]);
354 results[multi_i]=multi_error;
358 /* Process results of servers that support RXAFS_GetCapabilities */
359 for (i=0; i<nconns; i++) {
360 /* Leave the servers that did not support GetCapabilities alone */
361 if (results[i] == RXGEN_OPCODE)
365 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
366 rx_PutConnection(rxconns[i]);
367 cm_PutConn(conns[i]);
370 cm_GCConnections(tsp);
372 lock_ObtainMutex(&tsp->mx);
373 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
375 if (results[i] >= 0) {
376 /* mark server as up */
377 tsp->flags &= ~CM_SERVERFLAG_DOWN;
380 /* we currently handle 32-bits of capabilities */
381 if (caps[i].Capabilities_len > 0) {
382 tsp->capabilities = caps[i].Capabilities_val[0];
383 xdr_free(caps[i].Capabilities_val, caps[i].Capabilities_len);
384 caps[i].Capabilities_len = 0;
385 caps[i].Capabilities_val = 0;
387 tsp->capabilities = 0;
390 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
391 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
392 osi_LogSaveString(afsd_logp, hoststr),
393 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
396 /* Now update the volume status if necessary */
398 cm_server_vols_t * tsrvp;
402 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
403 for (i=0; i<NUM_SERVER_VOLS; i++) {
404 if (tsrvp->ids[i] != 0) {
407 lock_ReleaseMutex(&tsp->mx);
408 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
409 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
410 lock_ObtainMutex(&tsp->mx);
412 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
420 /* mark server as down */
421 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
422 tsp->flags |= CM_SERVERFLAG_DOWN;
423 tsp->downTime = time(NULL);
425 if (code != VRESTARTING) {
426 lock_ReleaseMutex(&tsp->mx);
427 cm_ForceNewConnections(tsp);
428 lock_ObtainMutex(&tsp->mx);
430 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
431 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
432 osi_LogSaveString(afsd_logp, hoststr),
433 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
436 /* Now update the volume status if necessary */
438 cm_server_vols_t * tsrvp;
442 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
443 for (i=0; i<NUM_SERVER_VOLS; i++) {
444 if (tsrvp->ids[i] != 0) {
447 lock_ReleaseMutex(&tsp->mx);
448 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
449 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
450 lock_ObtainMutex(&tsp->mx);
452 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
461 if (tsp->waitCount == 0)
462 tsp->flags &= ~CM_SERVERFLAG_PINGING;
464 osi_Wakeup((LONG_PTR)tsp);
466 lock_ReleaseMutex(&tsp->mx);
472 * At this point we have handled any responses that did not indicate
473 * that RXAFS_GetCapabilities is not supported.
475 for ( i=0, j=0; i<nconns; i++) {
476 if (results[i] == RXGEN_OPCODE) {
479 rxconns[j] = rxconns[i];
480 serversp[j] = serversp[i];
488 /* Perform the multi call */
490 multi_Rx(rxconns,nconns)
493 multi_RXAFS_GetTime(&secs, &usecs);
495 results[multi_i]=multi_error;
496 if ((start == end) && !multi_error)
497 deltas[multi_i] = end - secs;
501 /* Process Results of servers that only support RXAFS_GetTime */
502 for (i=0; i<nconns; i++) {
503 /* Leave the servers that did not support GetCapabilities alone */
505 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
506 rx_PutConnection(rxconns[i]);
507 cm_PutConn(conns[i]);
510 cm_GCConnections(tsp);
512 lock_ObtainMutex(&tsp->mx);
513 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
515 if (results[i] >= 0) {
516 /* mark server as up */
517 tsp->flags &= ~CM_SERVERFLAG_DOWN;
519 tsp->capabilities = 0;
521 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
522 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
523 osi_LogSaveString(afsd_logp, hoststr),
524 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
527 /* Now update the volume status if necessary */
529 cm_server_vols_t * tsrvp;
533 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
534 for (i=0; i<NUM_SERVER_VOLS; i++) {
535 if (tsrvp->ids[i] != 0) {
538 lock_ReleaseMutex(&tsp->mx);
539 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
540 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
541 lock_ObtainMutex(&tsp->mx);
543 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
551 /* mark server as down */
552 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
553 tsp->flags |= CM_SERVERFLAG_DOWN;
554 tsp->downTime = time(NULL);
556 if (code != VRESTARTING) {
557 lock_ReleaseMutex(&tsp->mx);
558 cm_ForceNewConnections(tsp);
559 lock_ObtainMutex(&tsp->mx);
561 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
562 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
563 osi_LogSaveString(afsd_logp, hoststr),
564 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
567 /* Now update the volume status if necessary */
569 cm_server_vols_t * tsrvp;
573 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
574 for (i=0; i<NUM_SERVER_VOLS; i++) {
575 if (tsrvp->ids[i] != 0) {
578 lock_ReleaseMutex(&tsp->mx);
579 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
580 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
581 lock_ObtainMutex(&tsp->mx);
583 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
592 if (tsp->waitCount == 0)
593 tsp->flags &= ~CM_SERVERFLAG_PINGING;
595 osi_Wakeup((LONG_PTR)tsp);
597 lock_ReleaseMutex(&tsp->mx);
603 if ((flags & CM_FLAG_CHECKVLDBSERVERS) ||
604 !(flags & (CM_FLAG_CHECKFILESERVERS|CM_FLAG_CHECKVLDBSERVERS)))
606 lock_ObtainRead(&cm_serverLock);
607 for (nconns=0, tsp = cm_allServersp; tsp && nconns < maxconns; tsp = tsp->allNextp) {
608 if (tsp->type != CM_SERVER_VLDB ||
609 tsp->cellp == NULL || /* SetPref only */
610 cellp && cellp != tsp->cellp)
613 cm_GetServerNoLock(tsp);
614 lock_ReleaseRead(&cm_serverLock);
616 lock_ObtainMutex(&tsp->mx);
617 isDown = tsp->flags & CM_SERVERFLAG_DOWN;
619 if ((tsp->flags & CM_SERVERFLAG_PINGING) ||
620 !((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
621 (!isDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
622 lock_ReleaseMutex(&tsp->mx);
623 lock_ObtainRead(&cm_serverLock);
624 cm_PutServerNoLock(tsp);
628 tsp->flags |= CM_SERVERFLAG_PINGING;
629 lock_ReleaseMutex(&tsp->mx);
631 serversp[nconns] = tsp;
632 code = cm_ConnByServer(tsp, cm_rootUserp, &conns[nconns]);
634 lock_ObtainRead(&cm_serverLock);
635 cm_PutServerNoLock(tsp);
638 lock_ObtainRead(&cm_serverLock);
639 rxconns[nconns] = cm_GetRxConn(conns[nconns]);
640 conntimer[nconns] = (isDown ? 1 : 0);
642 rx_SetConnDeadTime(rxconns[nconns], 10);
646 lock_ReleaseRead(&cm_serverLock);
649 /* Perform the multi call */
651 multi_Rx(rxconns,nconns)
653 multi_VL_ProbeServer();
654 results[multi_i]=multi_error;
658 /* Process results of servers that support VL_ProbeServer */
659 for (i=0; i<nconns; i++) {
661 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
662 rx_PutConnection(rxconns[i]);
663 cm_PutConn(conns[i]);
666 cm_GCConnections(tsp);
668 lock_ObtainMutex(&tsp->mx);
669 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
671 if (results[i] >= 0) {
672 /* mark server as up */
673 tsp->flags &= ~CM_SERVERFLAG_DOWN;
675 tsp->capabilities = 0;
677 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
678 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
679 osi_LogSaveString(afsd_logp, hoststr),
680 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
683 /* mark server as down */
684 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
685 tsp->flags |= CM_SERVERFLAG_DOWN;
686 tsp->downTime = time(NULL);
688 if (code != VRESTARTING) {
689 lock_ReleaseMutex(&tsp->mx);
690 cm_ForceNewConnections(tsp);
691 lock_ObtainMutex(&tsp->mx);
693 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
694 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
695 osi_LogSaveString(afsd_logp, hoststr),
696 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
700 if (tsp->waitCount == 0)
701 tsp->flags &= ~CM_SERVERFLAG_PINGING;
703 osi_Wakeup((LONG_PTR)tsp);
705 lock_ReleaseMutex(&tsp->mx);
720 void cm_CheckServers(afs_uint32 flags, cm_cell_t *cellp)
727 code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
728 0, KEY_QUERY_VALUE, &parmKey);
729 if (code == ERROR_SUCCESS) {
730 dummyLen = sizeof(multi);
731 code = RegQueryValueEx(parmKey, "MultiCheckServers", NULL, NULL,
732 (BYTE *) &multi, &dummyLen);
733 RegCloseKey (parmKey);
737 cm_CheckServersMulti(flags, cellp);
739 cm_CheckServersSingular(flags, cellp);
742 void cm_InitServer(void)
744 static osi_once_t once;
746 if (osi_Once(&once)) {
747 lock_InitializeRWLock(&cm_serverLock, "cm_serverLock", LOCK_HIERARCHY_SERVER_GLOBAL);
748 lock_InitializeRWLock(&cm_syscfgLock, "cm_syscfgLock", LOCK_HIERARCHY_SYSCFG_GLOBAL);
753 /* Protected by cm_syscfgLock (rw) */
754 int cm_noIPAddr; /* number of client network interfaces */
755 int cm_IPAddr[CM_MAXINTERFACE_ADDR]; /* client's IP address in host order */
756 int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
757 int cm_NetMtu[CM_MAXINTERFACE_ADDR]; /* client's MTU sizes */
758 int cm_NetFlags[CM_MAXINTERFACE_ADDR]; /* network flags */
759 int cm_LanAdapterChangeDetected = 1;
761 void cm_SetLanAdapterChangeDetected(void)
763 lock_ObtainWrite(&cm_syscfgLock);
764 cm_LanAdapterChangeDetected = 1;
765 lock_ReleaseWrite(&cm_syscfgLock);
768 void cm_GetServer(cm_server_t *serverp)
770 lock_ObtainRead(&cm_serverLock);
771 InterlockedIncrement(&serverp->refCount);
772 lock_ReleaseRead(&cm_serverLock);
775 void cm_GetServerNoLock(cm_server_t *serverp)
777 InterlockedIncrement(&serverp->refCount);
780 void cm_PutServer(cm_server_t *serverp)
783 lock_ObtainRead(&cm_serverLock);
784 refCount = InterlockedDecrement(&serverp->refCount);
785 osi_assertx(refCount >= 0, "cm_server_t refCount underflow");
786 lock_ReleaseRead(&cm_serverLock);
789 void cm_PutServerNoLock(cm_server_t *serverp)
791 afs_int32 refCount = InterlockedDecrement(&serverp->refCount);
792 osi_assertx(refCount >= 0, "cm_server_t refCount underflow");
795 void cm_SetServerNo64Bit(cm_server_t * serverp, int no64bit)
797 lock_ObtainMutex(&serverp->mx);
799 serverp->flags |= CM_SERVERFLAG_NO64BIT;
801 serverp->flags &= ~CM_SERVERFLAG_NO64BIT;
802 lock_ReleaseMutex(&serverp->mx);
805 void cm_SetServerNoInlineBulk(cm_server_t * serverp, int no)
807 lock_ObtainMutex(&serverp->mx);
809 serverp->flags |= CM_SERVERFLAG_NOINLINEBULK;
811 serverp->flags &= ~CM_SERVERFLAG_NOINLINEBULK;
812 lock_ReleaseMutex(&serverp->mx);
815 void cm_SetServerPrefs(cm_server_t * serverp)
817 unsigned long serverAddr; /* in host byte order */
818 unsigned long myAddr, myNet, mySubnet;/* in host byte order */
819 unsigned long netMask;
824 lock_ObtainRead(&cm_syscfgLock);
825 if (cm_LanAdapterChangeDetected) {
826 lock_ConvertRToW(&cm_syscfgLock);
828 if (cm_LanAdapterChangeDetected) {
829 /* get network related info */
830 cm_noIPAddr = CM_MAXINTERFACE_ADDR;
831 code = syscfg_GetIFInfo(&cm_noIPAddr,
832 cm_IPAddr, cm_SubnetMask,
833 cm_NetMtu, cm_NetFlags);
834 cm_LanAdapterChangeDetected = 0;
836 lock_ConvertWToR(&cm_syscfgLock);
839 serverAddr = ntohl(serverp->addr.sin_addr.s_addr);
840 serverp->ipRank = CM_IPRANK_LOW; /* default setings */
842 for ( i=0; i < cm_noIPAddr; i++)
844 /* loop through all the client's IP address and compare
845 ** each of them against the server's IP address */
847 myAddr = cm_IPAddr[i];
848 if ( IN_CLASSA(myAddr) )
849 netMask = IN_CLASSA_NET;
850 else if ( IN_CLASSB(myAddr) )
851 netMask = IN_CLASSB_NET;
852 else if ( IN_CLASSC(myAddr) )
853 netMask = IN_CLASSC_NET;
857 myNet = myAddr & netMask;
858 mySubnet = myAddr & cm_SubnetMask[i];
860 if ( (serverAddr & netMask) == myNet )
862 if ( (serverAddr & cm_SubnetMask[i]) == mySubnet)
864 if ( serverAddr == myAddr )
865 serverp->ipRank = min(serverp->ipRank,
866 CM_IPRANK_TOP);/* same machine */
867 else serverp->ipRank = min(serverp->ipRank,
868 CM_IPRANK_HI); /* same subnet */
870 else serverp->ipRank = min(serverp->ipRank,CM_IPRANK_MED);
873 } /* and of for loop */
875 /* random between 0..15*/
876 serverp->ipRank += (rand() % 0x000f);
877 lock_ReleaseRead(&cm_syscfgLock);
880 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp, afsUUID *uuidp, afs_uint32 flags) {
883 osi_assertx(socketp->sin_family == AF_INET, "unexpected socket family");
885 tsp = malloc(sizeof(*tsp));
887 memset(tsp, 0, sizeof(*tsp));
890 if (uuidp && !afs_uuid_is_nil(uuidp)) {
892 tsp->flags |= CM_SERVERFLAG_UUID;
895 lock_InitializeMutex(&tsp->mx, "cm_server_t mutex", LOCK_HIERARCHY_SERVER);
896 tsp->addr = *socketp;
898 cm_SetServerPrefs(tsp);
900 lock_ObtainWrite(&cm_serverLock); /* get server lock */
901 tsp->allNextp = cm_allServersp;
902 cm_allServersp = tsp;
913 lock_ReleaseWrite(&cm_serverLock); /* release server lock */
915 if ( !(flags & CM_FLAG_NOPROBE) ) {
916 tsp->flags |= CM_SERVERFLAG_DOWN; /* assume down; ping will mark up if available */
917 cm_PingServer(tsp); /* Obtain Capabilities and check up/down state */
924 cm_FindServerByIP(afs_uint32 ipaddr, unsigned short port, int type)
928 lock_ObtainRead(&cm_serverLock);
929 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
930 if (tsp->type == type &&
931 tsp->addr.sin_addr.S_un.S_addr == ipaddr &&
932 (tsp->addr.sin_port == port || tsp->addr.sin_port == 0))
936 /* bump ref count if we found the server */
938 cm_GetServerNoLock(tsp);
940 lock_ReleaseRead(&cm_serverLock);
946 cm_FindServerByUuid(afsUUID *serverUuid, int type)
950 lock_ObtainRead(&cm_serverLock);
951 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
952 if (tsp->type == type && !afs_uuid_equal(&tsp->uuid, serverUuid))
956 /* bump ref count if we found the server */
958 cm_GetServerNoLock(tsp);
960 lock_ReleaseRead(&cm_serverLock);
965 /* find a server based on its properties */
966 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
970 osi_assertx(addrp->sin_family == AF_INET, "unexpected socket value");
972 lock_ObtainRead(&cm_serverLock);
973 for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
974 if (tsp->type == type &&
975 tsp->addr.sin_addr.s_addr == addrp->sin_addr.s_addr &&
976 (tsp->addr.sin_port == addrp->sin_port || tsp->addr.sin_port == 0))
980 /* bump ref count if we found the server */
982 cm_GetServerNoLock(tsp);
984 /* drop big table lock */
985 lock_ReleaseRead(&cm_serverLock);
987 /* return what we found */
991 cm_server_vols_t *cm_NewServerVols(void) {
992 cm_server_vols_t *tsvp;
994 tsvp = malloc(sizeof(*tsvp));
996 memset(tsvp, 0, sizeof(*tsvp));
1001 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp, afs_uint32 volID)
1003 cm_serverRef_t *tsrp;
1004 cm_server_vols_t **tsrvpp = NULL;
1005 afs_uint32 *slotp = NULL;
1008 cm_GetServer(serverp);
1009 tsrp = malloc(sizeof(*tsrp));
1010 tsrp->server = serverp;
1011 tsrp->status = srv_not_busy;
1013 tsrp->volID = volID;
1016 /* if we have a non-zero volID, we need to add it to the list
1017 * of volumes maintained by the server. There are two phases:
1018 * (1) see if the volID is already in the list and (2) insert
1019 * it into the first empty slot if it is not.
1022 lock_ObtainMutex(&serverp->mx);
1024 tsrvpp = &serverp->vols;
1028 for (i=0; i<NUM_SERVER_VOLS; i++) {
1029 if ((*tsrvpp)->ids[i] == volID) {
1032 } else if (!slotp && (*tsrvpp)->ids[i] == 0) {
1033 slotp = &(*tsrvpp)->ids[i];
1040 tsrvpp = &(*tsrvpp)->nextp;
1047 /* if we didn't find an empty slot in a current
1048 * page we must need a new page */
1049 *tsrvpp = cm_NewServerVols();
1051 (*tsrvpp)->ids[0] = volID;
1055 lock_ReleaseMutex(&serverp->mx);
1061 LONG_PTR cm_ChecksumServerList(cm_serverRef_t *serversp)
1065 cm_serverRef_t *tsrp;
1067 lock_ObtainRead(&cm_serverLock);
1068 for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
1069 if (tsrp->status == srv_deleted)
1075 sum ^= (LONG_PTR) tsrp->server;
1078 lock_ReleaseRead(&cm_serverLock);
1083 ** Insert a server into the server list keeping the list sorted in
1084 ** ascending order of ipRank.
1086 ** The refCount of the cm_serverRef_t is increased
1088 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
1090 cm_serverRef_t *current=*list;
1091 unsigned short ipRank = element->server->ipRank;
1093 lock_ObtainWrite(&cm_serverLock);
1094 element->refCount++; /* increase refCount */
1096 /* insertion into empty list or at the beginning of the list */
1097 if ( !current || (current->server->ipRank > ipRank) )
1099 element->next = *list;
1101 lock_ReleaseWrite(&cm_serverLock);
1105 while ( current->next ) /* find appropriate place to insert */
1107 if ( current->next->server->ipRank > ipRank )
1109 else current = current->next;
1111 element->next = current->next;
1112 current->next = element;
1113 lock_ReleaseWrite(&cm_serverLock);
1116 ** Re-sort the server list with the modified rank
1117 ** returns 0 if element was changed successfully.
1118 ** returns 1 if list remained unchanged.
1120 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t* server)
1122 cm_serverRef_t **current=list;
1123 cm_serverRef_t *element=0;
1125 /* if there is max of one element in the list, nothing to sort */
1126 if ( (!*current) || !((*current)->next) )
1127 return 1; /* list unchanged: return success */
1129 lock_ObtainWrite(&cm_serverLock);
1130 /* if the server is on the list, delete it from list */
1133 if ( (*current)->server == server)
1135 element = (*current);
1136 *current = (*current)->next; /* delete it */
1139 current = & ( (*current)->next);
1141 lock_ReleaseWrite(&cm_serverLock);
1143 /* if this volume is not replicated on this server */
1145 return 1; /* server is not on list */
1147 /* re-insert deleted element into the list with modified rank*/
1148 cm_InsertServerList(list, element);
1150 /* reduce refCount which was increased by cm_InsertServerList */
1151 lock_ObtainWrite(&cm_serverLock);
1152 element->refCount--;
1153 lock_ReleaseWrite(&cm_serverLock);
1157 ** If there are more than one server on the list and the first n servers on
1158 ** the list have the same rank( n>1), then randomise among the first n servers.
1160 void cm_RandomizeServer(cm_serverRef_t** list)
1163 cm_serverRef_t* tsrp = *list, *lastTsrp;
1164 unsigned short lowestRank;
1166 /* an empty list or a list with only one element */
1167 if ( !tsrp || ! tsrp->next )
1170 lock_ObtainWrite(&cm_serverLock);
1172 /* count the number of servers with the lowest rank */
1173 lowestRank = tsrp->server->ipRank;
1174 for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
1176 if ( tsrp->server->ipRank != lowestRank)
1182 /* if there is only one server with the lowest rank, we are done */
1184 lock_ReleaseWrite(&cm_serverLock);
1188 picked = rand() % count;
1190 lock_ReleaseWrite(&cm_serverLock);
1195 while (--picked >= 0)
1200 lastTsrp->next = tsrp->next; /* delete random element from list*/
1201 tsrp->next = *list; /* insert element at the beginning of list */
1203 lock_ReleaseWrite(&cm_serverLock);
1206 /* call cm_FreeServer while holding a write lock on cm_serverLock */
1207 void cm_FreeServer(cm_server_t* serverp)
1209 cm_server_vols_t * tsrvp, *nextp;
1212 cm_PutServerNoLock(serverp);
1213 if (serverp->refCount == 0)
1216 * we need to check to ensure that all of the connections
1217 * for this server have a 0 refCount; otherwise, they will
1218 * not be garbage collected
1220 * must drop the cm_serverLock because cm_GCConnections
1221 * obtains the cm_connLock and that comes first in the
1224 lock_ReleaseWrite(&cm_serverLock);
1225 cm_GCConnections(serverp); /* connsp */
1226 lock_ObtainWrite(&cm_serverLock);
1231 * Once we have the cm_serverLock locked check to make
1232 * sure the refCount is still zero before removing the
1235 if (serverp->refCount == 0) {
1236 if (!(serverp->flags & CM_SERVERFLAG_PREF_SET)) {
1237 switch (serverp->type) {
1238 case CM_SERVER_VLDB:
1239 cm_numVldbServers--;
1241 case CM_SERVER_FILE:
1242 cm_numFileServers--;
1246 lock_FinalizeMutex(&serverp->mx);
1247 if ( cm_allServersp == serverp )
1248 cm_allServersp = serverp->allNextp;
1252 for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
1253 if ( tsp->allNextp == serverp ) {
1254 tsp->allNextp = serverp->allNextp;
1260 /* free the volid list */
1261 for ( tsrvp = serverp->vols; tsrvp; tsrvp = nextp) {
1262 nextp = tsrvp->nextp;
1271 /* Called with cm_serverLock write locked */
1272 void cm_RemoveVolumeFromServer(cm_server_t * serverp, afs_uint32 volID)
1274 cm_server_vols_t * tsrvp;
1280 for (tsrvp = serverp->vols; tsrvp; tsrvp = tsrvp->nextp) {
1281 for (i=0; i<NUM_SERVER_VOLS; i++) {
1282 if (tsrvp->ids[i] == volID) {
1290 void cm_FreeServerList(cm_serverRef_t** list, afs_uint32 flags)
1292 cm_serverRef_t **current = list;
1293 cm_serverRef_t **nextp = 0;
1294 cm_serverRef_t * next = 0;
1299 lock_ObtainWrite(&cm_serverLock);
1303 nextp = &(*current)->next;
1304 if (--((*current)->refCount) == 0) {
1307 if ((*current)->volID)
1308 cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1309 cm_FreeServer((*current)->server);
1313 if (flags & CM_FREESERVERLIST_DELETE) {
1314 (*current)->status = srv_deleted;
1315 if ((*current)->volID)
1316 cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1322 lock_ReleaseWrite(&cm_serverLock);
1325 /* dump all servers to a file.
1326 * cookie is used to identify this batch for easy parsing,
1327 * and it a string provided by a caller
1329 int cm_DumpServers(FILE *outputFile, char *cookie, int lock)
1338 lock_ObtainRead(&cm_serverLock);
1340 sprintf(output, "%s - dumping servers - cm_numFileServers=%d, cm_numVldbServers=%d\r\n",
1341 cookie, cm_numFileServers, cm_numVldbServers);
1342 WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1344 for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp)
1349 switch (tsp->type) {
1350 case CM_SERVER_VLDB:
1353 case CM_SERVER_FILE:
1360 afsUUID_to_string(&tsp->uuid, uuidstr, sizeof(uuidstr));
1361 afs_inet_ntoa_r(tsp->addr.sin_addr.s_addr, hoststr);
1362 down = ctime(&tsp->downTime);
1363 down[strlen(down)-1] = '\0';
1365 sprintf(output, "%s - tsp=0x%p cell=%s addr=%-15s port=%u uuid=%s type=%s caps=0x%x flags=0x%x waitCount=%u rank=%u downTime=\"%s\" refCount=%u\r\n",
1366 cookie, tsp, tsp->cellp ? tsp->cellp->name : "", tsp->addr.sin_port, hoststr, uuidstr, type,
1367 tsp->capabilities, tsp->flags, tsp->waitCount, tsp->ipRank,
1368 (tsp->flags & CM_SERVERFLAG_DOWN) ? down : "up",
1370 WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1372 sprintf(output, "%s - Done dumping servers.\r\n", cookie);
1373 WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1376 lock_ReleaseRead(&cm_serverLock);
1382 * Determine if two servers are in fact the same.
1384 * Returns 1 if they match, 0 if they do not
1386 int cm_ServerEqual(cm_server_t *srv1, cm_server_t *srv2)
1390 if (srv1 == NULL || srv2 == NULL)
1396 if (srv1->flags & CM_SERVERFLAG_UUID) {
1397 if (!(srv2->flags & CM_SERVERFLAG_UUID))
1400 /* Both support UUID */
1401 if (UuidEqual((UUID *)&srv1->uuid, (UUID *)&srv2->uuid, &status))