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 <afsconfig.h>
11 #include <afs/param.h>
16 #ifdef AFS_PTHREAD_ENV
17 # include <opr/lock.h>
19 # include <opr/lockstub.h>
25 #include <rx/rx_multi.h>
26 #include <afs/cellconfig.h>
28 #include <afs/afsutil.h>
31 #define UBIK_INTERNALS
35 /* These global variables were used to set the function to use to initialise
36 * the client security layer. They are retained for backwards compatiblity with
37 * legacy callers - the ubik_SetClientSecurityProcs() interface should be used
40 int (*ubik_CRXSecurityProc) (void *rock, struct rx_securityClass **,
42 void *ubik_CRXSecurityRock;
44 /*! \name statics used to determine if we're the sync site */
45 static int nServers; /*!< total number of servers */
46 static char amIMagic = 0; /*!< is this host the magic host */
47 char amIClone = 0; /*!< is this a clone which doesn't vote */
48 static char ubik_singleServer = 0;
50 static int (*secLayerProc) (void *rock, struct rx_securityClass **,
52 static int (*tokenCheckProc) (void *rock) = NULL;
53 static void * securityRock = NULL;
55 afs_int32 ubikSecIndex;
56 struct rx_securityClass *ubikSecClass;
58 /* Values protected by the address lock */
59 struct addr_data addr_globals;
61 /* Values protected by the beacon lock */
62 struct beacon_data beacon_globals;
64 static int ubeacon_InitServerListCommon(afs_uint32 ame,
65 struct afsconf_cell *info,
67 afs_uint32 aservers[]);
68 static int verifyInterfaceAddress(afs_uint32 *ame, struct afsconf_cell *info,
69 afs_uint32 aservers[]);
72 * Module responsible for both deciding if we're currently the sync site,
73 * and keeping collecting votes so as to stay sync site.
75 * The basic module contacts all of the servers it can, trying to get them to vote
76 * for this server for sync site. The vote request message (called a beacon message)
77 * also specifies until which time this site claims to be the sync site, if at all, thus enabling
78 * receiving sites to know how long the sync site guarantee is made for.
80 * Each of these beacon messages is thus both a declaration of how long this site will
81 * remain sync site, and an attempt to extend that time by collecting votes for a later
82 * sync site extension.
84 * The voting module is responsible for choosing a reasonable time until which it promises
85 * not to vote for someone else. This parameter (BIG seconds) is not actually passed in
86 * the interface (perhaps it should be?) but is instead a compile time constant that both
89 * The beacon and vote modules work intimately together; the vote module decides how long
90 * it should promise the beacon module its vote, and the beacon module takes all of these
91 * votes and decides for how long it is the synchronization site.
94 /*! \brief procedure called from debug rpc call to get this module's state for debugging */
96 ubeacon_Debug(struct ubik_debug *aparm)
98 /* fill in beacon's state fields in the ubik_debug structure */
99 aparm->syncSiteUntil = beacon_globals.syncSiteUntil;
100 aparm->nServers = nServers;
109 /* special case for fast startup */
110 if (nServers == 1 && !amIClone)
111 return 1; /* one guy is always the sync site */
114 if (beacon_globals.ubik_amSyncSite == 0 || amIClone)
115 rcode = 0; /* if I don't think I'm the sync site, say so */
117 now = FT_ApproxTime();
118 if (beacon_globals.syncSiteUntil <= now) { /* if my votes have expired, say so */
119 if (beacon_globals.ubik_amSyncSite)
120 ubik_dprint("Ubik: I am no longer the sync site\n");
121 beacon_globals.ubik_amSyncSite = 0;
122 beacon_globals.ubik_syncSiteAdvertised = 0;
125 rcode = 1; /* otherwise still have the required votes */
129 ubik_dprint("beacon: amSyncSite is %d\n", rcode);
134 * \brief Procedure that determines whether this site has enough current votes to remain sync site.
136 * Called from higher-level modules (everything but the vote module).
138 * If we're the sync site, check that our guarantees, obtained by the ubeacon_Interact()
139 * light-weight process, haven't expired. We're sync site as long as a majority of the
140 * servers in existence have promised us unexpired guarantees. The variable #ubik_syncSiteUntil
141 * contains the time at which the latest of the majority of the sync site guarantees expires
142 * (if the variable #ubik_amSyncSite is true)
143 * This module also calls up to the recovery module if it thinks that the recovery module
144 * may have to pick up a new database (which offucr sif [sic] we lose the sync site votes).
146 * \return 1 if local site is the sync site
147 * \return 0 if sync site is elsewhere
150 ubeacon_AmSyncSite(void)
154 rcode = amSyncSite();
157 urecovery_ResetState();
163 * \brief Determine whether at least quorum are aware we have a sync-site.
165 * Called from higher-level modules.
167 * There is a gap between the time when a new sync-site is elected and the time
168 * when the remotes are aware of that. Therefore, any write transaction between
169 * this gap will fail. This will force a new re-election which might be time
170 * consuming. This procedure determines whether the remotes (quorum) are aware
171 * we have a sync-site.
173 * \return 1 if remotes are aware we have a sync-site
174 * \return 0 if remotes are not aware we have a sync-site
177 ubeacon_SyncSiteAdvertised(void)
182 rcode = beacon_globals.ubik_syncSiteAdvertised;
189 * \see ubeacon_InitServerListCommon()
192 ubeacon_InitServerListByInfo(afs_uint32 ame, struct afsconf_cell *info,
197 code = ubeacon_InitServerListCommon(ame, info, clones, 0);
202 * \param ame "address of me"
203 * \param aservers list of other servers
205 * \see ubeacon_InitServerListCommon()
208 ubeacon_InitServerList(afs_uint32 ame, afs_uint32 aservers[])
213 ubeacon_InitServerListCommon(ame, (struct afsconf_cell *)0, 0,
218 /* Must be called with address lock held */
220 ubeacon_InitSecurityClass(void)
223 /* get the security index to use, if we can */
225 i = (*secLayerProc) (securityRock, &addr_globals.ubikSecClass, &addr_globals.ubikSecIndex);
226 } else if (ubik_CRXSecurityProc) {
227 i = (*ubik_CRXSecurityProc) (ubik_CRXSecurityRock, &addr_globals.ubikSecClass,
228 &addr_globals.ubikSecIndex);
232 /* don't have sec module yet */
233 addr_globals.ubikSecIndex = 0;
234 addr_globals.ubikSecClass = rxnull_NewClientSecurityObject();
239 ubeacon_ReinitServer(struct ubik_server *ts)
241 if (tokenCheckProc && !(*tokenCheckProc) (securityRock)) {
242 struct rx_connection *disk_rxcid;
243 struct rx_connection *vote_rxcid;
244 struct rx_connection *tmp;
246 ubeacon_InitSecurityClass();
248 rx_NewConnection(rx_HostOf(rx_PeerOf(ts->disk_rxcid)),
249 ubik_callPortal, DISK_SERVICE_ID,
250 addr_globals.ubikSecClass, addr_globals.ubikSecIndex);
252 tmp = ts->disk_rxcid;
253 ts->disk_rxcid = disk_rxcid;
254 rx_PutConnection(tmp);
257 rx_NewConnection(rx_HostOf(rx_PeerOf(ts->vote_rxcid)),
258 ubik_callPortal, VOTE_SERVICE_ID,
259 addr_globals.ubikSecClass, addr_globals.ubikSecIndex);
261 tmp = ts->vote_rxcid;
262 ts->vote_rxcid = vote_rxcid;
263 rx_PutConnection(tmp);
270 * \brief setup server list
272 * \param ame "address of me"
273 * \param aservers list of other servers
275 * called only at initialization to set up the list of servers to
276 * contact for votes. Just creates the server structure.
278 * The "magic" host is the one with the lowest internet address. It is
279 * magic because its vote counts epsilon more than the others. This acts
280 * as a tie-breaker when we have an even number of hosts in the system.
281 * For example, if the "magic" host is up in a 2 site system, then it
282 * is sync site. Without the magic host hack, if anyone crashed in a 2
283 * site system, we'd be out of business.
285 * \note There are two connections in every server structure, one for
286 * vote calls (which must always go through quickly) and one for database
287 * operations, which are subject to waiting for locks. If we used only
288 * one, the votes would sometimes get held up behind database operations,
289 * and the sync site guarantees would timeout even though the host would be
290 * up for communication.
292 * \see ubeacon_InitServerList(), ubeacon_InitServerListByInfo()
295 ubeacon_InitServerListCommon(afs_uint32 ame, struct afsconf_cell *info,
296 char clones[], afs_uint32 aservers[])
298 struct ubik_server *ts;
303 struct ubik_server *magicServer;
305 /* verify that the addresses passed in are correct */
306 if ((code = verifyInterfaceAddress(&ame, info, aservers)))
309 ubeacon_InitSecurityClass();
311 magicHost = ntohl(ame); /* do comparisons in host order */
312 magicServer = (struct ubik_server *)0;
315 for (i = 0; i < info->numServers; i++) {
316 if (ntohl((afs_uint32) info->hostAddr[i].sin_addr.s_addr) ==
317 ntohl((afs_uint32) ame)) {
326 for (i = 0; i < info->numServers; i++) {
329 ts = calloc(1, sizeof(struct ubik_server));
330 ts->next = ubik_servers;
332 ts->addr[0] = info->hostAddr[i].sin_addr.s_addr;
337 || ntohl((afs_uint32) ts->addr[0]) <
338 (afs_uint32) magicHost) {
339 magicHost = ntohl(ts->addr[0]);
346 rx_NewConnection(info->hostAddr[i].sin_addr.s_addr,
347 ubik_callPortal, VOTE_SERVICE_ID,
348 addr_globals.ubikSecClass, addr_globals.ubikSecIndex);
351 rx_NewConnection(info->hostAddr[i].sin_addr.s_addr,
352 ubik_callPortal, DISK_SERVICE_ID,
353 addr_globals.ubikSecClass, addr_globals.ubikSecIndex);
358 while ((servAddr = *aservers++)) {
360 return UNHOSTS; /* too many hosts */
361 ts = calloc(1, sizeof(struct ubik_server));
362 ts->next = ubik_servers;
364 ts->addr[0] = servAddr; /* primary address in net byte order */
365 ts->vote_rxcid = rx_NewConnection(servAddr, ubik_callPortal, VOTE_SERVICE_ID,
366 addr_globals.ubikSecClass, addr_globals.ubikSecIndex); /* for vote reqs */
367 ts->disk_rxcid = rx_NewConnection(servAddr, ubik_callPortal, DISK_SERVICE_ID,
368 addr_globals.ubikSecClass, addr_globals.ubikSecIndex); /* for disk reqs */
369 ts->isClone = 0; /* don't know about clones */
371 if (ntohl((afs_uint32) servAddr) < (afs_uint32) magicHost) {
372 magicHost = ntohl(servAddr);
379 magicServer->magic = 1; /* remember for when counting votes */
381 if (!amIClone && !magicServer)
385 ++nServers; /* count this server as well as the remotes */
387 nServers = i + 1; /* count this server as well as the remotes */
389 ubik_quorum = (nServers >> 1) + 1; /* compute the majority figure */
391 /* Shoud we set some defaults for RX??
393 r_nRetries = (RPCTIMEOUT/r_retryInterval);
396 if (!ubik_servers) /* special case 1 server */
397 ubik_singleServer = 1;
398 if (nServers == 1 && !amIClone) {
399 beacon_globals.ubik_amSyncSite = 1; /* let's start as sync site */
400 beacon_globals.syncSiteUntil = 0x7fffffff; /* and be it quite a while */
401 beacon_globals.ubik_syncSiteAdvertised = 1;
404 version_globals.ubik_epochTime = FT_ApproxTime();
409 if (nServers == 1) /* special case 1 server */
410 ubik_singleServer = 1;
413 if (ubik_singleServer) {
414 if (!beacon_globals.ubik_amSyncSite) {
415 ubik_dprint("Ubik: I am the sync site - 1 server\n");
418 version_globals.ubik_epochTime = FT_ApproxTime();
422 beacon_globals.ubik_amSyncSite = 1;
423 beacon_globals.syncSiteUntil = 0x7fffffff; /* quite a while */
424 beacon_globals.ubik_syncSiteAdvertised = 1;
430 * \brief main lwp loop for code that sends out beacons.
432 * This code only runs while we're sync site or we want to be the sync site.
433 * It runs in its very own light-weight process.
436 ubeacon_Interact(void *dummy)
440 struct rx_connection *connections[MAXSERVERS];
441 struct ubik_server *servers[MAXSERVERS];
443 struct ubik_server *ts;
444 afs_int32 temp, yesVotes, lastWakeupTime, oldestYesVote, syncsite;
446 struct ubik_tid ttid;
447 struct ubik_version tversion;
450 afs_pthread_setname_self("beacon");
452 /* loop forever getting votes */
453 lastWakeupTime = 0; /* keep track of time we last started a vote collection */
456 /* don't wakeup more than every POLLTIME seconds */
457 temp = (lastWakeupTime + POLLTIME) - FT_ApproxTime();
458 /* don't sleep if last collection phase took too long (probably timed someone out ) */
464 #ifdef AFS_PTHREAD_ENV
465 select(0, 0, 0, 0, &tt);
467 IOMGR_Select(0, 0, 0, 0, &tt);
471 lastWakeupTime = FT_ApproxTime(); /* started a new collection phase */
473 if (ubik_singleServer)
474 continue; /* special-case 1 server for speedy startup */
476 if (!uvote_ShouldIRun())
477 continue; /* if voter has heard from a better candidate than us, don't bother running */
479 /* otherwise we should run for election, or we're the sync site (and have already won);
480 * send out the beacon packets */
481 /* build list of all up hosts (noticing dead hosts are running again
482 * is a task for the recovery module, not the beacon module), and
483 * prepare to send them an r multi-call containing the beacon message */
484 i = 0; /* collect connections */
487 for (ts = ubik_servers; ts; ts = ts->next) {
488 if (ts->up && ts->addr[0] != ubik_host[0]) {
490 connections[i++] = ts->vote_rxcid;
495 servers[i] = (struct ubik_server *)0; /* end of list */
496 /* note that we assume in the vote module that we'll always get at least BIGTIME
497 * seconds of vote from anyone who votes for us, which means we can conservatively
498 * assume we'll be fine until SMALLTIME seconds after we start collecting votes */
499 /* this next is essentially an expansion of rgen's ServBeacon routine */
502 ttid.epoch = version_globals.ubik_epochTime;
503 if (ubik_dbase->flags & DBWRITING) {
505 * if a write is in progress, we have to send the writeTidCounter
506 * which holds the tid counter of the write transaction , and not
507 * send the tidCounter value which holds the tid counter of the
510 ttid.counter = ubik_dbase->writeTidCounter;
512 ttid.counter = ubik_dbase->tidCounter + 1;
513 tversion.epoch = ubik_dbase->version.epoch;
514 tversion.counter = ubik_dbase->version.counter;
517 /* now analyze return codes, counting up our votes */
518 yesVotes = 0; /* count how many to ensure we have quorum */
519 oldestYesVote = 0x7fffffff; /* time quorum expires */
520 syncsite = amSyncSite();
522 /* Ok to use the DB lock here since we aren't sync site */
524 urecovery_ResetState();
527 startTime = FT_ApproxTime();
529 * Don't waste time using mult Rx calls if there are no connections out there
533 multi_Rx(connections, i) {
534 multi_VOTE_Beacon(syncsite, startTime, &tversion,
536 temp = FT_ApproxTime(); /* now, more or less */
537 ts = servers[multi_i];
539 ts->lastBeaconSent = temp;
542 if (code > 0 && ((code < temp && code < temp - 3600) ||
543 (code > temp && code > temp + 3600))) {
544 /* if we reached here, supposedly the remote host voted
545 * for us based on a computation from over an hour ago in
546 * the past, or over an hour in the future. this is
547 * unlikely; what actually probably happened is that the
548 * call generated some error and was aborted. this can
549 * happen due to errors with the rx security class in play
550 * (rxkad, rxgk, etc). treat the host as if we got a
551 * timeout, since this is not a valid vote. */
552 ubik_print("assuming distant vote time %d from %s is an error; marking host down\n",
553 (int)code, afs_inet_ntoa_r(ts->addr[0], hoststr));
556 if (code > 0 && rx_ConnError(connections[multi_i])) {
557 ubik_print("assuming vote from %s is invalid due to conn error %d; marking host down\n",
558 afs_inet_ntoa_r(ts->addr[0], hoststr),
559 (int)rx_ConnError(connections[multi_i]));
563 /* note that the vote time (the return code) represents the time
564 * the vote was computed, *not* the time the vote expires. We compute
565 * the latter down below if we got enough votes to go with */
567 if ((code & ~0xff) == ERROR_TABLE_BASE_RXK) {
568 ubik_dprint("token error %d from host %s\n",
569 code, afs_inet_ntoa_r(ts->addr[0], hoststr));
571 ts->beaconSinceDown = 0;
572 urecovery_LostServer(ts);
574 ts->lastVoteTime = code;
575 if (code < oldestYesVote)
576 oldestYesVote = code;
581 yesVotes++; /* the extra epsilon */
582 ts->up = 1; /* server is up (not really necessary: recovery does this for real) */
583 ts->beaconSinceDown = 1;
584 ubik_dprint("yes vote from host %s\n",
585 afs_inet_ntoa_r(ts->addr[0], hoststr));
587 } else if (code == 0) {
588 ts->lastVoteTime = temp;
590 ts->beaconSinceDown = 1;
591 ubik_dprint("no vote from %s\n",
592 afs_inet_ntoa_r(ts->addr[0], hoststr));
593 } else if (code < 0) {
595 ts->beaconSinceDown = 0;
596 urecovery_LostServer(ts);
597 ubik_dprint("time out from %s\n",
598 afs_inet_ntoa_r(ts->addr[0], hoststr));
604 /* now call our own voter module to see if we'll vote for ourself. Note that
605 * the same restrictions apply for our voting for ourself as for our voting
606 * for anyone else. */
607 i = SVOTE_Beacon((struct rx_call *)0, ubeacon_AmSyncSite(), startTime,
612 yesVotes++; /* extra epsilon */
613 if (i < oldestYesVote)
617 /* now decide if we have enough votes to become sync site.
618 * Note that we can still get enough votes even if we didn't for ourself. */
620 if (yesVotes > nServers) { /* yesVotes is bumped by 2 or 3 for each site */
622 if (!beacon_globals.ubik_amSyncSite) {
623 ubik_dprint("Ubik: I am the sync site\n");
624 /* Defer actually changing any variables until we can take the
625 * DB lock (which is before the beacon lock in the lock order). */
628 beacon_globals.syncSiteUntil = oldestYesVote + SMALLTIME;
629 /* at this point, we have the guarantee that at least quorum
630 * received a beacon packet informing we have a sync-site. */
631 beacon_globals.ubik_syncSiteAdvertised = 1;
636 if (beacon_globals.ubik_amSyncSite)
637 ubik_dprint("Ubik: I am no longer the sync site\n");
638 beacon_globals.ubik_amSyncSite = 0;
639 beacon_globals.ubik_syncSiteAdvertised = 0;
642 urecovery_ResetState(); /* tell recovery we're no longer the sync site */
645 /* We cannot take the DB lock around the entire preceding conditional,
646 * because if we are currently the sync site and this election serves
647 * to confirm that status, the DB lock may already be held for a long-running
648 * write transaction. In such a case, attempting to acquire the DB lock
649 * would cause the beacon thread to block and disrupt election processing.
650 * However, if we are transitioning from not-sync-site to sync-site, there
651 * can be no outstanding transactions and acquiring the DB lock should be
652 * safe without extended blocking. */
653 if (becameSyncSite) {
657 version_globals.ubik_epochTime = FT_ApproxTime();
658 beacon_globals.ubik_amSyncSite = 1;
659 beacon_globals.syncSiteUntil = oldestYesVote + SMALLTIME;
666 AFS_UNREACHED(return(NULL));
670 * \brief Verify that a given IP addresses does actually exist on this machine.
672 * \param ame the pointer to my IP address specified in the
674 * \param aservers an array containing IP
675 * addresses of remote ubik servers. The array is
676 * terminated by a zero address.
678 * Algorithm : Verify that my IP addresses \p ame does actually exist
679 * on this machine. If any of my IP addresses are there
680 * in the remote server list \p aserver, remove them from
681 * this list. Update global variable \p ubik_host[] with
684 * \return 0 on success, non-zero on failure
687 verifyInterfaceAddress(afs_uint32 *ame, struct afsconf_cell *info,
688 afs_uint32 aservers[]) {
689 afs_uint32 myAddr[UBIK_MAX_INTERFACE_ADDR], *servList, tmpAddr;
690 afs_uint32 myAddr2[UBIK_MAX_INTERFACE_ADDR];
692 int tcount, count, found, i, j, totalServers, start, end, usednetfiles =
696 totalServers = info->numServers;
697 else { /* count the number of servers */
698 for (totalServers = 0, servList = aservers; *servList; servList++)
702 if (AFSDIR_SERVER_NETRESTRICT_FILEPATH || AFSDIR_SERVER_NETINFO_FILEPATH) {
704 * Find addresses we are supposed to register as per the netrestrict file
705 * if it exists, else just register all the addresses we find on this
706 * host as returned by rx_getAllAddr (in NBO)
709 count = afsconf_ParseNetFiles(myAddr, NULL, NULL,
710 UBIK_MAX_INTERFACE_ADDR, reason,
711 AFSDIR_SERVER_NETINFO_FILEPATH,
712 AFSDIR_SERVER_NETRESTRICT_FILEPATH);
714 ubik_print("ubik: Can't register any valid addresses:%s\n",
716 ubik_print("Aborting..\n");
721 /* get all my interface addresses in net byte order */
722 count = rx_getAllAddr(myAddr, UBIK_MAX_INTERFACE_ADDR);
725 if (count <= 0) { /* no address found */
726 ubik_print("ubik: No network addresses found, aborting..\n");
730 /* verify that the My-address passed in by ubik is correct */
731 for (j = 0, found = 0; j < count; j++) {
732 if (*ame == myAddr[j]) { /* both in net byte order */
739 ubik_print("ubik: primary address %s does not exist\n",
740 afs_inet_ntoa_r(*ame, hoststr));
741 /* if we had the result of rx_getAllAddr already, avoid subverting
742 * the "is gethostbyname(gethostname()) us" check. If we're
743 * using NetInfo/NetRestrict, we assume they have enough clue
744 * to avoid that big hole in their foot from the loaded gun. */
746 /* take the address we did get, then see if ame was masked */
748 tcount = rx_getAllAddr(myAddr2, UBIK_MAX_INTERFACE_ADDR);
749 if (tcount <= 0) { /* no address found */
750 ubik_print("ubik: No network addresses found, aborting..\n");
754 /* verify that the My-address passed in by ubik is correct */
755 for (j = 0, found = 0; j < tcount; j++) {
756 if (*ame == myAddr2[j]) { /* both in net byte order */
766 /* if any of my addresses are there in serverList, then
767 ** use that as my primary addresses : the higher level
768 ** application screwed up in dealing with multihomed concepts
770 for (j = 0, found = 0; j < count; j++) {
771 for (i = 0; i < totalServers; i++) {
773 tmpAddr = (afs_uint32) info->hostAddr[i].sin_addr.s_addr;
775 tmpAddr = aservers[i];
776 if (myAddr[j] == tmpAddr) {
785 ubik_print("Using %s as my primary address\n", afs_inet_ntoa_r(*ame, hoststr));
788 /* get rid of servers which were purged because all
789 ** those interface addresses are myself
791 for (start = 0, end = totalServers - 1; (start < end); start++, end--) {
792 /* find the first zero entry from the beginning */
793 for (; (start < end) && (aservers[start]); start++);
795 /* find the last non-zero entry from the end */
796 for (; (end >= 0) && (!aservers[end]); end--);
798 /* if there is nothing more to purge, exit from loop */
803 aservers[start] = aservers[end];
804 aservers[end] = 0; /* this entry was moved */
808 /* update all my addresses in ubik_host in such a way
809 ** that ubik_host[0] has the primary address
812 for (j = 0, i = 1; j < count; j++)
813 if (*ame != myAddr[j])
814 ubik_host[i++] = myAddr[j];
816 return 0; /* return success */
821 * \brief Exchange IP address information with remote servers.
823 * \param ubik_host an array containing all my IP addresses.
825 * Algorithm : Do an RPC to all remote ubik servers informing them
826 * about my IP addresses. Get their IP addresses and
827 * update my linked list of ubik servers \p ubik_servers
829 * \return 0 on success, non-zero on failure
832 ubeacon_updateUbikNetworkAddress(afs_uint32 ubik_host[UBIK_MAX_INTERFACE_ADDR])
834 int j, count, code = 0;
835 UbikInterfaceAddr inAddr, outAddr;
836 struct rx_connection *conns[MAXSERVERS];
837 struct ubik_server *ts, *server[MAXSERVERS];
842 for (count = 0, ts = ubik_servers; ts; count++, ts = ts->next) {
843 conns[count] = ts->disk_rxcid;
849 /* inform all other servers only if there are more than one
850 * database servers in the cell */
854 for (j = 0; j < UBIK_MAX_INTERFACE_ADDR; j++)
855 inAddr.hostAddr[j] = ntohl(ubik_host[j]);
858 /* do the multi-RX RPC to all other servers */
859 multi_Rx(conns, count) {
860 multi_DISK_UpdateInterfaceAddr(&inAddr, &outAddr);
861 ts = server[multi_i]; /* reply received from this server */
864 if (ts->addr[0] != htonl(outAddr.hostAddr[0])) {
866 strcpy(buffer, afs_inet_ntoa_r(ts->addr[0], hoststr));
867 ubik_print("ubik:Two primary addresses for same server \
869 afs_inet_ntoa_r(htonl(outAddr.hostAddr[0]), hoststr));
871 for (j = 1; j < UBIK_MAX_INTERFACE_ADDR; j++)
872 ts->addr[j] = htonl(outAddr.hostAddr[j]);
875 } else if (multi_error == RXGEN_OPCODE) { /* pre 3.5 remote server */
878 ("ubik server %s does not support UpdateInterfaceAddr RPC\n",
879 afs_inet_ntoa_r(ts->addr[0], hoststr));
881 } else if (multi_error == UBADHOST) {
882 code = UBADHOST; /* remote CellServDB inconsistency */
883 ubik_print("Inconsistent Cell Info on server:\n");
885 for (j = 0; j < UBIK_MAX_INTERFACE_ADDR && ts->addr[j]; j++)
886 ubik_print("... %s\n", afs_inet_ntoa_r(ts->addr[j], hoststr));
890 ts->up = 0; /* mark the remote server as down */
900 ubik_SetClientSecurityProcs(int (*secproc) (void *,
901 struct rx_securityClass **,
903 int (*checkproc) (void *),
906 secLayerProc = secproc;
907 tokenCheckProc = checkproc;