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