src/ubik/ubikclient.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 #include <afs/stds.h>
  13
  14 #include <roken.h>
  15 #include <afs/opr.h>
  16 #ifdef AFS_PTHREAD_ENV
  17 # include <opr/lock.h>
  18 #endif
  19
  20 #ifdef IGNORE_SOME_GCC_WARNINGS
  21 # pragma GCC diagnostic warning "-Wstrict-prototypes"
  22 #endif
  23
  24 #include <afs/pthread_glock.h>
  25 #include <rx/xdr.h>
  26 #include <rx/rx.h>
  27 #include <lock.h>
  28 #include <afs/rxgen_consts.h>
  29 #define UBIK_LEGACY_CALLITER
  30 #include "ubik.h"
  31
  32 short ubik_initializationState; /*!< initial state is zero */
  33
  34
  35 /*!
  36  * \brief Parse list for clients.
  37  */
  38 int
  39 ubik_ParseClientList(int argc, char **argv, afs_uint32 * aothers)
  40 {
  41     afs_int32 i;
  42     char *tp;
  43     struct hostent *th;
  44     afs_uint32 temp;
  45     afs_int32 counter;
  46     int inServer;
  47
  48     inServer = 0;               /* haven't seen -servers yet */
  49     counter = 0;
  50     for (i = 1; i < argc; i++) {
  51         /* look for -servers argument */
  52         tp = argv[i];
  53
  54         if (inServer) {
  55             if (*tp == '-')
  56                 break;          /* done */
  57             /* otherwise this is a new host name */
  58             LOCK_GLOBAL_MUTEX;
  59             th = gethostbyname(tp);
  60             if (!th) {
  61                 UNLOCK_GLOBAL_MUTEX;
  62                 return UBADHOST;
  63             }
  64             memmove((void *)&temp, (const void *)th->h_addr,
  65                     sizeof(afs_int32));
  66             UNLOCK_GLOBAL_MUTEX;
  67             if (counter++ >= MAXSERVERS)
  68                 return UNHOSTS;
  69             *aothers++ = temp;
  70         } else {
  71             /* haven't seen a -server yet */
  72             if (!strcmp(tp, "-servers")) {
  73                 inServer = 1;
  74             }
  75         }
  76     }
  77     if (!inServer) {
  78         /* never saw a -server */
  79         return UNOENT;
  80     }
  81     if (counter < MAXSERVERS)
  82         *aothers++ = 0;         /* null terminate if room */
  83     return 0;
  84 }
  85
  86 #ifdef AFS_PTHREAD_ENV
  87 #include <pthread.h>
  88
  89 static pthread_once_t random_once = PTHREAD_ONCE_INIT;
  90 static int called_afs_random_once;
  91 static pthread_key_t random_number_key;
  92
  93 static void
  94 afs_random_once(void)
  95 {
  96     opr_Verify(pthread_key_create(&random_number_key, NULL) == 0);
  97     called_afs_random_once = 1;
  98 }
  99
 100 #endif
 101
 102 /*!
 103  * \brief use time and pid to try to get some initial randomness.
 104  */
 105 #define ranstage(x)     (x)= (afs_uint32) (3141592621U*((afs_uint32)x)+1)
 106
 107 /*!
 108  * \brief Random number generator and constants from KnuthV2 2d ed, p170
 109  *
 110  * Rules: \n
 111  * X = (aX + c) % m \n
 112  * m is a power of two \n
 113  * a % 8 is 5 \n
 114  * a is 0.73m  should be 0.01m .. 0.99m \n
 115  * c is more or less immaterial.  1 or a is suggested. \n
 116  *
 117  * NB:  LOW ORDER BITS are not very random.  To get small random numbers,
 118  *      treat result as <1, with implied binary point, and multiply by
 119  *      desired modulus.
 120  *
 121  * NB:  Has to be unsigned, since shifts on signed quantities may preserve
 122  *      the sign bit.
 123  *
 124  * In this case, m == 2^32, the mod operation is implicit. a == pi, which
 125  * is used because it has some interesting characteristics (lacks any
 126  * interesting bit-patterns).
 127  */
 128 unsigned int
 129 afs_random(void)
 130 {
 131 #ifdef AFS_PTHREAD_ENV
 132     afs_uint32 state;
 133
 134     if (!called_afs_random_once)
 135         pthread_once(&random_once, afs_random_once);
 136
 137     state = (uintptr_t) pthread_getspecific(random_number_key);
 138 #else
 139     static afs_uint32 state = 0;
 140 #endif
 141
 142     if (!state) {
 143         int i;
 144         state = time(0) + getpid();
 145         for (i = 0; i < 15; i++) {
 146             ranstage(state);
 147         }
 148     }
 149
 150     ranstage(state);
 151 #ifdef AFS_PTHREAD_ENV
 152     pthread_setspecific(random_number_key, (const void *)(uintptr_t)state);
 153 #endif
 154     return (state);
 155
 156 }
 157
 158 /*!
 159  * \brief Returns int 0..14 using the high bits of a pseudo-random number instead of
 160  * the low bits, as the low bits are "less random" than the high ones...
 161  *
 162  * \todo Slight roundoff error exists, an excercise for the reader.
 163  *
 164  * Need to multiply by something with lots of ones in it, so multiply by
 165  * 8 or 16 is right out.
 166  */
 167 static unsigned int
 168 afs_randomMod15(void)
 169 {
 170     afs_uint32 temp;
 171
 172     temp = afs_random() >> 4;
 173     temp = (temp * 15) >> 28;
 174
 175     return temp;
 176 }
 177
 178 #ifdef abs
 179 #undef abs
 180 #endif /* abs */
 181 #define abs(a) ((a) < 0 ? -1*(a) : (a))
 182 int
 183 ubik_ClientInit(struct rx_connection **serverconns,
 184                 struct ubik_client **aclient)
 185 {
 186     int i, j;
 187     int count;
 188     int offset;
 189     struct ubik_client *tc;
 190
 191     initialize_U_error_table();
 192
 193     if (*aclient) {             /* the application is doing a re-initialization */
 194         LOCK_UBIK_CLIENT((*aclient));
 195         /* this is an important defensive check */
 196         if (!((*aclient)->initializationState)) {
 197             UNLOCK_UBIK_CLIENT((*aclient));
 198             return UREINITIALIZE;
 199         }
 200
 201         /* release all existing connections */
 202         for (tc = *aclient, i = 0; i < MAXSERVERS; i++) {
 203             struct rx_connection *rxConn = ubik_GetRPCConn(tc, i);
 204             if (rxConn == 0)
 205                 break;
 206 #ifdef AFS_PTHREAD_ENV
 207             rx_ReleaseCachedConnection(rxConn);
 208 #else
 209             rx_DestroyConnection(rxConn);
 210 #endif
 211         }
 212         UNLOCK_UBIK_CLIENT((*aclient));
 213 #ifdef AFS_PTHREAD_ENV
 214         if (pthread_mutex_destroy(&((*aclient)->cm)))
 215             return UMUTEXDESTROY;
 216 #endif
 217     } else {
 218         tc = malloc(sizeof(struct ubik_client));
 219     }
 220     if (tc == NULL)
 221         return UNOMEM;
 222     memset((void *)tc, 0, sizeof(*tc));
 223 #ifdef AFS_PTHREAD_ENV
 224     if (pthread_mutex_init(&(tc->cm), (const pthread_mutexattr_t *)0)) {
 225         free(tc);
 226         return UMUTEXINIT;
 227     }
 228 #endif
 229     tc->initializationState = ++ubik_initializationState;
 230
 231     /* first count the # of server conns so we can randomize properly */
 232     count = 0;
 233     for (i = 0; i < MAXSERVERS; i++) {
 234         if (serverconns[i] == (struct rx_connection *)0)
 235             break;
 236         count++;
 237     }
 238
 239     /* here count is the # of servers we're actually passed in.  Compute
 240      * offset, a number between 0..count-1, where we'll start copying from the
 241      * client-provided array. */
 242     for (i = 0; i < count; i++) {
 243         offset = afs_randomMod15() % count;
 244         for (j = abs(offset); j < 2 * count; j++) {
 245             if (!tc->conns[abs(j % count)]) {
 246                 tc->conns[abs(j % count)] = serverconns[i];
 247                 break;
 248             }
 249         }
 250     }
 251
 252     *aclient = tc;
 253     return 0;
 254 }
 255
 256 /*!
 257  * \brief Destroy an ubik connection.
 258  *
 259  * It calls rx to destroy the component rx connections, then frees the ubik
 260  * connection structure.
 261  */
 262 afs_int32
 263 ubik_ClientDestroy(struct ubik_client * aclient)
 264 {
 265     int c;
 266
 267     if (aclient == 0)
 268         return 0;
 269     LOCK_UBIK_CLIENT(aclient);
 270     for (c = 0; c < MAXSERVERS; c++) {
 271         struct rx_connection *rxConn = ubik_GetRPCConn(aclient, c);
 272         if (rxConn == 0)
 273             break;
 274 #ifdef AFS_PTHREAD_ENV
 275         rx_ReleaseCachedConnection(rxConn);
 276 #else
 277         rx_DestroyConnection(rxConn);
 278 #endif
 279     }
 280     aclient->initializationState = 0;   /* client in not initialized */
 281     UNLOCK_UBIK_CLIENT(aclient);
 282 #ifdef AFS_PTHREAD_ENV
 283     pthread_mutex_destroy(&(aclient->cm));      /* ignore failure */
 284 #endif
 285     free(aclient);
 286     return 0;
 287 }
 288
 289 /*!
 290  * \brief So that intermittent failures that cause connections to die
 291  *     don't kill whole ubik connection, refresh them when the connection is in
 292  *     error.
 293  */
 294 struct rx_connection *
 295 ubik_RefreshConn(struct rx_connection *tc)
 296 {
 297     afs_uint32 host;
 298     u_short port;
 299     u_short service;
 300     struct rx_securityClass *sc;
 301     int si;
 302     struct rx_connection *newTc;
 303
 304     host = rx_HostOf(rx_PeerOf(tc));
 305     port = rx_PortOf(rx_PeerOf(tc));
 306     service = rx_ServiceIdOf(tc);
 307     sc = rx_SecurityObjectOf(tc);
 308     si = rx_SecurityClassOf(tc);
 309
 310     /*
 311      * destroy old one after creating new one so that refCount on security
 312      * object cannot reach zero.
 313      */
 314     newTc = rx_NewConnection(host, port, service, sc, si);
 315     rx_DestroyConnection(tc);
 316     return newTc;
 317 }
 318
 319 #ifdef AFS_PTHREAD_ENV
 320
 321 pthread_once_t ubik_client_once = PTHREAD_ONCE_INIT;
 322 pthread_mutex_t ubik_client_mutex;
 323 #define LOCK_UCLNT_CACHE do { \
 324     opr_Verify(pthread_once(&ubik_client_once, ubik_client_init_mutex) == 0); \
 325     MUTEX_ENTER(&ubik_client_mutex); \
 326   } while (0)
 327 #define UNLOCK_UCLNT_CACHE MUTEX_EXIT(&ubik_client_mutex)
 328
 329 void
 330 ubik_client_init_mutex(void)
 331 {
 332     MUTEX_INIT(&ubik_client_mutex, "client init", MUTEX_DEFAULT, 0);
 333 }
 334
 335 #else
 336
 337 #define LOCK_UCLNT_CACHE
 338 #define UNLOCK_UCLNT_CACHE
 339
 340 #endif
 341
 342 #define SYNCCOUNT 10
 343 static int *calls_needsync[SYNCCOUNT];  /* proc calls that need the sync site */
 344 static int synccount = 0;
 345
 346
 347
 348 /*!
 349  * \brief Call this after getting back a #UNOTSYNC.
 350  *
 351  * \note Getting a #UNOTSYNC error code back does \b not guarantee
 352  * that there is a sync site yet elected.  However, if there is a sync
 353  * site out there somewhere, and you're trying an operation that
 354  * requires a sync site, ubik will return #UNOTSYNC, indicating the
 355  * operation won't work until you find a sync site
 356  */
 357 static int
 358 try_GetSyncSite(struct ubik_client *aclient, afs_int32 apos)
 359 {
 360     struct rx_peer *rxp;
 361     afs_int32 code;
 362     int i;
 363     afs_int32 thisHost, newHost;
 364     struct rx_connection *tc;
 365     short origLevel;
 366
 367     origLevel = aclient->initializationState;
 368
 369     /* get this conn */
 370     tc = aclient->conns[apos];
 371     if (tc && rx_ConnError(tc)) {
 372         aclient->conns[apos] = (tc = ubik_RefreshConn(tc));
 373     }
 374     if (!tc) {
 375         return -1;
 376     }
 377
 378     /* now see if we can find the sync site host */
 379     code = VOTE_GetSyncSite(tc, &newHost);
 380     if (aclient->initializationState != origLevel) {
 381         return -1;              /* somebody did a ubik_ClientInit */
 382     }
 383
 384     if (!code && newHost) {
 385         newHost = htonl(newHost);       /* convert back to network order */
 386
 387         /*
 388          * position count at the appropriate slot in the client
 389          * structure and retry. If we can't find in slot, we'll just
 390          * continue through the whole list
 391          */
 392         for (i = 0; i < MAXSERVERS; i++) {
 393             rxp = rx_PeerOf(aclient->conns[i]);
 394             thisHost = rx_HostOf(rxp);
 395             if (!thisHost) {
 396                 return -1;
 397             } else if (thisHost == newHost) {
 398                 return i;       /* we were told to use this one */
 399             }
 400         }
 401     }
 402     return -1;
 403 }
 404
 405 #define NEED_LOCK 1
 406 #define NO_LOCK 0
 407
 408 /*!
 409  * \brief Create an internal version of ubik_CallIter that takes an additional
 410  * parameter - to indicate whether the ubik client handle has already
 411  * been locked.
 412  */
 413 static afs_int32
 414 CallIter(int (*aproc) (), struct ubik_client *aclient,
 415          afs_int32 aflags, int *apos, long p1, long p2, long p3, long p4,
 416          long p5, long p6, long p7, long p8, long p9, long p10, long p11,
 417          long p12, long p13, long p14, long p15, long p16, int needlock)
 418 {
 419     afs_int32 code;
 420     struct rx_connection *tc;
 421     short origLevel;
 422
 423     if (needlock) {
 424         LOCK_UBIK_CLIENT(aclient);
 425     }
 426     origLevel = aclient->initializationState;
 427
 428     code = UNOSERVERS;
 429
 430     while (*apos < MAXSERVERS) {
 431         /* tc is the next conn to try */
 432         tc = aclient->conns[*apos];
 433         if (!tc)
 434             goto errout;
 435
 436         if (rx_ConnError(tc)) {
 437             tc = ubik_RefreshConn(tc);
 438             aclient->conns[*apos] = tc;
 439         }
 440
 441         if ((aflags & UPUBIKONLY) && (aclient->states[*apos] & CFLastFailed)) {
 442             (*apos)++;          /* try another one if this server is down */
 443         } else {
 444             break;              /* this is the desired path */
 445         }
 446     }
 447     if (*apos >= MAXSERVERS)
 448         goto errout;
 449
 450     code =
 451         (*aproc) (tc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
 452                   p14, p15, p16);
 453     if (aclient->initializationState != origLevel)
 454         /* somebody did a ubik_ClientInit */
 455         goto errout;
 456
 457     /* what should I do in case of UNOQUORUM ? */
 458     if (code < 0) {
 459         aclient->states[*apos] |= CFLastFailed; /* network errors */
 460     } else {
 461         /* either misc ubik code, or misc application code or success. */
 462         aclient->states[*apos] &= ~CFLastFailed;        /* operation worked */
 463     }
 464
 465     (*apos)++;
 466 errout:
 467     if (needlock) {
 468         UNLOCK_UBIK_CLIENT(aclient);
 469     }
 470     return code;
 471 }
 472
 473 /*!
 474  * \brief This is part of an iterator.  It doesn't handle finding sync sites.
 475  */
 476 afs_int32
 477 ubik_CallIter(int (*aproc) (), struct ubik_client *aclient,
 478                                afs_int32 aflags, int *apos, long p1, long p2,
 479                                long p3, long p4, long p5, long p6, long p7,
 480                                long p8, long p9, long p10, long p11, long p12,
 481                                long p13, long p14, long p15, long p16)
 482 {
 483     return CallIter(aproc, aclient, aflags, apos, p1, p2, p3, p4, p5, p6, p7,
 484                     p8, p9, p10, p11, p12, p13, p14, p15, p16, NEED_LOCK);
 485 }
 486
 487 /*!
 488  * \brief Call this instead of stub and we'll guarantee to find a host that's up.
 489  *
 490  * \todo In the future, we should also put in a protocol to find the sync site.
 491  */
 492 afs_int32
 493 ubik_Call_New(int (*aproc) (), struct ubik_client *aclient,
 494               afs_int32 aflags, long p1, long p2, long p3, long p4, long p5,
 495               long p6, long p7, long p8, long p9, long p10, long p11,
 496               long p12, long p13, long p14, long p15, long p16)
 497 {
 498     afs_int32 code, rcode;
 499     afs_int32 count;
 500     afs_int32 temp;
 501     int pass;
 502     int stepBack;
 503     short origLevel;
 504
 505     LOCK_UBIK_CLIENT(aclient);
 506   restart:
 507     rcode = UNOSERVERS;
 508     origLevel = aclient->initializationState;
 509
 510     /* Do two passes. First pass only checks servers known running */
 511     for (aflags |= UPUBIKONLY, pass = 0; pass < 2;
 512          pass++, aflags &= ~UPUBIKONLY) {
 513         stepBack = 0;
 514         count = 0;
 515         while (1) {
 516             code =
 517                 CallIter(aproc, aclient, aflags, &count, p1, p2, p3, p4, p5,
 518                          p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16,
 519                          NO_LOCK);
 520             if (code && (aclient->initializationState != origLevel)) {
 521                 goto restart;
 522             }
 523             if (code == UNOSERVERS) {
 524                 break;
 525             }
 526             rcode = code;       /* remember code from last good call */
 527
 528             if (code == UNOTSYNC) {     /* means this requires a sync site */
 529                 if (aclient->conns[3]) {        /* don't bother unless 4 or more srv */
 530                     temp = try_GetSyncSite(aclient, count);
 531                     if (aclient->initializationState != origLevel) {
 532                         goto restart;   /* somebody did a ubik_ClientInit */
 533                     }
 534                     if ((temp >= 0) && ((temp > count) || (stepBack++ <= 2))) {
 535                         count = temp;   /* generally try to make progress */
 536                     }
 537                 }
 538             } else if ((code >= 0) && (code != UNOQUORUM)) {
 539                 UNLOCK_UBIK_CLIENT(aclient);
 540                 return code;    /* success or global error condition */
 541             }
 542         }
 543     }
 544     UNLOCK_UBIK_CLIENT(aclient);
 545     return rcode;
 546 }
 547
 548 /*!
 549  * call this instead of stub and we'll guarantee to find a host that's up.
 550  *
 551  * \todo In the future, we should also put in a protocol to find the sync site.
 552  */
 553 afs_int32
 554 ubik_Call(int (*aproc) (), struct ubik_client *aclient,
 555           afs_int32 aflags, long p1, long p2, long p3, long p4,
 556           long p5, long p6, long p7, long p8, long p9, long p10,
 557           long p11, long p12, long p13, long p14, long p15, long p16)
 558 {
 559     afs_int32 rcode, code, newHost, thisHost, i, count;
 560     int chaseCount, pass, needsync, inlist, j;
 561     struct rx_connection *tc;
 562     struct rx_peer *rxp;
 563     short origLevel;
 564
 565     if (aflags & UBIK_CALL_NEW)
 566         return ubik_Call_New(aproc, aclient, aflags, p1, p2, p3, p4,
 567                              p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15,
 568                              p16);
 569
 570     if (!aclient)
 571         return UNOENT;
 572     LOCK_UBIK_CLIENT(aclient);
 573
 574   restart:
 575     origLevel = aclient->initializationState;
 576     rcode = UNOSERVERS;
 577     chaseCount = inlist = needsync = 0;
 578
 579     LOCK_UCLNT_CACHE;
 580     for (j = 0; ((j < SYNCCOUNT) && calls_needsync[j]); j++) {
 581         if (calls_needsync[j] == (int *)aproc) {
 582             inlist = needsync = 1;
 583             break;
 584         }
 585     }
 586     UNLOCK_UCLNT_CACHE;
 587     /*
 588      * First  pass, we try all servers that are up.
 589      * Second pass, we try all servers.
 590      */
 591     for (pass = 0; pass < 2; pass++) {  /*p */
 592         /* For each entry in our servers list */
 593         for (count = 0;; count++) {     /*s */
 594
 595             if (needsync) {
 596                 /* Need a sync site. Lets try to quickly find it */
 597                 if (aclient->syncSite) {
 598                     newHost = aclient->syncSite;        /* already in network order */
 599                     aclient->syncSite = 0;      /* Will reset if it works */
 600                 } else if (aclient->conns[3]) {
 601                     /* If there are fewer than four db servers in a cell,
 602                      * there's no point in making the GetSyncSite call.
 603                      * At best, it's a wash. At worst, it results in more
 604                      * RPCs than you would otherwise make.
 605                      */
 606                     tc = aclient->conns[count];
 607                     if (tc && rx_ConnError(tc)) {
 608                         aclient->conns[count] = tc = ubik_RefreshConn(tc);
 609                     }
 610                     if (!tc)
 611                         break;
 612                     code = VOTE_GetSyncSite(tc, &newHost);
 613                     if (aclient->initializationState != origLevel)
 614                         goto restart;   /* somebody did a ubik_ClientInit */
 615                     if (code)
 616                         newHost = 0;
 617                     newHost = htonl(newHost);   /* convert to network order */
 618                 } else {
 619                     newHost = 0;
 620                 }
 621                 if (newHost) {
 622                     /* position count at the appropriate slot in the client
 623                      * structure and retry. If we can't find in slot, we'll
 624                      * just continue through the whole list
 625                      */
 626                     for (i = 0; i < MAXSERVERS && aclient->conns[i]; i++) {
 627                         rxp = rx_PeerOf(aclient->conns[i]);
 628                         thisHost = rx_HostOf(rxp);
 629                         if (!thisHost)
 630                             break;
 631                         if (thisHost == newHost) {
 632                             if (chaseCount++ > 2)
 633                                 break;  /* avoid loop asking */
 634                             count = i;  /* this index is the sync site */
 635                             break;
 636                         }
 637                     }
 638                 }
 639             }
 640             /*needsync */
 641             tc = aclient->conns[count];
 642             if (tc && rx_ConnError(tc)) {
 643                 aclient->conns[count] = tc = ubik_RefreshConn(tc);
 644             }
 645             if (!tc)
 646                 break;
 647
 648             if ((pass == 0) && (aclient->states[count] & CFLastFailed)) {
 649                 continue;       /* this guy's down */
 650             }
 651
 652             rcode =
 653                 (*aproc) (tc, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11,
 654                           p12, p13, p14, p15, p16);
 655             if (aclient->initializationState != origLevel) {
 656                 /* somebody did a ubik_ClientInit */
 657                 if (rcode)
 658                     goto restart;       /* call failed */
 659                 else
 660                     goto done;  /* call suceeded */
 661             }
 662             if (rcode < 0) {    /* network errors */
 663                 aclient->states[count] |= CFLastFailed; /* Mark serer down */
 664             } else if (rcode == UNOTSYNC) {
 665                 needsync = 1;
 666             } else if (rcode != UNOQUORUM) {
 667                 /* either misc ubik code, or misc appl code, or success. */
 668                 aclient->states[count] &= ~CFLastFailed;        /* mark server up */
 669                 goto done;      /* all done */
 670             }
 671         }                       /*s */
 672     }                           /*p */
 673
 674   done:
 675     if (needsync) {
 676         if (!inlist) {          /* Remember proc call that needs sync site */
 677             LOCK_UCLNT_CACHE;
 678             calls_needsync[synccount % SYNCCOUNT] = (int *)aproc;
 679             synccount++;
 680             UNLOCK_UCLNT_CACHE;
 681             inlist = 1;
 682         }
 683         if (!rcode) {           /* Remember the sync site - cmd successful */
 684             rxp = rx_PeerOf(aclient->conns[count]);
 685             aclient->syncSite = rx_HostOf(rxp);
 686         }
 687     }
 688     UNLOCK_UBIK_CLIENT(aclient);
 689     return rcode;
 690 }
 691
 692 afs_int32
 693 ubik_CallRock(struct ubik_client *aclient, afs_int32 aflags,
 694               ubik_callrock_func proc, void *rock)
 695 {
 696     afs_int32 rcode, code, newHost, thisHost, i, _ucount;
 697     int chaseCount, pass, needsync;
 698     struct rx_connection *tc;
 699     struct rx_peer *rxp;
 700     short origLevel;
 701
 702     if (!aclient)
 703         return UNOENT;
 704     LOCK_UBIK_CLIENT(aclient);
 705
 706  restart:
 707     origLevel = aclient->initializationState;
 708     rcode = UNOSERVERS;
 709     chaseCount = needsync = 0;
 710
 711     /*
 712      * First  pass, we try all servers that are up.
 713      * Second pass, we try all servers.
 714      */
 715     for (pass = 0; pass < 2; pass++) {
 716         /* For each entry in our servers list */
 717         for (_ucount = 0;; _ucount++) {
 718             struct ubik_callrock_info info;
 719             if (needsync) {
 720                 /* Need a sync site. Lets try to quickly find it */
 721                 if (aclient->syncSite) {
 722                     newHost = aclient->syncSite;        /* already in network order */
 723                     aclient->syncSite = 0;      /* Will reset if it works */
 724                 } else if (aclient->conns[3]) {
 725                     /*
 726                      * If there are fewer than four db servers in a cell,
 727                      * there's no point in making the GetSyncSite call.
 728                      * At best, it's a wash. At worst, it results in more
 729                      * RPCs than you would otherwise make.
 730                      */
 731                     tc = aclient->conns[_ucount];
 732                     if (tc && rx_ConnError(tc)) {
 733                         aclient->conns[_ucount] = tc = ubik_RefreshConn(tc);
 734                     }
 735                     if (!tc)
 736                         break;
 737                     code = VOTE_GetSyncSite(tc, &newHost);
 738                     if (aclient->initializationState != origLevel)
 739                         goto restart;   /* somebody did a ubik_ClientInit */
 740                     if (code)
 741                         newHost = 0;
 742                     newHost = htonl(newHost);   /* convert to network order */
 743                 } else {
 744                     newHost = 0;
 745                 }
 746                 if (newHost) {
 747                     /*
 748                      * position count at the appropriate slot in the client
 749                      * structure and retry. If we can't find in slot, we'll
 750                      * just continue through the whole list
 751                      */
 752                     for (i = 0; i < MAXSERVERS && aclient->conns[i]; i++) {
 753                         rxp = rx_PeerOf(aclient->conns[i]);
 754                         thisHost = rx_HostOf(rxp);
 755                         if (!thisHost)
 756                             break;
 757                         if (thisHost == newHost) {
 758                             if (chaseCount++ > 2)
 759                                 break;  /* avoid loop asking */
 760                             _ucount = i;  /* this index is the sync site */
 761                             break;
 762                         }
 763                     }
 764                 }
 765             }
 766             /*needsync */
 767             tc = aclient->conns[_ucount];
 768             if (tc && rx_ConnError(tc)) {
 769                 aclient->conns[_ucount] = tc = ubik_RefreshConn(tc);
 770             }
 771             if (!tc)
 772                 break;
 773
 774             if ((pass == 0) && (aclient->states[_ucount] & CFLastFailed)) {
 775                 continue;       /* this guy's down */
 776             }
 777
 778             memset(&info, 0, sizeof(info));
 779             info.conn = tc;
 780             rcode = (*proc)(&info, rock);
 781
 782             if (aclient->initializationState != origLevel) {
 783                 /* somebody did a ubik_ClientInit */
 784                 if (rcode)
 785                     goto restart;       /* call failed */
 786                 else
 787                     goto done;  /* call suceeded */
 788             }
 789             if (rcode < 0) {    /* network errors */
 790                 aclient->states[_ucount] |= CFLastFailed; /* Mark server down */
 791             } else if (rcode == UNOTSYNC) {
 792                 needsync = 1;
 793             } else if (rcode != UNOQUORUM) {
 794                 /* either misc ubik code, or misc appl code, or success. */
 795                 aclient->states[_ucount] &= ~CFLastFailed;      /* mark server up*/
 796                 goto done;      /* all done */
 797             }
 798         }
 799     }
 800
 801  done:
 802     if (needsync) {
 803         if (!rcode) {           /* Remember the sync site - cmd successful */
 804             rxp = rx_PeerOf(aclient->conns[_ucount]);
 805             aclient->syncSite = rx_HostOf(rxp);
 806         }
 807     }
 808     UNLOCK_UBIK_CLIENT(aclient);
 809     return rcode;
 810 }