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>
27 osi_rwlock_t cm_serverLock;
28 osi_rwlock_t cm_syscfgLock;
30 cm_server_t *cm_allServersp;
31 afs_uint32 cm_numFileServers = 0;
32 afs_uint32 cm_numVldbServers = 0;
35 cm_ForceNewConnectionsAllServers(void)
39 lock_ObtainRead(&cm_serverLock);
40 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
41 cm_GetServerNoLock(tsp);
42 lock_ReleaseRead(&cm_serverLock);
43 cm_ForceNewConnections(tsp);
44 lock_ObtainRead(&cm_serverLock);
45 cm_PutServerNoLock(tsp);
47 lock_ReleaseRead(&cm_serverLock);
51 * lock_ObtainMutex must be held prior to calling
55 cm_RankServer(cm_server_t * tsp)
57 afs_int32 code = 0; /* start with "success" */
58 struct rx_debugPeer tpeer;
73 code = rx_GetLocalPeers(tsp->addr.sin_addr.s_addr, port, &tpeer);
75 /*check if rx_GetLocalPeers succeeded and if there is data for tsp */
76 if(code == 0 && (tpeer.rtt == 0 && tpeer.rtt_dev == 0))
80 if((tsp->flags & CM_SERVERFLAG_PREF_SET))
81 newRank = tsp->adminRank +
82 ((int)(623 * log(tpeer.rtt) / 10) * 10 + 5);
83 else /* rank has not been set by admin, derive rank from rtt */
84 newRank = (int)(7200 * log(tpeer.rtt) / 5000) * 5000 + 5000;
86 newRank += (rand() & 0x000f); /* randomize */
88 if (abs(newRank - tsp->ipRank) > 0xf) {
89 tsp->ipRank = newRank;
91 lock_ReleaseMutex(&tsp->mx);
95 * find volumes which might have RO copy
96 * on server and change the ordering of
99 cm_ChangeRankVolume(tsp);
102 /* set preferences for an existing vlserver */
103 cm_ChangeRankCellVLServer(tsp);
106 lock_ObtainMutex(&tsp->mx);
114 cm_PingServer(cm_server_t *tsp)
119 struct rx_connection * rxconnp;
122 Capabilities caps = {0, 0};
126 lock_ObtainMutex(&tsp->mx);
127 if (tsp->flags & CM_SERVERFLAG_PINGING) {
129 osi_SleepM((LONG_PTR)tsp, &tsp->mx);
130 lock_ObtainMutex(&tsp->mx);
132 if (tsp->waitCount == 0)
133 tsp->flags &= ~CM_SERVERFLAG_PINGING;
135 osi_Wakeup((LONG_PTR)tsp);
136 lock_ReleaseMutex(&tsp->mx);
139 tsp->flags |= CM_SERVERFLAG_PINGING;
140 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
141 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
142 lock_ReleaseMutex(&tsp->mx);
144 code = cm_ConnByServer(tsp, cm_rootUserp, &connp);
146 /* now call the appropriate ping call. Drop the timeout if
147 * the server is known to be down, so that we don't waste a
148 * lot of time retiming out down servers.
151 osi_Log4(afsd_logp, "cm_PingServer server %s (%s) was %s with caps 0x%x",
152 osi_LogSaveString(afsd_logp, hoststr),
153 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
154 wasDown ? "down" : "up",
157 rxconnp = cm_GetRxConn(connp);
159 rx_SetConnDeadTime(rxconnp, 10);
160 if (tsp->type == CM_SERVER_VLDB) {
161 code = VL_ProbeServer(rxconnp);
165 code = RXAFS_GetCapabilities(rxconnp, &caps);
166 if (code == RXGEN_OPCODE)
167 code = RXAFS_GetTime(rxconnp, &secs, &usecs);
170 rx_SetConnDeadTime(rxconnp, ConnDeadtimeout);
171 rx_PutConnection(rxconnp);
173 } /* got an unauthenticated connection to this server */
175 lock_ObtainMutex(&tsp->mx);
177 /* mark server as up */
178 tsp->flags &= ~CM_SERVERFLAG_DOWN;
181 /* we currently handle 32-bits of capabilities */
182 if (caps.Capabilities_len > 0) {
183 tsp->capabilities = caps.Capabilities_val[0];
184 xdr_free(caps.Capabilities_val, caps.Capabilities_len);
185 caps.Capabilities_len = 0;
186 caps.Capabilities_val = 0;
188 tsp->capabilities = 0;
191 osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is up with caps 0x%x",
192 osi_LogSaveString(afsd_logp, hoststr),
193 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
196 /* Now update the volume status if necessary */
198 cm_server_vols_t * tsrvp;
202 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
203 for (i=0; i<NUM_SERVER_VOLS; i++) {
204 if (tsrvp->ids[i] != 0) {
207 lock_ReleaseMutex(&tsp->mx);
208 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
209 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
210 lock_ObtainMutex(&tsp->mx);
212 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
220 /* mark server as down */
221 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
222 tsp->flags |= CM_SERVERFLAG_DOWN;
223 tsp->downTime = time(NULL);
225 if (code != VRESTARTING) {
226 lock_ReleaseMutex(&tsp->mx);
227 cm_ForceNewConnections(tsp);
228 lock_ObtainMutex(&tsp->mx);
230 osi_Log3(afsd_logp, "cm_PingServer server %s (%s) is down with caps 0x%x",
231 osi_LogSaveString(afsd_logp, hoststr),
232 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
235 /* Now update the volume status if necessary */
237 cm_server_vols_t * tsrvp;
241 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
242 for (i=0; i<NUM_SERVER_VOLS; i++) {
243 if (tsrvp->ids[i] != 0) {
246 lock_ReleaseMutex(&tsp->mx);
247 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
248 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
249 lock_ObtainMutex(&tsp->mx);
251 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
260 if (tsp->waitCount == 0)
261 tsp->flags &= ~CM_SERVERFLAG_PINGING;
263 osi_Wakeup((LONG_PTR)tsp);
264 lock_ReleaseMutex(&tsp->mx);
272 lock_ObtainRead(&cm_serverLock);
273 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
274 cm_GetServerNoLock(tsp);
275 lock_ReleaseRead(&cm_serverLock);
277 lock_ObtainMutex(&tsp->mx);
279 /* if the server is not down, rank the server */
280 if(!(tsp->flags & CM_SERVERFLAG_DOWN))
283 lock_ReleaseMutex(&tsp->mx);
285 lock_ObtainRead(&cm_serverLock);
286 cm_PutServerNoLock(tsp);
288 lock_ReleaseRead(&cm_serverLock);
291 static void cm_CheckServersSingular(afs_uint32 flags, cm_cell_t *cellp)
293 /* ping all file servers, up or down, with unauthenticated connection,
294 * to find out whether we have all our callbacks from the server still.
295 * Also, ping down VLDBs.
303 lock_ObtainRead(&cm_serverLock);
304 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
305 cm_GetServerNoLock(tsp);
306 lock_ReleaseRead(&cm_serverLock);
308 /* now process the server */
309 lock_ObtainMutex(&tsp->mx);
312 isDown = tsp->flags & CM_SERVERFLAG_DOWN;
313 isFS = tsp->type == CM_SERVER_FILE;
314 isVLDB = tsp->type == CM_SERVER_VLDB;
316 /* only do the ping if the cell matches the requested cell, or we're
317 * matching all cells (cellp == NULL), and if we've requested to ping
318 * this type of {up, down} servers.
320 if ((cellp == NULL || cellp == tsp->cellp) &&
321 ((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
322 (!isDown && (flags & CM_FLAG_CHECKUPSERVERS))) &&
323 ((!(flags & CM_FLAG_CHECKVLDBSERVERS) ||
324 isVLDB && (flags & CM_FLAG_CHECKVLDBSERVERS)) &&
325 (!(flags & CM_FLAG_CHECKFILESERVERS) ||
326 isFS && (flags & CM_FLAG_CHECKFILESERVERS)))) {
328 } /* we're supposed to check this up/down server */
329 lock_ReleaseMutex(&tsp->mx);
331 /* at this point, we've adjusted the server state, so do the ping and
337 /* also, run the GC function for connections on all of the
338 * server's connections.
340 cm_GCConnections(tsp);
342 lock_ObtainRead(&cm_serverLock);
343 cm_PutServerNoLock(tsp);
345 lock_ReleaseRead(&cm_serverLock);
348 static void cm_CheckServersMulti(afs_uint32 flags, cm_cell_t *cellp)
351 * The goal of this function is to probe simultaneously
352 * probe all of the up/down servers (vldb/file) as
353 * specified by flags in the minimum number of RPCs.
354 * Effectively that means use one multi_RXAFS_GetCapabilities()
355 * followed by possibly one multi_RXAFS_GetTime() and
356 * one multi_VL_ProbeServer().
358 * To make this work we must construct the list of vldb
359 * and file servers that are to be probed as well as the
360 * associated data structures.
363 int srvAddrCount = 0;
364 struct srvAddr **addrs = NULL;
365 cm_conn_t **conns = NULL;
366 struct rx_connection **rxconns = NULL;
368 afs_int32 i, j, nconns = 0, maxconns;
369 afs_int32 *conntimer, *results;
370 Capabilities *caps = NULL;
371 cm_server_t ** serversp, *tsp;
372 afs_uint32 isDown, wasDown;
374 time_t start, end, *deltas;
380 maxconns = max(cm_numFileServers,cm_numVldbServers);
384 conns = (cm_conn_t **)malloc(maxconns * sizeof(cm_conn_t *));
385 rxconns = (struct rx_connection **)malloc(maxconns * sizeof(struct rx_connection *));
386 conntimer = (afs_int32 *)malloc(maxconns * sizeof (afs_int32));
387 deltas = (time_t *)malloc(maxconns * sizeof (time_t));
388 results = (afs_int32 *)malloc(maxconns * sizeof (afs_int32));
389 serversp = (cm_server_t **)malloc(maxconns * sizeof(cm_server_t *));
390 caps = (Capabilities *)malloc(maxconns * sizeof(Capabilities));
392 memset(caps, 0, maxconns * sizeof(Capabilities));
394 if ((flags & CM_FLAG_CHECKFILESERVERS) ||
395 !(flags & (CM_FLAG_CHECKFILESERVERS|CM_FLAG_CHECKVLDBSERVERS)))
397 lock_ObtainRead(&cm_serverLock);
398 for (nconns=0, tsp = cm_allServersp; tsp && nconns < maxconns; tsp = tsp->allNextp) {
399 if (tsp->type != CM_SERVER_FILE ||
400 tsp->cellp == NULL || /* SetPref only */
401 cellp && cellp != tsp->cellp)
404 cm_GetServerNoLock(tsp);
405 lock_ReleaseRead(&cm_serverLock);
407 lock_ObtainMutex(&tsp->mx);
408 isDown = tsp->flags & CM_SERVERFLAG_DOWN;
410 if ((tsp->flags & CM_SERVERFLAG_PINGING) ||
411 !((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
412 (!isDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
413 lock_ReleaseMutex(&tsp->mx);
414 lock_ObtainRead(&cm_serverLock);
415 cm_PutServerNoLock(tsp);
419 tsp->flags |= CM_SERVERFLAG_PINGING;
420 lock_ReleaseMutex(&tsp->mx);
422 serversp[nconns] = tsp;
423 code = cm_ConnByServer(tsp, cm_rootUserp, &conns[nconns]);
425 lock_ObtainRead(&cm_serverLock);
426 cm_PutServerNoLock(tsp);
429 lock_ObtainRead(&cm_serverLock);
430 rxconns[nconns] = cm_GetRxConn(conns[nconns]);
431 if (conntimer[nconns] = (isDown ? 1 : 0))
432 rx_SetConnDeadTime(rxconns[nconns], 10);
436 lock_ReleaseRead(&cm_serverLock);
439 /* Perform the multi call */
441 multi_Rx(rxconns,nconns)
443 multi_RXAFS_GetCapabilities(&caps[multi_i]);
444 results[multi_i]=multi_error;
448 /* Process results of servers that support RXAFS_GetCapabilities */
449 for (i=0; i<nconns; i++) {
450 /* Leave the servers that did not support GetCapabilities alone */
451 if (results[i] == RXGEN_OPCODE)
455 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
456 rx_PutConnection(rxconns[i]);
457 cm_PutConn(conns[i]);
460 cm_GCConnections(tsp);
462 lock_ObtainMutex(&tsp->mx);
463 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
465 if (results[i] >= 0) {
466 /* mark server as up */
467 tsp->flags &= ~CM_SERVERFLAG_DOWN;
470 /* we currently handle 32-bits of capabilities */
471 if (caps[i].Capabilities_len > 0) {
472 tsp->capabilities = caps[i].Capabilities_val[0];
473 xdr_free(caps[i].Capabilities_val, caps[i].Capabilities_len);
474 caps[i].Capabilities_len = 0;
475 caps[i].Capabilities_val = 0;
477 tsp->capabilities = 0;
480 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
481 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
482 osi_LogSaveString(afsd_logp, hoststr),
483 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
486 /* Now update the volume status if necessary */
488 cm_server_vols_t * tsrvp;
492 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
493 for (i=0; i<NUM_SERVER_VOLS; i++) {
494 if (tsrvp->ids[i] != 0) {
497 lock_ReleaseMutex(&tsp->mx);
498 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
499 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
500 lock_ObtainMutex(&tsp->mx);
502 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
510 /* mark server as down */
511 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
512 tsp->flags |= CM_SERVERFLAG_DOWN;
513 tsp->downTime = time(NULL);
515 if (code != VRESTARTING) {
516 lock_ReleaseMutex(&tsp->mx);
517 cm_ForceNewConnections(tsp);
518 lock_ObtainMutex(&tsp->mx);
520 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
521 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
522 osi_LogSaveString(afsd_logp, hoststr),
523 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
526 /* Now update the volume status if necessary */
528 cm_server_vols_t * tsrvp;
532 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
533 for (i=0; i<NUM_SERVER_VOLS; i++) {
534 if (tsrvp->ids[i] != 0) {
537 lock_ReleaseMutex(&tsp->mx);
538 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
539 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
540 lock_ObtainMutex(&tsp->mx);
542 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
551 if (tsp->waitCount == 0)
552 tsp->flags &= ~CM_SERVERFLAG_PINGING;
554 osi_Wakeup((LONG_PTR)tsp);
556 lock_ReleaseMutex(&tsp->mx);
562 * At this point we have handled any responses that did not indicate
563 * that RXAFS_GetCapabilities is not supported.
565 for ( i=0, j=0; i<nconns; i++) {
566 if (results[i] == RXGEN_OPCODE) {
569 rxconns[j] = rxconns[i];
570 serversp[j] = serversp[i];
578 /* Perform the multi call */
580 multi_Rx(rxconns,nconns)
583 multi_RXAFS_GetTime(&secs, &usecs);
585 results[multi_i]=multi_error;
586 if ((start == end) && !multi_error)
587 deltas[multi_i] = end - secs;
591 /* Process Results of servers that only support RXAFS_GetTime */
592 for (i=0; i<nconns; i++) {
593 /* Leave the servers that did not support GetCapabilities alone */
595 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
596 rx_PutConnection(rxconns[i]);
597 cm_PutConn(conns[i]);
600 cm_GCConnections(tsp);
602 lock_ObtainMutex(&tsp->mx);
603 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
605 if (results[i] >= 0) {
606 /* mark server as up */
607 tsp->flags &= ~CM_SERVERFLAG_DOWN;
609 tsp->capabilities = 0;
611 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
612 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
613 osi_LogSaveString(afsd_logp, hoststr),
614 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
617 /* Now update the volume status if necessary */
619 cm_server_vols_t * tsrvp;
623 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
624 for (i=0; i<NUM_SERVER_VOLS; i++) {
625 if (tsrvp->ids[i] != 0) {
628 lock_ReleaseMutex(&tsp->mx);
629 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
630 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
631 lock_ObtainMutex(&tsp->mx);
633 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
641 /* mark server as down */
642 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
643 tsp->flags |= CM_SERVERFLAG_DOWN;
644 tsp->downTime = time(NULL);
646 if (code != VRESTARTING) {
647 lock_ReleaseMutex(&tsp->mx);
648 cm_ForceNewConnections(tsp);
649 lock_ObtainMutex(&tsp->mx);
651 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
652 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
653 osi_LogSaveString(afsd_logp, hoststr),
654 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
657 /* Now update the volume status if necessary */
659 cm_server_vols_t * tsrvp;
663 for (tsrvp = tsp->vols; tsrvp; tsrvp = tsrvp->nextp) {
664 for (i=0; i<NUM_SERVER_VOLS; i++) {
665 if (tsrvp->ids[i] != 0) {
668 lock_ReleaseMutex(&tsp->mx);
669 code = cm_FindVolumeByID(tsp->cellp, tsrvp->ids[i], cm_rootUserp,
670 &req, CM_GETVOL_FLAG_NO_LRU_UPDATE, &volp);
671 lock_ObtainMutex(&tsp->mx);
673 cm_UpdateVolumeStatus(volp, tsrvp->ids[i]);
682 if (tsp->waitCount == 0)
683 tsp->flags &= ~CM_SERVERFLAG_PINGING;
685 osi_Wakeup((LONG_PTR)tsp);
687 lock_ReleaseMutex(&tsp->mx);
693 if ((flags & CM_FLAG_CHECKVLDBSERVERS) ||
694 !(flags & (CM_FLAG_CHECKFILESERVERS|CM_FLAG_CHECKVLDBSERVERS)))
696 lock_ObtainRead(&cm_serverLock);
697 for (nconns=0, tsp = cm_allServersp; tsp && nconns < maxconns; tsp = tsp->allNextp) {
698 if (tsp->type != CM_SERVER_VLDB ||
699 tsp->cellp == NULL || /* SetPref only */
700 cellp && cellp != tsp->cellp)
703 cm_GetServerNoLock(tsp);
704 lock_ReleaseRead(&cm_serverLock);
706 lock_ObtainMutex(&tsp->mx);
707 isDown = tsp->flags & CM_SERVERFLAG_DOWN;
709 if ((tsp->flags & CM_SERVERFLAG_PINGING) ||
710 !((isDown && (flags & CM_FLAG_CHECKDOWNSERVERS)) ||
711 (!isDown && (flags & CM_FLAG_CHECKUPSERVERS)))) {
712 lock_ReleaseMutex(&tsp->mx);
713 lock_ObtainRead(&cm_serverLock);
714 cm_PutServerNoLock(tsp);
718 tsp->flags |= CM_SERVERFLAG_PINGING;
719 lock_ReleaseMutex(&tsp->mx);
721 serversp[nconns] = tsp;
722 code = cm_ConnByServer(tsp, cm_rootUserp, &conns[nconns]);
724 lock_ObtainRead(&cm_serverLock);
725 cm_PutServerNoLock(tsp);
728 lock_ObtainRead(&cm_serverLock);
729 rxconns[nconns] = cm_GetRxConn(conns[nconns]);
730 conntimer[nconns] = (isDown ? 1 : 0);
732 rx_SetConnDeadTime(rxconns[nconns], 10);
736 lock_ReleaseRead(&cm_serverLock);
739 /* Perform the multi call */
741 multi_Rx(rxconns,nconns)
743 multi_VL_ProbeServer();
744 results[multi_i]=multi_error;
748 /* Process results of servers that support VL_ProbeServer */
749 for (i=0; i<nconns; i++) {
751 rx_SetConnDeadTime(rxconns[i], ConnDeadtimeout);
752 rx_PutConnection(rxconns[i]);
753 cm_PutConn(conns[i]);
756 cm_GCConnections(tsp);
758 lock_ObtainMutex(&tsp->mx);
759 wasDown = tsp->flags & CM_SERVERFLAG_DOWN;
761 if (results[i] >= 0) {
762 /* mark server as up */
763 tsp->flags &= ~CM_SERVERFLAG_DOWN;
765 tsp->capabilities = 0;
767 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
768 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is up with caps 0x%x",
769 osi_LogSaveString(afsd_logp, hoststr),
770 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
773 /* mark server as down */
774 if (!(tsp->flags & CM_SERVERFLAG_DOWN)) {
775 tsp->flags |= CM_SERVERFLAG_DOWN;
776 tsp->downTime = time(NULL);
778 if (code != VRESTARTING) {
779 lock_ReleaseMutex(&tsp->mx);
780 cm_ForceNewConnections(tsp);
781 lock_ObtainMutex(&tsp->mx);
783 afs_inet_ntoa_r(tsp->addr.sin_addr.S_un.S_addr, hoststr);
784 osi_Log3(afsd_logp, "cm_MultiPingServer server %s (%s) is down with caps 0x%x",
785 osi_LogSaveString(afsd_logp, hoststr),
786 tsp->type == CM_SERVER_VLDB ? "vldb" : "file",
790 if (tsp->waitCount == 0)
791 tsp->flags &= ~CM_SERVERFLAG_PINGING;
793 osi_Wakeup((LONG_PTR)tsp);
795 lock_ReleaseMutex(&tsp->mx);
810 void cm_CheckServers(afs_uint32 flags, cm_cell_t *cellp)
817 code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
818 0, KEY_QUERY_VALUE, &parmKey);
819 if (code == ERROR_SUCCESS) {
820 dummyLen = sizeof(multi);
821 code = RegQueryValueEx(parmKey, "MultiCheckServers", NULL, NULL,
822 (BYTE *) &multi, &dummyLen);
823 RegCloseKey (parmKey);
827 cm_CheckServersMulti(flags, cellp);
829 cm_CheckServersSingular(flags, cellp);
832 void cm_InitServer(void)
834 static osi_once_t once;
836 if (osi_Once(&once)) {
837 lock_InitializeRWLock(&cm_serverLock, "cm_serverLock", LOCK_HIERARCHY_SERVER_GLOBAL);
838 lock_InitializeRWLock(&cm_syscfgLock, "cm_syscfgLock", LOCK_HIERARCHY_SYSCFG_GLOBAL);
843 /* Protected by cm_syscfgLock (rw) */
844 int cm_noIPAddr; /* number of client network interfaces */
845 int cm_IPAddr[CM_MAXINTERFACE_ADDR]; /* client's IP address in host order */
846 int cm_SubnetMask[CM_MAXINTERFACE_ADDR];/* client's subnet mask in host order*/
847 int cm_NetMtu[CM_MAXINTERFACE_ADDR]; /* client's MTU sizes */
848 int cm_NetFlags[CM_MAXINTERFACE_ADDR]; /* network flags */
849 int cm_LanAdapterChangeDetected = 1;
851 void cm_SetLanAdapterChangeDetected(void)
853 lock_ObtainWrite(&cm_syscfgLock);
854 cm_LanAdapterChangeDetected = 1;
855 lock_ReleaseWrite(&cm_syscfgLock);
858 void cm_GetServer(cm_server_t *serverp)
860 lock_ObtainRead(&cm_serverLock);
861 InterlockedIncrement(&serverp->refCount);
862 lock_ReleaseRead(&cm_serverLock);
865 void cm_GetServerNoLock(cm_server_t *serverp)
867 InterlockedIncrement(&serverp->refCount);
870 void cm_PutServer(cm_server_t *serverp)
873 lock_ObtainRead(&cm_serverLock);
874 refCount = InterlockedDecrement(&serverp->refCount);
875 osi_assertx(refCount >= 0, "cm_server_t refCount underflow");
876 lock_ReleaseRead(&cm_serverLock);
879 void cm_PutServerNoLock(cm_server_t *serverp)
881 afs_int32 refCount = InterlockedDecrement(&serverp->refCount);
882 osi_assertx(refCount >= 0, "cm_server_t refCount underflow");
885 void cm_SetServerNo64Bit(cm_server_t * serverp, int no64bit)
887 lock_ObtainMutex(&serverp->mx);
889 serverp->flags |= CM_SERVERFLAG_NO64BIT;
891 serverp->flags &= ~CM_SERVERFLAG_NO64BIT;
892 lock_ReleaseMutex(&serverp->mx);
895 void cm_SetServerNoInlineBulk(cm_server_t * serverp, int no)
897 lock_ObtainMutex(&serverp->mx);
899 serverp->flags |= CM_SERVERFLAG_NOINLINEBULK;
901 serverp->flags &= ~CM_SERVERFLAG_NOINLINEBULK;
902 lock_ReleaseMutex(&serverp->mx);
905 void cm_SetServerPrefs(cm_server_t * serverp)
907 unsigned long serverAddr; /* in host byte order */
908 unsigned long myAddr, myNet, mySubnet;/* in host byte order */
909 unsigned long netMask;
914 lock_ObtainRead(&cm_syscfgLock);
915 if (cm_LanAdapterChangeDetected) {
916 lock_ConvertRToW(&cm_syscfgLock);
918 if (cm_LanAdapterChangeDetected) {
919 /* get network related info */
920 cm_noIPAddr = CM_MAXINTERFACE_ADDR;
921 code = syscfg_GetIFInfo(&cm_noIPAddr,
922 cm_IPAddr, cm_SubnetMask,
923 cm_NetMtu, cm_NetFlags);
924 cm_LanAdapterChangeDetected = 0;
926 lock_ConvertWToR(&cm_syscfgLock);
929 serverAddr = ntohl(serverp->addr.sin_addr.s_addr);
930 serverp->ipRank = CM_IPRANK_LOW; /* default settings */
932 for ( i=0; i < cm_noIPAddr; i++)
934 /* loop through all the client's IP address and compare
935 ** each of them against the server's IP address */
937 myAddr = cm_IPAddr[i];
938 if ( IN_CLASSA(myAddr) )
939 netMask = IN_CLASSA_NET;
940 else if ( IN_CLASSB(myAddr) )
941 netMask = IN_CLASSB_NET;
942 else if ( IN_CLASSC(myAddr) )
943 netMask = IN_CLASSC_NET;
947 myNet = myAddr & netMask;
948 mySubnet = myAddr & cm_SubnetMask[i];
950 if ( (serverAddr & netMask) == myNet )
952 if ( (serverAddr & cm_SubnetMask[i]) == mySubnet)
954 if ( serverAddr == myAddr )
955 serverp->ipRank = min(serverp->ipRank,
956 CM_IPRANK_TOP);/* same machine */
957 else serverp->ipRank = min(serverp->ipRank,
958 CM_IPRANK_HI); /* same subnet */
960 else serverp->ipRank = min(serverp->ipRank,CM_IPRANK_MED);
963 } /* and of for loop */
965 /* random between 0..15*/
966 serverp->ipRank += (rand() % 0x000f);
967 lock_ReleaseRead(&cm_syscfgLock);
970 cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp, afsUUID *uuidp, afs_uint32 flags) {
973 osi_assertx(socketp->sin_family == AF_INET, "unexpected socket family");
975 tsp = malloc(sizeof(*tsp));
977 memset(tsp, 0, sizeof(*tsp));
980 if (uuidp && !afs_uuid_is_nil(uuidp)) {
982 tsp->flags |= CM_SERVERFLAG_UUID;
985 lock_InitializeMutex(&tsp->mx, "cm_server_t mutex", LOCK_HIERARCHY_SERVER);
986 tsp->addr = *socketp;
988 cm_SetServerPrefs(tsp);
990 lock_ObtainWrite(&cm_serverLock); /* get server lock */
991 tsp->allNextp = cm_allServersp;
992 cm_allServersp = tsp;
1003 lock_ReleaseWrite(&cm_serverLock); /* release server lock */
1005 if ( !(flags & CM_FLAG_NOPROBE) ) {
1006 tsp->flags |= CM_SERVERFLAG_DOWN; /* assume down; ping will mark up if available */
1007 cm_PingServer(tsp); /* Obtain Capabilities and check up/down state */
1014 cm_FindServerByIP(afs_uint32 ipaddr, unsigned short port, int type)
1018 lock_ObtainRead(&cm_serverLock);
1019 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
1020 if (tsp->type == type &&
1021 tsp->addr.sin_addr.S_un.S_addr == ipaddr &&
1022 (tsp->addr.sin_port == port || tsp->addr.sin_port == 0))
1026 /* bump ref count if we found the server */
1028 cm_GetServerNoLock(tsp);
1030 lock_ReleaseRead(&cm_serverLock);
1036 cm_FindServerByUuid(afsUUID *serverUuid, int type)
1040 lock_ObtainRead(&cm_serverLock);
1041 for (tsp = cm_allServersp; tsp; tsp = tsp->allNextp) {
1042 if (tsp->type == type && !afs_uuid_equal(&tsp->uuid, serverUuid))
1046 /* bump ref count if we found the server */
1048 cm_GetServerNoLock(tsp);
1050 lock_ReleaseRead(&cm_serverLock);
1055 /* find a server based on its properties */
1056 cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
1060 osi_assertx(addrp->sin_family == AF_INET, "unexpected socket value");
1062 lock_ObtainRead(&cm_serverLock);
1063 for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {
1064 if (tsp->type == type &&
1065 tsp->addr.sin_addr.s_addr == addrp->sin_addr.s_addr &&
1066 (tsp->addr.sin_port == addrp->sin_port || tsp->addr.sin_port == 0))
1070 /* bump ref count if we found the server */
1072 cm_GetServerNoLock(tsp);
1074 /* drop big table lock */
1075 lock_ReleaseRead(&cm_serverLock);
1077 /* return what we found */
1081 cm_server_vols_t *cm_NewServerVols(void) {
1082 cm_server_vols_t *tsvp;
1084 tsvp = malloc(sizeof(*tsvp));
1086 memset(tsvp, 0, sizeof(*tsvp));
1091 cm_serverRef_t *cm_NewServerRef(cm_server_t *serverp, afs_uint32 volID)
1093 cm_serverRef_t *tsrp;
1094 cm_server_vols_t **tsrvpp = NULL;
1095 afs_uint32 *slotp = NULL;
1098 cm_GetServer(serverp);
1099 tsrp = malloc(sizeof(*tsrp));
1100 tsrp->server = serverp;
1101 tsrp->status = srv_not_busy;
1103 tsrp->volID = volID;
1106 /* if we have a non-zero volID, we need to add it to the list
1107 * of volumes maintained by the server. There are two phases:
1108 * (1) see if the volID is already in the list and (2) insert
1109 * it into the first empty slot if it is not.
1112 lock_ObtainMutex(&serverp->mx);
1114 tsrvpp = &serverp->vols;
1118 for (i=0; i<NUM_SERVER_VOLS; i++) {
1119 if ((*tsrvpp)->ids[i] == volID) {
1122 } else if (!slotp && (*tsrvpp)->ids[i] == 0) {
1123 slotp = &(*tsrvpp)->ids[i];
1130 tsrvpp = &(*tsrvpp)->nextp;
1137 /* if we didn't find an empty slot in a current
1138 * page we must need a new page */
1139 *tsrvpp = cm_NewServerVols();
1141 (*tsrvpp)->ids[0] = volID;
1145 lock_ReleaseMutex(&serverp->mx);
1151 LONG_PTR cm_ChecksumServerList(cm_serverRef_t *serversp)
1155 cm_serverRef_t *tsrp;
1157 lock_ObtainRead(&cm_serverLock);
1158 for (tsrp = serversp; tsrp; tsrp=tsrp->next) {
1159 if (tsrp->status == srv_deleted)
1165 sum ^= (LONG_PTR) tsrp->server;
1168 lock_ReleaseRead(&cm_serverLock);
1173 ** Insert a server into the server list keeping the list sorted in
1174 ** ascending order of ipRank.
1176 ** The refCount of the cm_serverRef_t is increased
1178 void cm_InsertServerList(cm_serverRef_t** list, cm_serverRef_t* element)
1180 cm_serverRef_t *current=*list;
1181 unsigned short ipRank = element->server->ipRank;
1183 lock_ObtainWrite(&cm_serverLock);
1184 element->refCount++; /* increase refCount */
1186 /* insertion into empty list or at the beginning of the list */
1187 if ( !current || (current->server->ipRank > ipRank) )
1189 element->next = *list;
1191 lock_ReleaseWrite(&cm_serverLock);
1195 while ( current->next ) /* find appropriate place to insert */
1197 if ( current->next->server->ipRank > ipRank )
1199 else current = current->next;
1201 element->next = current->next;
1202 current->next = element;
1203 lock_ReleaseWrite(&cm_serverLock);
1206 ** Re-sort the server list with the modified rank
1207 ** returns 0 if element was changed successfully.
1208 ** returns 1 if list remained unchanged.
1210 long cm_ChangeRankServer(cm_serverRef_t** list, cm_server_t* server)
1212 cm_serverRef_t **current=list;
1213 cm_serverRef_t *element=0;
1215 /* if there is max of one element in the list, nothing to sort */
1216 if ( (!*current) || !((*current)->next) )
1217 return 1; /* list unchanged: return success */
1219 lock_ObtainWrite(&cm_serverLock);
1220 /* if the server is on the list, delete it from list */
1223 if ( (*current)->server == server)
1225 element = (*current);
1226 *current = (*current)->next; /* delete it */
1229 current = & ( (*current)->next);
1231 lock_ReleaseWrite(&cm_serverLock);
1233 /* if this volume is not replicated on this server */
1235 return 1; /* server is not on list */
1237 /* re-insert deleted element into the list with modified rank*/
1238 cm_InsertServerList(list, element);
1240 /* reduce refCount which was increased by cm_InsertServerList */
1241 lock_ObtainWrite(&cm_serverLock);
1242 element->refCount--;
1243 lock_ReleaseWrite(&cm_serverLock);
1247 ** If there are more than one server on the list and the first n servers on
1248 ** the list have the same rank( n>1), then randomise among the first n servers.
1250 void cm_RandomizeServer(cm_serverRef_t** list)
1253 cm_serverRef_t* tsrp = *list, *lastTsrp;
1254 unsigned short lowestRank;
1256 /* an empty list or a list with only one element */
1257 if ( !tsrp || ! tsrp->next )
1260 lock_ObtainWrite(&cm_serverLock);
1262 /* count the number of servers with the lowest rank */
1263 lowestRank = tsrp->server->ipRank;
1264 for ( count=1, tsrp=tsrp->next; tsrp; tsrp=tsrp->next)
1266 if ( tsrp->server->ipRank != lowestRank)
1272 /* if there is only one server with the lowest rank, we are done */
1274 lock_ReleaseWrite(&cm_serverLock);
1278 picked = rand() % count;
1280 lock_ReleaseWrite(&cm_serverLock);
1285 while (--picked >= 0)
1290 lastTsrp->next = tsrp->next; /* delete random element from list*/
1291 tsrp->next = *list; /* insert element at the beginning of list */
1293 lock_ReleaseWrite(&cm_serverLock);
1296 /* call cm_FreeServer while holding a write lock on cm_serverLock */
1297 void cm_FreeServer(cm_server_t* serverp)
1299 cm_server_vols_t * tsrvp, *nextp;
1302 cm_PutServerNoLock(serverp);
1303 if (serverp->refCount == 0)
1306 * we need to check to ensure that all of the connections
1307 * for this server have a 0 refCount; otherwise, they will
1308 * not be garbage collected
1310 * must drop the cm_serverLock because cm_GCConnections
1311 * obtains the cm_connLock and that comes first in the
1314 lock_ReleaseWrite(&cm_serverLock);
1315 cm_GCConnections(serverp); /* connsp */
1316 lock_ObtainWrite(&cm_serverLock);
1321 * Once we have the cm_serverLock locked check to make
1322 * sure the refCount is still zero before removing the
1325 if (serverp->refCount == 0) {
1326 if (!(serverp->flags & CM_SERVERFLAG_PREF_SET)) {
1327 switch (serverp->type) {
1328 case CM_SERVER_VLDB:
1329 cm_numVldbServers--;
1331 case CM_SERVER_FILE:
1332 cm_numFileServers--;
1336 lock_FinalizeMutex(&serverp->mx);
1337 if ( cm_allServersp == serverp )
1338 cm_allServersp = serverp->allNextp;
1342 for(tsp = cm_allServersp; tsp->allNextp; tsp=tsp->allNextp) {
1343 if ( tsp->allNextp == serverp ) {
1344 tsp->allNextp = serverp->allNextp;
1350 /* free the volid list */
1351 for ( tsrvp = serverp->vols; tsrvp; tsrvp = nextp) {
1352 nextp = tsrvp->nextp;
1361 /* Called with cm_serverLock write locked */
1362 void cm_RemoveVolumeFromServer(cm_server_t * serverp, afs_uint32 volID)
1364 cm_server_vols_t * tsrvp;
1370 for (tsrvp = serverp->vols; tsrvp; tsrvp = tsrvp->nextp) {
1371 for (i=0; i<NUM_SERVER_VOLS; i++) {
1372 if (tsrvp->ids[i] == volID) {
1380 void cm_FreeServerList(cm_serverRef_t** list, afs_uint32 flags)
1382 cm_serverRef_t **current = list;
1383 cm_serverRef_t **nextp = 0;
1384 cm_serverRef_t * next = 0;
1389 lock_ObtainWrite(&cm_serverLock);
1393 nextp = &(*current)->next;
1394 if (--((*current)->refCount) == 0) {
1397 if ((*current)->volID)
1398 cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1399 cm_FreeServer((*current)->server);
1403 if (flags & CM_FREESERVERLIST_DELETE) {
1404 (*current)->status = srv_deleted;
1405 if ((*current)->volID)
1406 cm_RemoveVolumeFromServer((*current)->server, (*current)->volID);
1412 lock_ReleaseWrite(&cm_serverLock);
1415 /* dump all servers to a file.
1416 * cookie is used to identify this batch for easy parsing,
1417 * and it a string provided by a caller
1419 int cm_DumpServers(FILE *outputFile, char *cookie, int lock)
1428 lock_ObtainRead(&cm_serverLock);
1431 "%s - dumping servers - cm_numFileServers=%d, cm_numVldbServers=%d\r\n",
1432 cookie, cm_numFileServers, cm_numVldbServers);
1433 WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1435 for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp)
1440 switch (tsp->type) {
1441 case CM_SERVER_VLDB:
1444 case CM_SERVER_FILE:
1451 afsUUID_to_string(&tsp->uuid, uuidstr, sizeof(uuidstr));
1452 afs_inet_ntoa_r(tsp->addr.sin_addr.s_addr, hoststr);
1453 down = ctime(&tsp->downTime);
1454 down[strlen(down)-1] = '\0';
1457 "%s - tsp=0x%p cell=%s addr=%-15s port=%u uuid=%s type=%s caps=0x%x "
1458 "flags=0x%x waitCount=%u rank=%u downTime=\"%s\" refCount=%u\r\n",
1459 cookie, tsp, tsp->cellp ? tsp->cellp->name : "", hoststr,
1460 ntohs(tsp->addr.sin_port), uuidstr, type,
1461 tsp->capabilities, tsp->flags, tsp->waitCount, tsp->ipRank,
1462 (tsp->flags & CM_SERVERFLAG_DOWN) ? down : "up",
1464 WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1466 sprintf(output, "%s - Done dumping servers.\r\n", cookie);
1467 WriteFile(outputFile, output, (DWORD)strlen(output), &zilch, NULL);
1470 lock_ReleaseRead(&cm_serverLock);
1476 * Determine if two servers are in fact the same.
1478 * Returns 1 if they match, 0 if they do not
1480 int cm_ServerEqual(cm_server_t *srv1, cm_server_t *srv2)
1484 if (srv1 == NULL || srv2 == NULL)
1490 if (srv1->flags & CM_SERVERFLAG_UUID) {
1491 if (!(srv2->flags & CM_SERVERFLAG_UUID))
1494 /* Both support UUID */
1495 if (UuidEqual((UUID *)&srv1->uuid, (UUID *)&srv2->uuid, &status))