DEVEL15-kill-ubik-pthread-env-20080718
[openafs.git] / src / ubik / beacon.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
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
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 RCSID
14     ("$Header$");
15
16 #include <sys/types.h>
17 #ifdef AFS_NT40_ENV
18 #include <winsock2.h>
19 #include <time.h>
20 #else
21 #include <sys/file.h>
22 #include <sys/time.h>
23 #include <sys/socket.h>
24 #include <netinet/in.h>
25 #include <netdb.h>
26 #endif
27 #include <errno.h>
28 #include <lock.h>
29 #include <string.h>
30 #include <rx/xdr.h>
31 #include <rx/rx.h>
32 #include <rx/rx_multi.h>
33 #include <afs/cellconfig.h>
34 #ifndef AFS_NT40_ENV
35 #include <afs/afsutil.h>
36 #include <afs/netutils.h>
37 #endif
38
39 #define UBIK_INTERNALS
40 #include "ubik.h"
41 #include "ubik_int.h"
42
43 /* statics used to determine if we're the sync site */
44 static afs_int32 syncSiteUntil = 0;     /* valid only if amSyncSite */
45 int ubik_amSyncSite = 0;        /* flag telling if I'm sync site */
46 static nServers;                /* total number of servers */
47 static char amIMagic = 0;       /* is this host the magic host */
48 char amIClone = 0;              /* is this a clone which doesn't vote */
49 static char ubik_singleServer = 0;
50 int (*ubik_CRXSecurityProc) ();
51 char *ubik_CRXSecurityRock;
52 afs_int32 ubikSecIndex;
53 struct rx_securityClass *ubikSecClass;
54 static verifyInterfaceAddress();
55
56
57 /* Module responsible for both deciding if we're currently the sync site,
58  * and keeping collecting votes so as to stay sync site.
59  *
60  * The basic module contacts all of the servers it can, trying to get them to vote
61  * for this server for sync site.  The vote request message (called a beacon message)
62  * also specifies until which time this site claims to be the sync site, if at all, thus enabling
63  * receiving sites to know how long the sync site guarantee is made for.
64  *
65  * Each  of these beacon messages is thus both a declaration of how long this site will
66  * remain sync site, and an attempt to extend that time by collecting votes for a later
67  * sync site extension.
68  *
69  * The voting module is responsible for choosing a reasonable time until which it promises
70  * not to vote for someone else.  This parameter (BIG seconds) is not actually passed in
71  * the interface (perhaps it should be?) but is instead a compile time constant that both
72  * sides know about.
73  
74  * The beacon and vote modules work intimately together; the vote module decides how long
75  * it should promise the beacon module its vote, and the beacon module takes all of these
76  * votes and decides for how long it is the synchronization site.
77  */
78
79 /* procedure called from debug rpc call to get this module's state for debugging */
80 void
81 ubeacon_Debug(aparm)
82      register struct ubik_debug *aparm;
83 {
84     /* fill in beacon's state fields in the ubik_debug structure */
85     aparm->syncSiteUntil = syncSiteUntil;
86     aparm->nServers = nServers;
87 }
88
89 /* procedure that determines whether this site has enough current votes to remain sync site.
90  *  called from higher-level modules (everything but the vote module).
91  *
92  * If we're the sync site, check that our guarantees, obtained by the ubeacon_Interact
93  * light-weight process, haven't expired.  We're sync site as long as a majority of the
94  * servers in existence have promised us unexpired guarantees.  The variable ubik_syncSiteUntil
95  * contains the time at which the latest of the majority of the sync site guarantees expires
96  * (if the variable ubik_amSyncSite is true)
97  * This module also calls up to the recovery module if it thinks that the recovery module
98  * may have to pick up a new database (which offucr sif we lose the sync site votes).
99  */
100 ubeacon_AmSyncSite()
101 {
102     register afs_int32 now;
103     register afs_int32 rcode;
104
105     /* special case for fast startup */
106     if (nServers == 1 && !amIClone) {
107         return 1;               /* one guy is always the sync site */
108     }
109
110     if (ubik_amSyncSite == 0 || amIClone)
111         rcode = 0;              /* if I don't think I'm the sync site, say so */
112     else {
113         now = FT_ApproxTime();
114         if (syncSiteUntil <= now) {     /* if my votes have expired, say so */
115             if (ubik_amSyncSite)
116                 ubik_dprint("Ubik: I am no longer the sync site\n");
117             ubik_amSyncSite = 0;
118             rcode = 0;
119         } else {
120             rcode = 1;          /* otherwise still have the required votes */
121         }
122     }
123     if (rcode == 0)
124         urecovery_ResetState(); /* force recovery to re-execute */
125     ubik_dprint("beacon: amSyncSite is %d\n", rcode);
126     return rcode;
127 }
128
129 /* setup server list; called with two parms, first is my address, second is list of other servers
130  * called only at initialization to set up the list of servers to contact for votes.  Just creates
131  * the server structure.  Note that there are two connections in every server structure, one for
132  * vote calls (which must always go through quickly) and one for database operations, which
133  * are subject to waiting for locks.  If we used only one, the votes would sometimes get
134  * held up behind database operations, and the sync site guarantees would timeout
135  * even though the host would be up for communication.
136  *
137  * The "magic" host is the one with the lowest internet address.  It is
138  * magic because its vote counts epsilon more than the others.  This acts
139  * as a tie-breaker when we have an even number of hosts in the system.
140  * For example, if the "magic" host is up in a 2 site system, then it
141  * is sync site.  Without the magic host hack, if anyone crashed in a 2
142  * site system, we'd be out of business.
143  */
144 ubeacon_InitServerListByInfo(ame, info, clones)
145      afs_int32 ame;
146      struct afsconf_cell *info;
147      char clones[];
148 {
149     afs_int32 code;
150
151     code = ubeacon_InitServerListCommon(ame, info, clones, 0);
152     return code;
153 }
154
155 ubeacon_InitServerList(ame, aservers)
156      afs_int32 ame;
157      register afs_int32 aservers[];
158 {
159     afs_int32 code;
160
161     code =
162         ubeacon_InitServerListCommon(ame, (struct afsconf_cell *)0, 0,
163                                      aservers);
164     return code;
165 }
166
167 ubeacon_InitServerListCommon(ame, info, clones, aservers)
168      afs_int32 ame;
169      struct afsconf_cell *info;
170      char clones[];
171      register afs_int32 aservers[];
172 {
173     register struct ubik_server *ts;
174     afs_int32 me = -1;
175     register afs_int32 servAddr;
176     register afs_int32 i, code;
177     afs_int32 magicHost;
178     struct ubik_server *magicServer;
179
180     /* verify that the addresses passed in are correct */
181     if ((code = verifyInterfaceAddress(&ame, info, aservers)))
182         return code;
183
184     /* get the security index to use, if we can */
185     if (ubik_CRXSecurityProc) {
186         i = (*ubik_CRXSecurityProc) (ubik_CRXSecurityRock, &ubikSecClass,
187                                      &ubikSecIndex);
188     } else
189         i = 1;
190     if (i) {
191         /* don't have sec module yet */
192         ubikSecIndex = 0;
193         ubikSecClass = rxnull_NewClientSecurityObject();
194     }
195     magicHost = ntohl(ame);     /* do comparisons in host order */
196     magicServer = (struct ubik_server *)0;
197
198     if (info) {
199         for (i = 0; i < info->numServers; i++) {
200             if (ntohl((afs_uint32) info->hostAddr[i].sin_addr.s_addr) ==
201                 ntohl((afs_uint32) ame)) {
202                 me = i;
203                 if (clones[i]) {
204                     amIClone = 1;
205                     magicHost = 0;
206                 }
207             }
208         }
209         nServers = 0;
210         for (i = 0; i < info->numServers; i++) {
211             if (i == me)
212                 continue;
213             ts = (struct ubik_server *)malloc(sizeof(struct ubik_server));
214             memset(ts, 0, sizeof(struct ubik_server));
215             ts->next = ubik_servers;
216             ubik_servers = ts;
217             ts->addr[0] = info->hostAddr[i].sin_addr.s_addr;
218             if (clones[i]) {
219                 ts->isClone = 1;
220             } else {
221                 if (!magicHost
222                     || ntohl((afs_uint32) ts->addr[0]) <
223                     (afs_uint32) magicHost) {
224                     magicHost = ntohl(ts->addr[0]);
225                     magicServer = ts;
226                 }
227                 ++nServers;
228             }
229             /* for vote reqs */
230             ts->vote_rxcid =
231                 rx_NewConnection(info->hostAddr[i].sin_addr.s_addr,
232                                  ubik_callPortal, VOTE_SERVICE_ID,
233                                  ubikSecClass, ubikSecIndex);
234             /* for disk reqs */
235             ts->disk_rxcid =
236                 rx_NewConnection(info->hostAddr[i].sin_addr.s_addr,
237                                  ubik_callPortal, DISK_SERVICE_ID,
238                                  ubikSecClass, ubikSecIndex);
239             ts->up = 1;
240         }
241     } else {
242         i = 0;
243         while ((servAddr = *aservers++)) {
244             if (i >= MAXSERVERS)
245                 return UNHOSTS; /* too many hosts */
246             ts = (struct ubik_server *)malloc(sizeof(struct ubik_server));
247             memset(ts, 0, sizeof(struct ubik_server));
248             ts->next = ubik_servers;
249             ubik_servers = ts;
250             ts->addr[0] = servAddr;     /* primary address in  net byte order */
251             ts->vote_rxcid = rx_NewConnection(servAddr, ubik_callPortal, VOTE_SERVICE_ID, ubikSecClass, ubikSecIndex);  /* for vote reqs */
252             ts->disk_rxcid = rx_NewConnection(servAddr, ubik_callPortal, DISK_SERVICE_ID, ubikSecClass, ubikSecIndex);  /* for disk reqs */
253             ts->isClone = 0;    /* don't know about clones */
254             ts->up = 1;
255             if (ntohl((afs_uint32) servAddr) < (afs_uint32) magicHost) {
256                 magicHost = ntohl(servAddr);
257                 magicServer = ts;
258             }
259             i++;
260         }
261     }
262     if (magicServer)
263         magicServer->magic = 1; /* remember for when counting votes */
264
265     if (!amIClone && !magicServer)
266         amIMagic = 1;
267     if (info) {
268         if (!amIClone)
269             ++nServers;         /* count this server as well as the remotes */
270     } else
271         nServers = i + 1;       /* count this server as well as the remotes */
272
273     ubik_quorum = (nServers >> 1) + 1;  /* compute the majority figure */
274     /* send addrs to all other servers */
275     code = updateUbikNetworkAddress(ubik_host);
276     if (code)
277         return code;
278
279 /* Shoud we set some defaults for RX??
280     r_retryInterval = 2;        
281     r_nRetries = (RPCTIMEOUT/r_retryInterval);
282 */
283     if (info) {
284         if (!ubik_servers)      /* special case 1 server */
285             ubik_singleServer = 1;
286         if (nServers == 1 && !amIClone) {
287             ubik_amSyncSite = 1;        /* let's start as sync site */
288             syncSiteUntil = 0x7fffffff; /* and be it quite a while */
289         }
290     } else {
291         if (nServers == 1)      /* special case 1 server */
292             ubik_singleServer = 1;
293     }
294
295     if (ubik_singleServer) {
296         if (!ubik_amSyncSite)
297             ubik_dprint("Ubik: I am the sync site - 1 server\n");
298         ubik_amSyncSite = 1;
299         syncSiteUntil = 0x7fffffff;     /* quite a while */
300     }
301     return 0;
302 }
303
304 /* main lwp loop for code that sends out beacons.  This code only runs while
305  * we're sync site or we want to be the sync site.  It runs in its very own light-weight
306  * process.
307  */
308 void *
309 ubeacon_Interact(void *dummy)
310 {
311     register afs_int32 code;
312     struct timeval tt;
313     struct rx_connection *connections[MAXSERVERS];
314     struct ubik_server *servers[MAXSERVERS];
315     register afs_int32 i;
316     register struct ubik_server *ts;
317     afs_int32 temp, yesVotes, lastWakeupTime, oldestYesVote, syncsite;
318     struct ubik_tid ttid;
319     afs_int32 startTime;
320
321     /* loop forever getting votes */
322     lastWakeupTime = 0;         /* keep track of time we last started a vote collection */
323     while (1) {
324
325         /* don't wakeup more than every POLLTIME seconds */
326         temp = (lastWakeupTime + POLLTIME) - FT_ApproxTime();
327         /* don't sleep if last collection phase took too long (probably timed someone out ) */
328         if (temp > 0) {
329             if (temp > POLLTIME)
330                 temp = POLLTIME;
331             tt.tv_sec = temp;
332             tt.tv_usec = 0;
333 #ifdef AFS_PTHREAD_ENV
334             code = select(0, 0, 0, 0, &tt);
335 #else
336             code = IOMGR_Select(0, 0, 0, 0, &tt);
337 #endif
338         } else
339             code = 0;
340
341         lastWakeupTime = FT_ApproxTime();       /* started a new collection phase */
342
343         if (ubik_singleServer)
344             continue;           /* special-case 1 server for speedy startup */
345
346         if (!uvote_ShouldIRun())
347             continue;           /* if voter has heard from a better candidate than us, don't bother running */
348
349         /* otherwise we should run for election, or we're the sync site (and have already won);
350          * send out the beacon packets */
351         /* build list of all up hosts (noticing dead hosts are running again
352          * is a task for the recovery module, not the beacon module), and
353          * prepare to send them an r multi-call containing the beacon message */
354         i = 0;                  /* collect connections */
355         for (ts = ubik_servers; ts; ts = ts->next) {
356             if (ts->up && ts->addr[0] != ubik_host[0]) {
357                 servers[i] = ts;
358                 connections[i++] = ts->vote_rxcid;
359             }
360         }
361         servers[i] = (struct ubik_server *)0;   /* end of list */
362         /* note that we assume in the vote module that we'll always get at least BIGTIME 
363          * seconds of vote from anyone who votes for us, which means we can conservatively
364          * assume we'll be fine until SMALLTIME seconds after we start collecting votes */
365         /* this next is essentially an expansion of rgen's ServBeacon routine */
366
367         ttid.epoch = ubik_epochTime;
368         if (ubik_dbase->flags & DBWRITING) {
369             /*
370              * if a write is in progress, we have to send the writeTidCounter
371              * which holds the tid counter of the write transaction , and not
372              * send the tidCounter value which holds the tid counter of the
373              * last transaction.
374              */
375             ttid.counter = ubik_dbase->writeTidCounter;
376         } else
377             ttid.counter = ubik_dbase->tidCounter + 1;
378 #if defined(UBIK_PAUSE)
379         ubik_dbase->flags |= DBVOTING;
380 #endif /* UBIK_PAUSE */
381
382         /* now analyze return codes, counting up our votes */
383         yesVotes = 0;           /* count how many to ensure we have quorum */
384         oldestYesVote = 0x7fffffff;     /* time quorum expires */
385         syncsite = ubeacon_AmSyncSite();
386         startTime = FT_ApproxTime();
387         /*
388          * Don't waste time using mult Rx calls if there are no connections out there
389          */
390         if (i > 0) {
391             multi_Rx(connections, i) {
392                 multi_VOTE_Beacon(syncsite, startTime, &ubik_dbase->version,
393                                   &ttid);
394                 temp = FT_ApproxTime(); /* now, more or less */
395                 ts = servers[multi_i];
396                 ts->lastBeaconSent = temp;
397                 code = multi_error;
398                 /* note that the vote time (the return code) represents the time
399                  * the vote was computed, *not* the time the vote expires.  We compute
400                  * the latter down below if we got enough votes to go with */
401                 if (code > 0) {
402                     ts->lastVoteTime = code;
403                     if (code < oldestYesVote)
404                         oldestYesVote = code;
405                     ts->lastVote = 1;
406                     if (!ts->isClone)
407                         yesVotes += 2;
408                     if (ts->magic)
409                         yesVotes++;     /* the extra epsilon */
410                     ts->up = 1; /* server is up (not really necessary: recovery does this for real) */
411                     ts->beaconSinceDown = 1;
412                     ubik_dprint("yes vote from host %s\n",
413                                 afs_inet_ntoa(ts->addr[0]));
414                 } else if (code == 0) {
415                     ts->lastVoteTime = temp;
416                     ts->lastVote = 0;
417                     ts->beaconSinceDown = 1;
418                     ubik_dprint("no vote from %s\n",
419                                 afs_inet_ntoa(ts->addr[0]));
420                 } else if (code < 0) {
421                     ts->up = 0;
422                     ts->beaconSinceDown = 0;
423                     urecovery_LostServer();
424                     ubik_dprint("time out from %s\n",
425                                 afs_inet_ntoa(ts->addr[0]));
426                 }
427             }
428             multi_End;
429         }
430         /* now call our own voter module to see if we'll vote for ourself.  Note that
431          * the same restrictions apply for our voting for ourself as for our voting
432          * for anyone else. */
433         i = SVOTE_Beacon((struct rx_call *)0, ubeacon_AmSyncSite(), startTime,
434                          &ubik_dbase->version, &ttid);
435         if (i) {
436             yesVotes += 2;
437             if (amIMagic)
438                 yesVotes++;     /* extra epsilon */
439             if (i < oldestYesVote)
440                 oldestYesVote = i;
441         }
442 #if defined(UBIK_PAUSE)
443         ubik_dbase->flags &= ~DBVOTING;
444 #endif /* UBIK_PAUSE */
445
446         /* now decide if we have enough votes to become sync site.
447          * Note that we can still get enough votes even if we didn't for ourself. */
448         if (yesVotes > nServers) {      /* yesVotes is bumped by 2 or 3 for each site */
449             if (!ubik_amSyncSite)
450                 ubik_dprint("Ubik: I am the sync site\n");
451             ubik_amSyncSite = 1;
452             syncSiteUntil = oldestYesVote + SMALLTIME;
453 #ifndef AFS_PTHREAD_ENV
454                 /* I did not find a corresponding LWP_WaitProcess(&ubik_amSyncSite) --
455                    this may be a spurious signal call -- sjenkins */
456                 LWP_NoYieldSignal(&ubik_amSyncSite);
457 #endif
458         } else {
459             if (ubik_amSyncSite)
460                 ubik_dprint("Ubik: I am no longer the sync site\n");
461             ubik_amSyncSite = 0;
462             urecovery_ResetState();     /* tell recovery we're no longer the sync site */
463         }
464
465     }                           /* while loop */
466     return NULL;
467 }
468
469 /* 
470 * Input Param   : ame is the pointer to my IP address specified in the
471 *                 CellServDB file. aservers is an array containing IP 
472 *                 addresses of remote ubik servers. The array is 
473 *                 terminated by a zero address.
474 *
475 * Algorithm     : Verify that my IP addresses 'ame' does actually exist
476 *                 on this machine.  If any of my IP addresses are there 
477 *                 in the remote server list 'aserver', remove them from 
478 *                 this list.  Update global variable ubik_host[] with 
479 *                 my IP addresses.
480 *
481 * Return Values : 0 on success, non-zero on failure
482 */
483 static
484 verifyInterfaceAddress(ame, info, aservers)
485      afs_uint32 *ame;           /* one of my interface addr in net byte order */
486      struct afsconf_cell *info;
487      afs_uint32 aservers[];     /* list of all possible server addresses */
488 {
489     afs_uint32 myAddr[UBIK_MAX_INTERFACE_ADDR], *servList, tmpAddr;
490     afs_uint32 myAddr2[UBIK_MAX_INTERFACE_ADDR];
491     int tcount, count, found, i, j, totalServers, start, end, usednetfiles =
492         0;
493
494     if (info)
495         totalServers = info->numServers;
496     else {                      /* count the number of servers */
497         for (totalServers = 0, servList = aservers; *servList; servList++)
498             totalServers++;
499     }
500
501 #ifdef AFS_NT40_ENV
502     /* get all my interface addresses in net byte order */
503     count = rx_getAllAddr(myAddr, UBIK_MAX_INTERFACE_ADDR);
504 #else
505     if (AFSDIR_SERVER_NETRESTRICT_FILEPATH || AFSDIR_SERVER_NETINFO_FILEPATH) {
506         /*
507          * Find addresses we are supposed to register as per the netrestrict file
508          * if it exists, else just register all the addresses we find on this 
509          * host as returned by rx_getAllAddr (in NBO)
510          */
511         char reason[1024];
512         count =
513             parseNetFiles(myAddr, NULL, NULL, UBIK_MAX_INTERFACE_ADDR, reason,
514                           AFSDIR_SERVER_NETINFO_FILEPATH,
515                           AFSDIR_SERVER_NETRESTRICT_FILEPATH);
516         if (count < 0) {
517             ubik_print("ubik: Can't register any valid addresses:%s\n",
518                        reason);
519             ubik_print("Aborting..\n");
520             return UBADHOST;
521         }
522         usednetfiles++;
523     } else {
524         /* get all my interface addresses in net byte order */
525         count = rx_getAllAddr(myAddr, UBIK_MAX_INTERFACE_ADDR);
526     }
527 #endif
528
529     if (count <= 0) {           /* no address found */
530         ubik_print("ubik: No network addresses found, aborting..");
531         return UBADHOST;
532     }
533
534     /* verify that the My-address passed in by ubik is correct */
535     for (j = 0, found = 0; j < count; j++) {
536         if (*ame == myAddr[j]) {        /* both in net byte order */
537             found = 1;
538             break;
539         }
540     }
541
542     if (!found) {
543         ubik_print("ubik: primary address %s does not exist\n",
544                    afs_inet_ntoa(*ame));
545         /* if we had the result of rx_getAllAddr already, avoid subverting
546          * the "is gethostbyname(gethostname()) us" check. If we're
547          * using NetInfo/NetRestrict, we assume they have enough clue
548          * to avoid that big hole in their foot from the loaded gun. */
549         if (usednetfiles) {
550             /* take the address we did get, then see if ame was masked */
551             *ame = myAddr[0];
552             tcount = rx_getAllAddr(myAddr2, UBIK_MAX_INTERFACE_ADDR);
553             if (tcount <= 0) {  /* no address found */
554                 ubik_print("ubik: No network addresses found, aborting..");
555                 return UBADHOST;
556             }
557
558             /* verify that the My-address passed in by ubik is correct */
559             for (j = 0, found = 0; j < tcount; j++) {
560                 if (*ame == myAddr2[j]) {       /* both in net byte order */
561                     found = 1;
562                     break;
563                 }
564             }
565         }
566         if (!found)
567             return UBADHOST;
568     }
569
570     /* if any of my addresses are there in serverList, then
571      ** use that as my primary addresses : the higher level 
572      ** application screwed up in dealing with multihomed concepts
573      */
574     for (j = 0, found = 0; j < count; j++) {
575         for (i = 0; i < totalServers; i++) {
576             if (info)
577                 tmpAddr = (afs_uint32) info->hostAddr[i].sin_addr.s_addr;
578             else
579                 tmpAddr = aservers[i];
580             if (myAddr[j] == tmpAddr) {
581                 *ame = tmpAddr;
582                 if (!info)
583                     aservers[i] = 0;
584                 found = 1;
585             }
586         }
587     }
588     if (found)
589         ubik_print("Using %s as my primary address\n", afs_inet_ntoa(*ame));
590
591     if (!info) {
592         /* get rid of servers which were purged because all 
593          ** those interface addresses are myself 
594          */
595         for (start = 0, end = totalServers - 1; (start < end); start++, end--) {
596             /* find the first zero entry from the beginning */
597             for (; (start < end) && (aservers[start]); start++);
598
599             /* find the last non-zero entry from the end */
600             for (; (end >= 0) && (!aservers[end]); end--);
601
602             /* if there is nothing more to purge, exit from loop */
603             if (start >= end)
604                 break;
605
606             /* move the entry */
607             aservers[start] = aservers[end];
608             aservers[end] = 0;  /* this entry was moved */
609         }
610     }
611
612     /* update all my addresses in ubik_host in such a way 
613      ** that ubik_host[0] has the primary address 
614      */
615     ubik_host[0] = *ame;
616     for (j = 0, i = 1; j < count; j++)
617         if (*ame != myAddr[j])
618             ubik_host[i++] = myAddr[j];
619
620     return 0;                   /* return success */
621 }
622
623
624 /* 
625 * Input Param   : ubik_host is an array containing all my IP addresses.
626 *
627 * Algorithm     : Do an RPC to all remote ubik servers infroming them 
628 *                 about my IP addresses. Get their IP addresses and
629 *                 update my linked list of ubik servers 'ubik_servers'
630 *
631 * Return Values : 0 on success, non-zero on failure
632 */
633 int
634 updateUbikNetworkAddress(ubik_host)
635      afs_uint32 ubik_host[UBIK_MAX_INTERFACE_ADDR];
636 {
637     int j, count, code = 0;
638     UbikInterfaceAddr inAddr, outAddr;
639     struct rx_connection *conns[MAXSERVERS];
640     struct ubik_server *ts, *server[MAXSERVERS];
641     char buffer[32];
642
643     for (count = 0, ts = ubik_servers; ts; count++, ts = ts->next) {
644         conns[count] = ts->disk_rxcid;
645         server[count] = ts;
646     }
647
648
649     /* inform all other servers only if there are more than one
650      * database servers in the cell */
651
652     if (count > 0) {
653
654         for (j = 0; j < UBIK_MAX_INTERFACE_ADDR; j++)
655             inAddr.hostAddr[j] = ntohl(ubik_host[j]);
656
657
658         /* do the multi-RX RPC to all other servers */
659         multi_Rx(conns, count) {
660             multi_DISK_UpdateInterfaceAddr(&inAddr, &outAddr);
661             ts = server[multi_i];       /* reply received from this server */
662             if (!multi_error) {
663                 if (ts->addr[0] != htonl(outAddr.hostAddr[0])) {
664                     code = UBADHOST;
665                     strcpy(buffer, (char *)afs_inet_ntoa(ts->addr[0]));
666                     ubik_print("ubik:Two primary addresses for same server \
667                     %s %s\n", buffer, afs_inet_ntoa(htonl(outAddr.hostAddr[0])));
668                 } else {
669                     for (j = 1; j < UBIK_MAX_INTERFACE_ADDR; j++)
670                         ts->addr[j] = htonl(outAddr.hostAddr[j]);
671                 }
672             } else if (multi_error == RXGEN_OPCODE) {   /* pre 3.5 remote server */
673                 ubik_print
674                     ("ubik server %s does not support UpdateInterfaceAddr RPC\n",
675                      afs_inet_ntoa(ts->addr[0]));
676             } else if (multi_error == UBADHOST) {
677                 code = UBADHOST;        /* remote CellServDB inconsistency */
678                 ubik_print("Inconsistent Cell Info on server: ");
679                 for (j = 0; j < UBIK_MAX_INTERFACE_ADDR && ts->addr[j]; j++)
680                     ubik_print("%s ", afs_inet_ntoa(ts->addr[j]));
681                 ubik_print("\n");
682             } else {
683                 ts->up = 0;     /* mark the remote server as down */
684             }
685         }
686         multi_End;
687     }
688     return code;
689 }