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 #include <roken.h>
  14
  15 #include <afs/opr.h>
  16 #ifdef AFS_PTHREAD_ENV
  17 # include <opr/lock.h>
  18 #else
  19 # include <opr/lockstub.h>
  20 #endif
  21
  22 #include <lock.h>
  23 #include <rx/rx.h>
  24 #include <rx/rxkad.h>
  25 #include <rx/rx_multi.h>
  26 #include <afs/cellconfig.h>
  27 #ifndef AFS_NT40_ENV
  28 #include <afs/afsutil.h>
  29 #endif
  30
  31 #define UBIK_INTERNALS
  32 #include "ubik.h"
  33 #include "ubik_int.h"
  34
  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
  38  * instead
  39  */
  40 int (*ubik_CRXSecurityProc) (void *rock, struct rx_securityClass **,
  41                              afs_int32 *);
  42 void *ubik_CRXSecurityRock;
  43
  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;
  49 /*\}*/
  50 static int (*secLayerProc) (void *rock, struct rx_securityClass **,
  51                             afs_int32 *) = NULL;
  52 static int (*tokenCheckProc) (void *rock) = NULL;
  53 static void * securityRock = NULL;
  54
  55 afs_int32 ubikSecIndex;
  56 struct rx_securityClass *ubikSecClass;
  57
  58 /* Values protected by the address lock */
  59 struct addr_data addr_globals;
  60
  61 /* Values protected by the beacon lock */
  62 struct beacon_data beacon_globals;
  63
  64 static int ubeacon_InitServerListCommon(afs_uint32 ame,
  65                                         struct afsconf_cell *info,
  66                                         char clones[],
  67                                         afs_uint32 aservers[]);
  68 static int verifyInterfaceAddress(afs_uint32 *ame, struct afsconf_cell *info,
  69                                   afs_uint32 aservers[]);
  70
  71 /*! \file
  72  * Module responsible for both deciding if we're currently the sync site,
  73  * and keeping collecting votes so as to stay sync site.
  74  *
  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.
  79  *
  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.
  83  *
  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
  87  * sides know about.
  88
  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.
  92  */
  93
  94 /*! \brief procedure called from debug rpc call to get this module's state for debugging */
  95 void
  96 ubeacon_Debug(struct ubik_debug *aparm)
  97 {
  98     /* fill in beacon's state fields in the ubik_debug structure */
  99     aparm->syncSiteUntil = beacon_globals.syncSiteUntil;
 100     aparm->nServers = nServers;
 101 }
 102
 103 static int
 104 amSyncSite(void)
 105 {
 106     afs_int32 now;
 107     afs_int32 rcode;
 108
 109     /* special case for fast startup */
 110     if (nServers == 1 && !amIClone)
 111         return 1;               /* one guy is always the sync site */
 112
 113     UBIK_BEACON_LOCK;
 114     if (beacon_globals.ubik_amSyncSite == 0 || amIClone)
 115         rcode = 0;              /* if I don't think I'm the sync site, say so */
 116     else {
 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;
 123             rcode = 0;
 124         } else {
 125             rcode = 1;          /* otherwise still have the required votes */
 126         }
 127     }
 128     UBIK_BEACON_UNLOCK;
 129     ubik_dprint("beacon: amSyncSite is %d\n", rcode);
 130     return rcode;
 131 }
 132
 133 /*!
 134  * \brief Procedure that determines whether this site has enough current votes to remain sync site.
 135  *
 136  * Called from higher-level modules (everything but the vote module).
 137  *
 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).
 145  *
 146  * \return 1 if local site is the sync site
 147  * \return 0 if sync site is elsewhere
 148  */
 149 int
 150 ubeacon_AmSyncSite(void)
 151 {
 152     afs_int32 rcode;
 153
 154     rcode = amSyncSite();
 155
 156     if (!rcode)
 157         urecovery_ResetState();
 158
 159     return rcode;
 160 }
 161
 162 /*!
 163  * \brief Determine whether at least quorum are aware we have a sync-site.
 164  *
 165  * Called from higher-level modules.
 166  *
 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.
 172  *
 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
 175  */
 176 int
 177 ubeacon_SyncSiteAdvertised(void)
 178 {
 179     afs_int32 rcode;
 180
 181     UBIK_BEACON_LOCK;
 182     rcode = beacon_globals.ubik_syncSiteAdvertised;
 183     UBIK_BEACON_UNLOCK;
 184
 185     return rcode;
 186 }
 187
 188 /*!
 189  * \see ubeacon_InitServerListCommon()
 190  */
 191 int
 192 ubeacon_InitServerListByInfo(afs_uint32 ame, struct afsconf_cell *info,
 193                              char clones[])
 194 {
 195     afs_int32 code;
 196
 197     code = ubeacon_InitServerListCommon(ame, info, clones, 0);
 198     return code;
 199 }
 200
 201 /*!
 202  * \param ame "address of me"
 203  * \param aservers list of other servers
 204  *
 205  * \see ubeacon_InitServerListCommon()
 206  */
 207 int
 208 ubeacon_InitServerList(afs_uint32 ame, afs_uint32 aservers[])
 209 {
 210     afs_int32 code;
 211
 212     code =
 213         ubeacon_InitServerListCommon(ame, (struct afsconf_cell *)0, 0,
 214                                      aservers);
 215     return code;
 216 }
 217
 218 /* Must be called with address lock held */
 219 void
 220 ubeacon_InitSecurityClass(void)
 221 {
 222     int i;
 223     /* get the security index to use, if we can */
 224     if (secLayerProc) {
 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);
 229     } else
 230         i = 1;
 231     if (i) {
 232         /* don't have sec module yet */
 233         addr_globals.ubikSecIndex = 0;
 234         addr_globals.ubikSecClass = rxnull_NewClientSecurityObject();
 235     }
 236 }
 237
 238 void
 239 ubeacon_ReinitServer(struct ubik_server *ts)
 240 {
 241     if (tokenCheckProc && !(*tokenCheckProc) (securityRock)) {
 242         struct rx_connection *disk_rxcid;
 243         struct rx_connection *vote_rxcid;
 244         struct rx_connection *tmp;
 245         UBIK_ADDR_LOCK;
 246         ubeacon_InitSecurityClass();
 247         disk_rxcid =
 248             rx_NewConnection(rx_HostOf(rx_PeerOf(ts->disk_rxcid)),
 249                              ubik_callPortal, DISK_SERVICE_ID,
 250                              addr_globals.ubikSecClass, addr_globals.ubikSecIndex);
 251         if (disk_rxcid) {
 252             tmp = ts->disk_rxcid;
 253             ts->disk_rxcid = disk_rxcid;
 254             rx_PutConnection(tmp);
 255         }
 256         vote_rxcid =
 257             rx_NewConnection(rx_HostOf(rx_PeerOf(ts->vote_rxcid)),
 258                              ubik_callPortal, VOTE_SERVICE_ID,
 259                              addr_globals.ubikSecClass, addr_globals.ubikSecIndex);
 260         if (vote_rxcid) {
 261             tmp = ts->vote_rxcid;
 262             ts->vote_rxcid = vote_rxcid;
 263             rx_PutConnection(tmp);
 264         }
 265         UBIK_ADDR_UNLOCK;
 266     }
 267 }
 268
 269 /*!
 270  * \brief setup server list
 271  *
 272  * \param ame "address of me"
 273  * \param aservers list of other servers
 274  *
 275  * called only at initialization to set up the list of servers to
 276  * contact for votes.  Just creates the server structure.
 277  *
 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.
 284  *
 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.
 291  *
 292  * \see ubeacon_InitServerList(), ubeacon_InitServerListByInfo()
 293  */
 294 int
 295 ubeacon_InitServerListCommon(afs_uint32 ame, struct afsconf_cell *info,
 296                              char clones[], afs_uint32 aservers[])
 297 {
 298     struct ubik_server *ts;
 299     afs_int32 me = -1;
 300     afs_int32 servAddr;
 301     afs_int32 i, code;
 302     afs_int32 magicHost;
 303     struct ubik_server *magicServer;
 304
 305     /* verify that the addresses passed in are correct */
 306     if ((code = verifyInterfaceAddress(&ame, info, aservers)))
 307         return code;
 308
 309     ubeacon_InitSecurityClass();
 310
 311     magicHost = ntohl(ame);     /* do comparisons in host order */
 312     magicServer = (struct ubik_server *)0;
 313
 314     if (info) {
 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)) {
 318                 me = i;
 319                 if (clones[i]) {
 320                     amIClone = 1;
 321                     magicHost = 0;
 322                 }
 323             }
 324         }
 325         nServers = 0;
 326         for (i = 0; i < info->numServers; i++) {
 327             if (i == me)
 328                 continue;
 329             ts = calloc(1, sizeof(struct ubik_server));
 330             ts->next = ubik_servers;
 331             ubik_servers = ts;
 332             ts->addr[0] = info->hostAddr[i].sin_addr.s_addr;
 333             if (clones[i]) {
 334                 ts->isClone = 1;
 335             } else {
 336                 if (!magicHost
 337                     || ntohl((afs_uint32) ts->addr[0]) <
 338                     (afs_uint32) magicHost) {
 339                     magicHost = ntohl(ts->addr[0]);
 340                     magicServer = ts;
 341                 }
 342                 ++nServers;
 343             }
 344             /* for vote reqs */
 345             ts->vote_rxcid =
 346                 rx_NewConnection(info->hostAddr[i].sin_addr.s_addr,
 347                                  ubik_callPortal, VOTE_SERVICE_ID,
 348                                  addr_globals.ubikSecClass, addr_globals.ubikSecIndex);
 349             /* for disk reqs */
 350             ts->disk_rxcid =
 351                 rx_NewConnection(info->hostAddr[i].sin_addr.s_addr,
 352                                  ubik_callPortal, DISK_SERVICE_ID,
 353                                  addr_globals.ubikSecClass, addr_globals.ubikSecIndex);
 354             ts->up = 1;
 355         }
 356     } else {
 357         i = 0;
 358         while ((servAddr = *aservers++)) {
 359             if (i >= MAXSERVERS)
 360                 return UNHOSTS; /* too many hosts */
 361             ts = calloc(1, sizeof(struct ubik_server));
 362             ts->next = ubik_servers;
 363             ubik_servers = ts;
 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 */
 370             ts->up = 1;
 371             if (ntohl((afs_uint32) servAddr) < (afs_uint32) magicHost) {
 372                 magicHost = ntohl(servAddr);
 373                 magicServer = ts;
 374             }
 375             i++;
 376         }
 377     }
 378     if (magicServer)
 379         magicServer->magic = 1; /* remember for when counting votes */
 380
 381     if (!amIClone && !magicServer)
 382         amIMagic = 1;
 383     if (info) {
 384         if (!amIClone)
 385             ++nServers;         /* count this server as well as the remotes */
 386     } else
 387         nServers = i + 1;       /* count this server as well as the remotes */
 388
 389     ubik_quorum = (nServers >> 1) + 1;  /* compute the majority figure */
 390
 391 /* Shoud we set some defaults for RX??
 392     r_retryInterval = 2;
 393     r_nRetries = (RPCTIMEOUT/r_retryInterval);
 394 */
 395     if (info) {
 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;
 402             DBHOLD(ubik_dbase);
 403             UBIK_VERSION_LOCK;
 404             version_globals.ubik_epochTime = FT_ApproxTime();
 405             UBIK_VERSION_UNLOCK;
 406             DBRELE(ubik_dbase);
 407         }
 408     } else {
 409         if (nServers == 1)      /* special case 1 server */
 410             ubik_singleServer = 1;
 411     }
 412
 413     if (ubik_singleServer) {
 414         if (!beacon_globals.ubik_amSyncSite) {
 415             ubik_dprint("Ubik: I am the sync site - 1 server\n");
 416             DBHOLD(ubik_dbase);
 417             UBIK_VERSION_LOCK;
 418             version_globals.ubik_epochTime = FT_ApproxTime();
 419             UBIK_VERSION_UNLOCK;
 420             DBRELE(ubik_dbase);
 421         }
 422         beacon_globals.ubik_amSyncSite = 1;
 423         beacon_globals.syncSiteUntil = 0x7fffffff;      /* quite a while */
 424         beacon_globals.ubik_syncSiteAdvertised = 1;
 425     }
 426     return 0;
 427 }
 428
 429 /*!
 430  * \brief main lwp loop for code that sends out beacons.
 431  *
 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.
 434  */
 435 void *
 436 ubeacon_Interact(void *dummy)
 437 {
 438     afs_int32 code;
 439     struct timeval tt;
 440     struct rx_connection *connections[MAXSERVERS];
 441     struct ubik_server *servers[MAXSERVERS];
 442     afs_int32 i;
 443     struct ubik_server *ts;
 444     afs_int32 temp, yesVotes, lastWakeupTime, oldestYesVote, syncsite;
 445     int becameSyncSite;
 446     struct ubik_tid ttid;
 447     struct ubik_version tversion;
 448     afs_int32 startTime;
 449
 450     afs_pthread_setname_self("beacon");
 451
 452     /* loop forever getting votes */
 453     lastWakeupTime = 0;         /* keep track of time we last started a vote collection */
 454     while (1) {
 455
 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 ) */
 459         if (temp > 0) {
 460             if (temp > POLLTIME)
 461                 temp = POLLTIME;
 462             tt.tv_sec = temp;
 463             tt.tv_usec = 0;
 464 #ifdef AFS_PTHREAD_ENV
 465             select(0, 0, 0, 0, &tt);
 466 #else
 467             IOMGR_Select(0, 0, 0, 0, &tt);
 468 #endif
 469         }
 470
 471         lastWakeupTime = FT_ApproxTime();       /* started a new collection phase */
 472
 473         if (ubik_singleServer)
 474             continue;           /* special-case 1 server for speedy startup */
 475
 476         if (!uvote_ShouldIRun())
 477             continue;           /* if voter has heard from a better candidate than us, don't bother running */
 478
 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 */
 485         UBIK_BEACON_LOCK;
 486         UBIK_ADDR_LOCK;
 487         for (ts = ubik_servers; ts; ts = ts->next) {
 488             if (ts->up && ts->addr[0] != ubik_host[0]) {
 489                 servers[i] = ts;
 490                 connections[i++] = ts->vote_rxcid;
 491             }
 492         }
 493         UBIK_ADDR_UNLOCK;
 494         UBIK_BEACON_UNLOCK;
 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 */
 500
 501         UBIK_VERSION_LOCK;
 502         ttid.epoch = version_globals.ubik_epochTime;
 503         if (ubik_dbase->flags & DBWRITING) {
 504             /*
 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
 508              * last transaction.
 509              */
 510             ttid.counter = ubik_dbase->writeTidCounter;
 511         } else
 512             ttid.counter = ubik_dbase->tidCounter + 1;
 513         tversion.epoch = ubik_dbase->version.epoch;
 514         tversion.counter = ubik_dbase->version.counter;
 515         UBIK_VERSION_UNLOCK;
 516
 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();
 521         if (!syncsite) {
 522             /* Ok to use the DB lock here since we aren't sync site */
 523             DBHOLD(ubik_dbase);
 524             urecovery_ResetState();
 525             DBRELE(ubik_dbase);
 526         }
 527         startTime = FT_ApproxTime();
 528         /*
 529          * Don't waste time using mult Rx calls if there are no connections out there
 530          */
 531         if (i > 0) {
 532             char hoststr[16];
 533             multi_Rx(connections, i) {
 534                 multi_VOTE_Beacon(syncsite, startTime, &tversion,
 535                                   &ttid);
 536                 temp = FT_ApproxTime(); /* now, more or less */
 537                 ts = servers[multi_i];
 538                 UBIK_BEACON_LOCK;
 539                 ts->lastBeaconSent = temp;
 540                 code = multi_error;
 541
 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));
 554                     code = -1;
 555                 }
 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]));
 560                     code = -1;
 561                 }
 562
 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 */
 566                 if (code > 0) {
 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));
 570                         ts->up = 0;
 571                         ts->beaconSinceDown = 0;
 572                         urecovery_LostServer(ts);
 573                     } else {
 574                         ts->lastVoteTime = code;
 575                         if (code < oldestYesVote)
 576                             oldestYesVote = code;
 577                         ts->lastVote = 1;
 578                         if (!ts->isClone)
 579                             yesVotes += 2;
 580                         if (ts->magic)
 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));
 586                     }
 587                 } else if (code == 0) {
 588                     ts->lastVoteTime = temp;
 589                     ts->lastVote = 0;
 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) {
 594                     ts->up = 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));
 599                 }
 600                 UBIK_BEACON_UNLOCK;
 601             }
 602             multi_End;
 603         }
 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,
 608                          &tversion, &ttid);
 609         if (i) {
 610             yesVotes += 2;
 611             if (amIMagic)
 612                 yesVotes++;     /* extra epsilon */
 613             if (i < oldestYesVote)
 614                 oldestYesVote = i;
 615         }
 616
 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. */
 619         becameSyncSite = 0;
 620         if (yesVotes > nServers) {      /* yesVotes is bumped by 2 or 3 for each site */
 621             UBIK_BEACON_LOCK;
 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). */
 626                 becameSyncSite = 1;
 627             } else {
 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;
 632             }
 633             UBIK_BEACON_UNLOCK;
 634         } else {
 635             UBIK_BEACON_LOCK;
 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;
 640             UBIK_BEACON_UNLOCK;
 641             DBHOLD(ubik_dbase);
 642             urecovery_ResetState();     /* tell recovery we're no longer the sync site */
 643             DBRELE(ubik_dbase);
 644         }
 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) {
 654             DBHOLD(ubik_dbase);
 655             UBIK_BEACON_LOCK;
 656             UBIK_VERSION_LOCK;
 657             version_globals.ubik_epochTime = FT_ApproxTime();
 658             beacon_globals.ubik_amSyncSite = 1;
 659             beacon_globals.syncSiteUntil = oldestYesVote + SMALLTIME;
 660             UBIK_VERSION_UNLOCK;
 661             UBIK_BEACON_UNLOCK;
 662             DBRELE(ubik_dbase);
 663         }
 664
 665     }                           /* while loop */
 666     return NULL;
 667 }
 668
 669 /*!
 670  * \brief Verify that a given IP addresses does actually exist on this machine.
 671  *
 672  * \param ame      the pointer to my IP address specified in the
 673  *                 CellServDB file.
 674  * \param aservers an array containing IP
 675  *                 addresses of remote ubik servers. The array is
 676  *                 terminated by a zero address.
 677  *
 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
 682  *                 my IP addresses.
 683  *
 684  * \return 0 on success, non-zero on failure
 685  */
 686 static int
 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];
 691     char hoststr[16];
 692     int tcount, count, found, i, j, totalServers, start, end, usednetfiles =
 693         0;
 694
 695     if (info)
 696         totalServers = info->numServers;
 697     else {                      /* count the number of servers */
 698         for (totalServers = 0, servList = aservers; *servList; servList++)
 699             totalServers++;
 700     }
 701
 702     if (AFSDIR_SERVER_NETRESTRICT_FILEPATH || AFSDIR_SERVER_NETINFO_FILEPATH) {
 703         /*
 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)
 707          */
 708         char reason[1024];
 709         count = afsconf_ParseNetFiles(myAddr, NULL, NULL,
 710                                       UBIK_MAX_INTERFACE_ADDR, reason,
 711                                       AFSDIR_SERVER_NETINFO_FILEPATH,
 712                                       AFSDIR_SERVER_NETRESTRICT_FILEPATH);
 713         if (count < 0) {
 714             ubik_print("ubik: Can't register any valid addresses:%s\n",
 715                        reason);
 716             ubik_print("Aborting..\n");
 717             return UBADHOST;
 718         }
 719         usednetfiles++;
 720     } else {
 721         /* get all my interface addresses in net byte order */
 722         count = rx_getAllAddr(myAddr, UBIK_MAX_INTERFACE_ADDR);
 723     }
 724
 725     if (count <= 0) {           /* no address found */
 726         ubik_print("ubik: No network addresses found, aborting..\n");
 727         return UBADHOST;
 728     }
 729
 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 */
 733             found = 1;
 734             break;
 735         }
 736     }
 737
 738     if (!found) {
 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. */
 745         if (usednetfiles) {
 746             /* take the address we did get, then see if ame was masked */
 747             *ame = myAddr[0];
 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");
 751                 return UBADHOST;
 752             }
 753
 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 */
 757                     found = 1;
 758                     break;
 759                 }
 760             }
 761         }
 762         if (!found)
 763             return UBADHOST;
 764     }
 765
 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
 769      */
 770     for (j = 0, found = 0; j < count; j++) {
 771         for (i = 0; i < totalServers; i++) {
 772             if (info)
 773                 tmpAddr = (afs_uint32) info->hostAddr[i].sin_addr.s_addr;
 774             else
 775                 tmpAddr = aservers[i];
 776             if (myAddr[j] == tmpAddr) {
 777                 *ame = tmpAddr;
 778                 if (!info)
 779                     aservers[i] = 0;
 780                 found = 1;
 781             }
 782         }
 783     }
 784     if (found)
 785         ubik_print("Using %s as my primary address\n", afs_inet_ntoa_r(*ame, hoststr));
 786
 787     if (!info) {
 788         /* get rid of servers which were purged because all
 789          ** those interface addresses are myself
 790          */
 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++);
 794
 795             /* find the last non-zero entry from the end */
 796             for (; (end >= 0) && (!aservers[end]); end--);
 797
 798             /* if there is nothing more to purge, exit from loop */
 799             if (start >= end)
 800                 break;
 801
 802             /* move the entry */
 803             aservers[start] = aservers[end];
 804             aservers[end] = 0;  /* this entry was moved */
 805         }
 806     }
 807
 808     /* update all my addresses in ubik_host in such a way
 809      ** that ubik_host[0] has the primary address
 810      */
 811     ubik_host[0] = *ame;
 812     for (j = 0, i = 1; j < count; j++)
 813         if (*ame != myAddr[j])
 814             ubik_host[i++] = myAddr[j];
 815
 816     return 0;                   /* return success */
 817 }
 818
 819
 820 /*!
 821  * \brief Exchange IP address information with remote servers.
 822  *
 823  * \param ubik_host an array containing all my IP addresses.
 824  *
 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
 828  *
 829  * \return 0 on success, non-zero on failure
 830  */
 831 int
 832 ubeacon_updateUbikNetworkAddress(afs_uint32 ubik_host[UBIK_MAX_INTERFACE_ADDR])
 833 {
 834     int j, count, code = 0;
 835     UbikInterfaceAddr inAddr, outAddr;
 836     struct rx_connection *conns[MAXSERVERS];
 837     struct ubik_server *ts, *server[MAXSERVERS];
 838     char buffer[32];
 839     char hoststr[16];
 840
 841     UBIK_ADDR_LOCK;
 842     for (count = 0, ts = ubik_servers; ts; count++, ts = ts->next) {
 843         conns[count] = ts->disk_rxcid;
 844         server[count] = ts;
 845     }
 846     UBIK_ADDR_UNLOCK;
 847
 848
 849     /* inform all other servers only if there are more than one
 850      * database servers in the cell */
 851
 852     if (count > 0) {
 853
 854         for (j = 0; j < UBIK_MAX_INTERFACE_ADDR; j++)
 855             inAddr.hostAddr[j] = ntohl(ubik_host[j]);
 856
 857
 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 */
 862             if (!multi_error) {
 863                 UBIK_ADDR_LOCK;
 864                 if (ts->addr[0] != htonl(outAddr.hostAddr[0])) {
 865                     code = UBADHOST;
 866                     strcpy(buffer, afs_inet_ntoa_r(ts->addr[0], hoststr));
 867                     ubik_print("ubik:Two primary addresses for same server \
 868                     %s %s\n", buffer,
 869                     afs_inet_ntoa_r(htonl(outAddr.hostAddr[0]), hoststr));
 870                 } else {
 871                     for (j = 1; j < UBIK_MAX_INTERFACE_ADDR; j++)
 872                         ts->addr[j] = htonl(outAddr.hostAddr[j]);
 873                 }
 874                 UBIK_ADDR_UNLOCK;
 875             } else if (multi_error == RXGEN_OPCODE) {   /* pre 3.5 remote server */
 876                 UBIK_ADDR_LOCK;
 877                 ubik_print
 878                     ("ubik server %s does not support UpdateInterfaceAddr RPC\n",
 879                      afs_inet_ntoa_r(ts->addr[0], hoststr));
 880                 UBIK_ADDR_UNLOCK;
 881             } else if (multi_error == UBADHOST) {
 882                 code = UBADHOST;        /* remote CellServDB inconsistency */
 883                 ubik_print("Inconsistent Cell Info on server:\n");
 884                 UBIK_ADDR_LOCK;
 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));
 887                 UBIK_ADDR_UNLOCK;
 888             } else {
 889                 UBIK_BEACON_LOCK;
 890                 ts->up = 0;     /* mark the remote server as down */
 891                 UBIK_BEACON_UNLOCK;
 892             }
 893         }
 894         multi_End;
 895     }
 896     return code;
 897 }
 898
 899 void
 900 ubik_SetClientSecurityProcs(int (*secproc) (void *,
 901                                             struct rx_securityClass **,
 902                                             afs_int32 *),
 903                             int (*checkproc) (void *),
 904                             void *rock)
 905 {
 906     secLayerProc = secproc;
 907     tokenCheckProc = checkproc;
 908     securityRock = rock;
 909 }