src/ubik/ubik.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 <sys/types.h>
  16 #include <string.h>
  17 #include <stdarg.h>
  18 #include <time.h>
  19
  20 #ifdef AFS_NT40_ENV
  21 #include <winsock2.h>
  22 #else
  23 #include <sys/file.h>
  24 #include <netinet/in.h>
  25 #include <sys/param.h>
  26 #endif
  27
  28 #include <lock.h>
  29 #include <rx/xdr.h>
  30 #include <rx/rx.h>
  31 #include <afs/cellconfig.h>
  32
  33 #define UBIK_INTERNALS
  34 #include "ubik.h"
  35 #include "ubik_int.h"
  36
  37 #include <lwp.h>   /* temporary hack by klm */
  38
  39 #define ERROR_EXIT(code) {error=(code); goto error_exit;}
  40
  41 /*!
  42  * \file
  43  * This system is organized in a hierarchical set of related modules.  Modules
  44  * at one level can only call modules at the same level or below.
  45  *
  46  * At the bottom level (0) we have R, RFTP, LWP and IOMGR, i.e. the basic
  47  * operating system primitives.
  48  *
  49  * At the next level (1) we have
  50  *
  51  * \li VOTER--The module responsible for casting votes when asked.  It is also
  52  * responsible for determining whether this server should try to become
  53  * a synchronization site.
  54  * \li BEACONER--The module responsible for sending keep-alives out when a
  55  * server is actually the sync site, or trying to become a sync site.
  56  * \li DISK--The module responsible for representing atomic transactions
  57  * on the local disk.  It maintains a new-value only log.
  58  * \li LOCK--The module responsible for locking byte ranges in the database file.
  59  *
  60  * At the next level (2) we have
  61  *
  62  * \li RECOVERY--The module responsible for ensuring that all members of a quorum
  63  * have the same up-to-date database after a new synchronization site is
  64  * elected.  This module runs only on the synchronization site.
  65  *
  66  * At the next level (3) we have
  67  *
  68  * \li REMOTE--The module responsible for interpreting requests from the sync
  69  * site and applying them to the database, after obtaining the appropriate
  70  * locks.
  71  *
  72  * At the next level (4) we have
  73  *
  74  * \li UBIK--The module users call to perform operations on the database.
  75  */
  76
  77
  78 /* some globals */
  79 afs_int32 ubik_quorum = 0;
  80 struct ubik_dbase *ubik_dbase = 0;
  81 struct ubik_stats ubik_stats;
  82 afs_uint32 ubik_host[UBIK_MAX_INTERFACE_ADDR];
  83 afs_int32 ubik_epochTime = 0;
  84 afs_int32 urecovery_state = 0;
  85 int (*ubik_SRXSecurityProc) (void *, struct rx_securityClass **, afs_int32 *);
  86 void *ubik_SRXSecurityRock;
  87 int (*ubik_SyncWriterCacheProc) (void);
  88 struct ubik_server *ubik_servers;
  89 short ubik_callPortal;
  90
  91 static int BeginTrans(struct ubik_dbase *dbase, afs_int32 transMode,
  92                       struct ubik_trans **transPtr, int readAny);
  93
  94 struct rx_securityClass *ubik_sc[3];
  95
  96 #define CStampVersion       1   /* meaning set ts->version */
  97
  98 static_inline struct rx_connection *
  99 Quorum_StartIO(struct ubik_trans *atrans, struct ubik_server *as)
 100 {
 101     struct rx_connection *conn;
 102
 103     conn = as->disk_rxcid;
 104
 105 #ifdef AFS_PTHREAD_ENV
 106     rx_GetConnection(conn);
 107     DBRELE(atrans->dbase);
 108 #endif /* AFS_PTHREAD_ENV */
 109
 110     return conn;
 111 }
 112
 113 static_inline void
 114 Quorum_EndIO(struct ubik_trans *atrans, struct rx_connection *aconn)
 115 {
 116 #ifdef AFS_PTHREAD_ENV
 117     DBHOLD(atrans->dbase);
 118     rx_PutConnection(aconn);
 119 #endif /* AFS_PTHREAD_ENV */
 120 }
 121
 122 /*!
 123  * \brief Perform an operation at a quorum, handling error conditions.
 124  * \return 0 if all worked and a quorum was contacted successfully
 125  * \return otherwise mark failing server as down and return #UERROR
 126  *
 127  * \note If any server misses an update, we must wait #BIGTIME seconds before
 128  * allowing the transaction to commit, to ensure that the missing and
 129  * possibly still functioning server times out and stops handing out old
 130  * data.  This is done in the commit code, where we wait for a server marked
 131  * down to have stayed down for #BIGTIME seconds before we allow a transaction
 132  * to commit.  A server that fails but comes back up won't give out old data
 133  * because it is sent the sync count along with the beacon message that
 134  * marks it as \b really up (\p beaconSinceDown).
 135  */
 136 afs_int32
 137 ContactQuorum_NoArguments(afs_int32 (*proc)(struct rx_connection *, ubik_tid *),
 138                           struct ubik_trans *atrans, int aflags)
 139 {
 140     struct ubik_server *ts;
 141     afs_int32 code;
 142     afs_int32 rcode, okcalls;
 143     struct rx_connection *conn;
 144
 145     rcode = 0;
 146     okcalls = 0;
 147     for (ts = ubik_servers; ts; ts = ts->next) {
 148         /* for each server */
 149         if (!ts->up || !ts->currentDB) {
 150             ts->currentDB = 0;  /* db is no longer current; we just missed an update */
 151             continue;           /* not up-to-date, don't bother */
 152         }
 153
 154         conn = Quorum_StartIO(atrans, ts);
 155
 156         code = (*proc)(conn, &atrans->tid);
 157
 158         Quorum_EndIO(atrans, conn);
 159         conn = NULL;
 160
 161         if (code) {             /* failure */
 162             rcode = code;
 163             ts->up = 0;         /* mark as down now; beacons will no longer be sent */
 164             ts->currentDB = 0;
 165             ts->beaconSinceDown = 0;
 166             urecovery_LostServer();     /* tell recovery to try to resend dbase later */
 167         } else {                /* success */
 168             if (!ts->isClone)
 169                 okcalls++;      /* count up how many worked */
 170             if (aflags & CStampVersion) {
 171                 ts->version = atrans->dbase->version;
 172             }
 173         }
 174     }
 175     /* return 0 if we successfully contacted a quorum, otherwise return error code.  We don't have to contact ourselves (that was done locally) */
 176     if (okcalls + 1 >= ubik_quorum)
 177         return 0;
 178     else
 179         return rcode;
 180 }
 181
 182 afs_int32
 183 ContactQuorum_DISK_Lock(struct ubik_trans *atrans, int aflags,afs_int32 file,
 184                         afs_int32 position, afs_int32 length, afs_int32 type)
 185 {
 186     struct ubik_server *ts;
 187     afs_int32 code;
 188     afs_int32 rcode, okcalls;
 189     struct rx_connection *conn;
 190
 191     rcode = 0;
 192     okcalls = 0;
 193     for (ts = ubik_servers; ts; ts = ts->next) {
 194         /* for each server */
 195         if (!ts->up || !ts->currentDB) {
 196             ts->currentDB = 0;  /* db is no longer current; we just missed an update */
 197             continue;           /* not up-to-date, don't bother */
 198         }
 199
 200         conn = Quorum_StartIO(atrans, ts);
 201
 202         code = DISK_Lock(conn, &atrans->tid, file, position, length, type);
 203
 204         Quorum_EndIO(atrans, conn);
 205         conn = NULL;
 206
 207         if (code) {             /* failure */
 208             rcode = code;
 209             ts->up = 0;         /* mark as down now; beacons will no longer be sent */
 210             ts->currentDB = 0;
 211             ts->beaconSinceDown = 0;
 212             urecovery_LostServer();     /* tell recovery to try to resend dbase later */
 213         } else {                /* success */
 214             if (!ts->isClone)
 215                 okcalls++;      /* count up how many worked */
 216             if (aflags & CStampVersion) {
 217                 ts->version = atrans->dbase->version;
 218             }
 219         }
 220     }
 221     /* return 0 if we successfully contacted a quorum, otherwise return error code.  We don't have to contact ourselves (that was done locally) */
 222     if (okcalls + 1 >= ubik_quorum)
 223         return 0;
 224     else
 225         return rcode;
 226 }
 227
 228 afs_int32
 229 ContactQuorum_DISK_Write(struct ubik_trans *atrans, int aflags,
 230                          afs_int32 file, afs_int32 position, bulkdata *data)
 231 {
 232     struct ubik_server *ts;
 233     afs_int32 code;
 234     afs_int32 rcode, okcalls;
 235     struct rx_connection *conn;
 236
 237     rcode = 0;
 238     okcalls = 0;
 239     for (ts = ubik_servers; ts; ts = ts->next) {
 240         /* for each server */
 241         if (!ts->up || !ts->currentDB) {
 242             ts->currentDB = 0;  /* db is no longer current; we just missed an update */
 243             continue;           /* not up-to-date, don't bother */
 244         }
 245
 246         conn = Quorum_StartIO(atrans, ts);
 247
 248         code = DISK_Write(conn, &atrans->tid, file, position, data);
 249
 250         Quorum_EndIO(atrans, conn);
 251         conn = NULL;
 252
 253         if (code) {             /* failure */
 254             rcode = code;
 255             ts->up = 0;         /* mark as down now; beacons will no longer be sent */
 256             ts->currentDB = 0;
 257             ts->beaconSinceDown = 0;
 258             urecovery_LostServer();     /* tell recovery to try to resend dbase later */
 259         } else {                /* success */
 260             if (!ts->isClone)
 261                 okcalls++;      /* count up how many worked */
 262             if (aflags & CStampVersion) {
 263                 ts->version = atrans->dbase->version;
 264             }
 265         }
 266     }
 267     /* return 0 if we successfully contacted a quorum, otherwise return error code.  We don't have to contact ourselves (that was done locally) */
 268     if (okcalls + 1 >= ubik_quorum)
 269         return 0;
 270     else
 271         return rcode;
 272 }
 273
 274 afs_int32
 275 ContactQuorum_DISK_Truncate(struct ubik_trans *atrans, int aflags,
 276                             afs_int32 file, afs_int32 length)
 277 {
 278     struct ubik_server *ts;
 279     afs_int32 code;
 280     afs_int32 rcode, okcalls;
 281     struct rx_connection *conn;
 282
 283     rcode = 0;
 284     okcalls = 0;
 285     for (ts = ubik_servers; ts; ts = ts->next) {
 286         /* for each server */
 287         if (!ts->up || !ts->currentDB) {
 288             ts->currentDB = 0;  /* db is no longer current; we just missed an update */
 289             continue;           /* not up-to-date, don't bother */
 290         }
 291
 292         conn = Quorum_StartIO(atrans, ts);
 293
 294         code = DISK_Truncate(conn, &atrans->tid, file, length);
 295
 296         Quorum_EndIO(atrans, conn);
 297         conn = NULL;
 298
 299         if (code) {             /* failure */
 300             rcode = code;
 301             ts->up = 0;         /* mark as down now; beacons will no longer be sent */
 302             ts->currentDB = 0;
 303             ts->beaconSinceDown = 0;
 304             urecovery_LostServer();     /* tell recovery to try to resend dbase later */
 305         } else {                /* success */
 306             if (!ts->isClone)
 307                 okcalls++;      /* count up how many worked */
 308             if (aflags & CStampVersion) {
 309                 ts->version = atrans->dbase->version;
 310             }
 311         }
 312     }
 313     /* return 0 if we successfully contacted a quorum, otherwise return error code.  We don't have to contact ourselves (that was done locally) */
 314     if (okcalls + 1 >= ubik_quorum)
 315         return 0;
 316     else
 317         return rcode;
 318 }
 319
 320 afs_int32
 321 ContactQuorum_DISK_WriteV(struct ubik_trans *atrans, int aflags,
 322                           iovec_wrt * io_vector, iovec_buf *io_buffer)
 323 {
 324     struct ubik_server *ts;
 325     afs_int32 code;
 326     afs_int32 rcode, okcalls;
 327     struct rx_connection *conn;
 328
 329     rcode = 0;
 330     okcalls = 0;
 331     for (ts = ubik_servers; ts; ts = ts->next) {
 332         /* for each server */
 333         if (!ts->up || !ts->currentDB) {
 334             ts->currentDB = 0;  /* db is no longer current; we just missed an update */
 335             continue;           /* not up-to-date, don't bother */
 336         }
 337
 338         conn = Quorum_StartIO(atrans, ts);
 339
 340         code = DISK_WriteV(conn, &atrans->tid, io_vector, io_buffer);
 341
 342         Quorum_EndIO(atrans, conn);
 343         conn = NULL;
 344
 345         if ((code <= -450) && (code > -500)) {
 346             /* An RPC interface mismatch (as defined in comerr/error_msg.c).
 347              * Un-bulk the entries and do individual DISK_Write calls
 348              * instead of DISK_WriteV.
 349              */
 350             struct ubik_iovec *iovec =
 351                 (struct ubik_iovec *)io_vector->iovec_wrt_val;
 352             char *iobuf = (char *)io_buffer->iovec_buf_val;
 353             bulkdata tcbs;
 354             afs_int32 i, offset;
 355
 356             conn = Quorum_StartIO(atrans, ts);
 357
 358             for (i = 0, offset = 0; i < io_vector->iovec_wrt_len; i++) {
 359                 /* Sanity check for going off end of buffer */
 360                 if ((offset + iovec[i].length) > io_buffer->iovec_buf_len) {
 361                     code = UINTERNAL;
 362                     break;
 363                 }
 364                 tcbs.bulkdata_len = iovec[i].length;
 365                 tcbs.bulkdata_val = &iobuf[offset];
 366
 367                 code =
 368                     DISK_Write(conn, &atrans->tid, iovec[i].file,
 369                                iovec[i].position, &tcbs);
 370                 if (code)
 371                     break;
 372
 373                 offset += iovec[i].length;
 374             }
 375
 376             Quorum_EndIO(atrans, conn);
 377             conn = NULL;
 378         }
 379
 380         if (code) {             /* failure */
 381             rcode = code;
 382             ts->up = 0;         /* mark as down now; beacons will no longer be sent */
 383             ts->currentDB = 0;
 384             ts->beaconSinceDown = 0;
 385             urecovery_LostServer();     /* tell recovery to try to resend dbase later */
 386         } else {                /* success */
 387             if (!ts->isClone)
 388                 okcalls++;      /* count up how many worked */
 389             if (aflags & CStampVersion) {
 390                 ts->version = atrans->dbase->version;
 391             }
 392         }
 393     }
 394     /* return 0 if we successfully contacted a quorum, otherwise return error code.  We don't have to contact ourselves (that was done locally) */
 395     if (okcalls + 1 >= ubik_quorum)
 396         return 0;
 397     else
 398         return rcode;
 399 }
 400
 401 afs_int32
 402 ContactQuorum_DISK_SetVersion(struct ubik_trans *atrans, int aflags,
 403                               ubik_version *OldVersion,
 404                               ubik_version *NewVersion)
 405 {
 406     struct ubik_server *ts;
 407     afs_int32 code;
 408     afs_int32 rcode, okcalls;
 409     struct rx_connection *conn;
 410
 411     rcode = 0;
 412     okcalls = 0;
 413     for (ts = ubik_servers; ts; ts = ts->next) {
 414         /* for each server */
 415         if (!ts->up || !ts->currentDB) {
 416             ts->currentDB = 0;  /* db is no longer current; we just missed an update */
 417             continue;           /* not up-to-date, don't bother */
 418         }
 419
 420         conn = Quorum_StartIO(atrans, ts);
 421
 422         code = DISK_SetVersion(conn, &atrans->tid, OldVersion, NewVersion);
 423
 424         Quorum_EndIO(atrans, conn);
 425         conn = NULL;
 426
 427         if (code) {             /* failure */
 428             rcode = code;
 429             ts->up = 0;         /* mark as down now; beacons will no longer be sent */
 430             ts->currentDB = 0;
 431             ts->beaconSinceDown = 0;
 432             urecovery_LostServer();     /* tell recovery to try to resend dbase later */
 433         } else {                /* success */
 434             if (!ts->isClone)
 435                 okcalls++;      /* count up how many worked */
 436             if (aflags & CStampVersion) {
 437                 ts->version = atrans->dbase->version;
 438             }
 439         }
 440     }
 441     /* return 0 if we successfully contacted a quorum, otherwise return error code.  We don't have to contact ourselves (that was done locally) */
 442     if (okcalls + 1 >= ubik_quorum)
 443         return 0;
 444     else
 445         return rcode;
 446 }
 447
 448 /*!
 449  * \brief This routine initializes the ubik system for a set of servers.
 450  * \return 0 for success, or an error code on failure.
 451  * \param serverList set of servers specified; nServers gives the number of entries in this array.
 452  * \param pathName provides an initial prefix used for naming storage files used by this system.
 453  * \param dbase the returned structure representing this instance of an ubik; it is passed to various calls below.
 454  *
 455  * \todo This routine should perhaps be generalized to a low-level disk interface providing read, write, file enumeration and sync operations.
 456  *
 457  * \warning The host named by myHost should not also be listed in serverList.
 458  *
 459  * \see ubik_ServerInit(), ubik_ServerInitByInfo()
 460  */
 461 int
 462 ubik_ServerInitCommon(afs_uint32 myHost, short myPort,
 463                       struct afsconf_cell *info, char clones[],
 464                       afs_uint32 serverList[], const char *pathName,
 465                       struct ubik_dbase **dbase)
 466 {
 467     struct ubik_dbase *tdb;
 468     afs_int32 code;
 469 #ifdef AFS_PTHREAD_ENV
 470     pthread_t rxServerThread;        /* pthread variables */
 471     pthread_t ubeacon_InteractThread;
 472     pthread_t urecovery_InteractThread;
 473     pthread_attr_t rxServer_tattr;
 474     pthread_attr_t ubeacon_Interact_tattr;
 475     pthread_attr_t urecovery_Interact_tattr;
 476 #else
 477     PROCESS junk;
 478     extern int rx_stackSize;
 479 #endif
 480
 481     afs_int32 secIndex;
 482     struct rx_securityClass *secClass;
 483
 484     struct rx_service *tservice;
 485
 486     initialize_U_error_table();
 487
 488     tdb = (struct ubik_dbase *)malloc(sizeof(struct ubik_dbase));
 489     tdb->pathName = (char *)malloc(strlen(pathName) + 1);
 490     strcpy(tdb->pathName, pathName);
 491     tdb->activeTrans = (struct ubik_trans *)0;
 492     memset(&tdb->version, 0, sizeof(struct ubik_version));
 493     memset(&tdb->cachedVersion, 0, sizeof(struct ubik_version));
 494 #ifdef AFS_PTHREAD_ENV
 495     MUTEX_INIT(&tdb->versionLock, "version lock", MUTEX_DEFAULT, 0);
 496 #else
 497     Lock_Init(&tdb->versionLock);
 498 #endif
 499     Lock_Init(&tdb->cache_lock);
 500     tdb->flags = 0;
 501     tdb->read = uphys_read;
 502     tdb->write = uphys_write;
 503     tdb->truncate = uphys_truncate;
 504     tdb->open = uphys_invalidate;       /* this function isn't used any more */
 505     tdb->sync = uphys_sync;
 506     tdb->stat = uphys_stat;
 507     tdb->getlabel = uphys_getlabel;
 508     tdb->setlabel = uphys_setlabel;
 509     tdb->getnfiles = uphys_getnfiles;
 510     tdb->readers = 0;
 511     tdb->tidCounter = tdb->writeTidCounter = 0;
 512     *dbase = tdb;
 513     ubik_dbase = tdb;           /* for now, only one db per server; can fix later when we have names for the other dbases */
 514
 515 #ifdef AFS_PTHREAD_ENV
 516     CV_INIT(&tdb->version_cond, "version", CV_DEFAULT, 0);
 517     CV_INIT(&tdb->flags_cond, "flags", CV_DEFAULT, 0);
 518 #endif /* AFS_PTHREAD_ENV */
 519
 520     /* initialize RX */
 521
 522     /* the following call is idempotent so when/if it got called earlier,
 523      * by whatever called us, it doesn't really matter -- klm */
 524     code = rx_Init(myPort);
 525     if (code < 0)
 526         return code;
 527
 528     ubik_callPortal = myPort;
 529     /* try to get an additional security object */
 530     ubik_sc[0] = rxnull_NewServerSecurityObject();
 531     ubik_sc[1] = 0;
 532     ubik_sc[2] = 0;
 533     if (ubik_SRXSecurityProc) {
 534         code =
 535             (*ubik_SRXSecurityProc) (ubik_SRXSecurityRock, &secClass,
 536                                      &secIndex);
 537         if (code == 0) {
 538             ubik_sc[secIndex] = secClass;
 539         }
 540     }
 541     /* for backwards compat this should keep working as it does now
 542        and not host bind */
 543 #if 0
 544     /* This really needs to be up above, where I have put it.  It works
 545      * here when we're non-pthreaded, but the code above, when using
 546      * pthreads may (and almost certainly does) end up calling on a
 547      * pthread resource which gets initialized by rx_Init.  The end
 548      * result is that an assert fails and the program dies. -- klm
 549      */
 550     code = rx_Init(myPort);
 551     if (code < 0)
 552         return code;
 553 #endif
 554
 555     tservice =
 556         rx_NewService(0, VOTE_SERVICE_ID, "VOTE", ubik_sc, 3,
 557                       VOTE_ExecuteRequest);
 558     if (tservice == (struct rx_service *)0) {
 559         ubik_dprint("Could not create VOTE rx service!\n");
 560         return -1;
 561     }
 562     rx_SetMinProcs(tservice, 2);
 563     rx_SetMaxProcs(tservice, 3);
 564
 565     tservice =
 566         rx_NewService(0, DISK_SERVICE_ID, "DISK", ubik_sc, 3,
 567                       DISK_ExecuteRequest);
 568     if (tservice == (struct rx_service *)0) {
 569         ubik_dprint("Could not create DISK rx service!\n");
 570         return -1;
 571     }
 572     rx_SetMinProcs(tservice, 2);
 573     rx_SetMaxProcs(tservice, 3);
 574
 575     /* start an rx_ServerProc to handle incoming RPC's in particular the
 576      * UpdateInterfaceAddr RPC that occurs in ubeacon_InitServerList. This avoids
 577      * the "steplock" problem in ubik initialization. Defect 11037.
 578      */
 579 #ifdef AFS_PTHREAD_ENV
 580 /* do assert stuff */
 581     osi_Assert(pthread_attr_init(&rxServer_tattr) == 0);
 582     osi_Assert(pthread_attr_setdetachstate(&rxServer_tattr, PTHREAD_CREATE_DETACHED) == 0);
 583 /*    osi_Assert(pthread_attr_setstacksize(&rxServer_tattr, rx_stackSize) == 0); */
 584
 585     osi_Assert(pthread_create(&rxServerThread, &rxServer_tattr, (void *)rx_ServerProc, NULL) == 0);
 586 #else
 587     LWP_CreateProcess(rx_ServerProc, rx_stackSize, RX_PROCESS_PRIORITY,
 588               NULL, "rx_ServerProc", &junk);
 589 #endif
 590
 591     /* do basic initialization */
 592     code = uvote_Init();
 593     if (code)
 594         return code;
 595     code = urecovery_Initialize(tdb);
 596     if (code)
 597         return code;
 598     if (info)
 599         code = ubeacon_InitServerListByInfo(myHost, info, clones);
 600     else
 601         code = ubeacon_InitServerList(myHost, serverList);
 602     if (code)
 603         return code;
 604
 605     /* now start up async processes */
 606 #ifdef AFS_PTHREAD_ENV
 607 /* do assert stuff */
 608     osi_Assert(pthread_attr_init(&ubeacon_Interact_tattr) == 0);
 609     osi_Assert(pthread_attr_setdetachstate(&ubeacon_Interact_tattr, PTHREAD_CREATE_DETACHED) == 0);
 610 /*    osi_Assert(pthread_attr_setstacksize(&ubeacon_Interact_tattr, 16384) == 0); */
 611     /*  need another attr set here for priority???  - klm */
 612
 613     osi_Assert(pthread_create(&ubeacon_InteractThread, &ubeacon_Interact_tattr,
 614            (void *)ubeacon_Interact, NULL) == 0);
 615 #else
 616     code = LWP_CreateProcess(ubeacon_Interact, 16384 /*8192 */ ,
 617                              LWP_MAX_PRIORITY - 1, (void *)0, "beacon",
 618                              &junk);
 619     if (code)
 620         return code;
 621 #endif
 622
 623 #ifdef AFS_PTHREAD_ENV
 624 /* do assert stuff */
 625     osi_Assert(pthread_attr_init(&urecovery_Interact_tattr) == 0);
 626     osi_Assert(pthread_attr_setdetachstate(&urecovery_Interact_tattr, PTHREAD_CREATE_DETACHED) == 0);
 627 /*    osi_Assert(pthread_attr_setstacksize(&urecovery_Interact_tattr, 16384) == 0); */
 628     /*  need another attr set here for priority???  - klm */
 629
 630     osi_Assert(pthread_create(&urecovery_InteractThread, &urecovery_Interact_tattr,
 631            (void *)urecovery_Interact, NULL) == 0);
 632
 633     return 0;  /* is this correct?  - klm */
 634 #else
 635     code = LWP_CreateProcess(urecovery_Interact, 16384 /*8192 */ ,
 636                              LWP_MAX_PRIORITY - 1, (void *)0, "recovery",
 637                              &junk);
 638     return code;
 639 #endif
 640
 641 }
 642
 643 /*!
 644  * \see ubik_ServerInitCommon()
 645  */
 646 int
 647 ubik_ServerInitByInfo(afs_uint32 myHost, short myPort,
 648                       struct afsconf_cell *info, char clones[],
 649                       const char *pathName, struct ubik_dbase **dbase)
 650 {
 651     afs_int32 code;
 652
 653     code =
 654         ubik_ServerInitCommon(myHost, myPort, info, clones, 0, pathName,
 655                               dbase);
 656     return code;
 657 }
 658
 659 /*!
 660  * \see ubik_ServerInitCommon()
 661  */
 662 int
 663 ubik_ServerInit(afs_uint32 myHost, short myPort, afs_uint32 serverList[],
 664                 const char *pathName, struct ubik_dbase **dbase)
 665 {
 666     afs_int32 code;
 667
 668     code =
 669         ubik_ServerInitCommon(myHost, myPort, (struct afsconf_cell *)0, 0,
 670                               serverList, pathName, dbase);
 671     return code;
 672 }
 673
 674 /*!
 675  * \brief This routine begins a read or write transaction on the transaction
 676  * identified by transPtr, in the dbase named by dbase.
 677  *
 678  * An open mode of ubik_READTRANS identifies this as a read transaction,
 679  * while a mode of ubik_WRITETRANS identifies this as a write transaction.
 680  * transPtr is set to the returned transaction control block.
 681  * The readAny flag is set to 0 or 1 or 2 by the wrapper functions
 682  * ubik_BeginTrans() or ubik_BeginTransReadAny() or
 683  * ubik_BeginTransReadAnyWrite() below.
 684  *
 685  * \note We can only begin transaction when we have an up-to-date database.
 686  */
 687 static int
 688 BeginTrans(struct ubik_dbase *dbase, afs_int32 transMode,
 689            struct ubik_trans **transPtr, int readAny)
 690 {
 691     struct ubik_trans *jt;
 692     struct ubik_trans *tt;
 693     afs_int32 code;
 694 #if defined(UBIK_PAUSE)
 695     int count;
 696 #endif /* UBIK_PAUSE */
 697
 698     if (readAny > 1 && ubik_SyncWriterCacheProc == NULL) {
 699         /* it's not safe to use ubik_BeginTransReadAnyWrite without a
 700          * cache-syncing function; fall back to ubik_BeginTransReadAny,
 701          * which is safe but slower */
 702         ubik_print("ubik_BeginTransReadAnyWrite called, but "
 703                    "ubik_SyncWriterCacheProc not set; pretending "
 704                    "ubik_BeginTransReadAny was called instead\n");
 705         readAny = 1;
 706     }
 707
 708     if ((transMode != UBIK_READTRANS) && readAny)
 709         return UBADTYPE;
 710     DBHOLD(dbase);
 711 #if defined(UBIK_PAUSE)
 712     /* if we're polling the slave sites, wait until the returns
 713      *  are all in.  Otherwise, the urecovery_CheckTid call may
 714      *  glitch us.
 715      */
 716     if (transMode == UBIK_WRITETRANS)
 717         for (count = 75; dbase->flags & DBVOTING; --count) {
 718             DBRELE(dbase);
 719 #ifdef GRAND_PAUSE_DEBUGGING
 720             if (count == 75)
 721                 fprintf(stderr,
 722                         "%ld: myport=%d: BeginTrans is waiting 'cause of voting conflict\n",
 723                         time(0), ntohs(ubik_callPortal));
 724             else
 725 #endif
 726             if (count <= 0) {
 727 #if 1
 728                 fprintf(stderr,
 729                         "%ld: myport=%d: BeginTrans failed because of voting conflict\n",
 730                         time(0), ntohs(ubik_callPortal));
 731 #endif
 732                 return UNOQUORUM;       /* a white lie */
 733             }
 734 #ifdef AFS_PTHREAD_ENV
 735             sleep(2);
 736 #else
 737             IOMGR_Sleep(2);
 738 #endif
 739             DBHOLD(dbase);
 740         }
 741 #endif /* UBIK_PAUSE */
 742     if (urecovery_AllBetter(dbase, readAny) == 0) {
 743         DBRELE(dbase);
 744         return UNOQUORUM;
 745     }
 746     /* otherwise we have a quorum, use it */
 747
 748     /* make sure that at most one write transaction occurs at any one time.  This
 749      * has nothing to do with transaction locking; that's enforced by the lock package.  However,
 750      * we can't even handle two non-conflicting writes, since our log and recovery modules
 751      * don't know how to restore one without possibly picking up some data from the other. */
 752     if (transMode == UBIK_WRITETRANS) {
 753         /* if we're writing already, wait */
 754         while (dbase->flags & DBWRITING) {
 755 #ifdef AFS_PTHREAD_ENV
 756             CV_WAIT(&dbase->flags_cond, &dbase->versionLock);
 757 #else
 758             DBRELE(dbase);
 759             LWP_WaitProcess(&dbase->flags);
 760             DBHOLD(dbase);
 761 #endif
 762         }
 763
 764         if (!ubeacon_AmSyncSite()) {
 765             DBRELE(dbase);
 766             return UNOTSYNC;
 767         }
 768     }
 769
 770     /* create the transaction */
 771     code = udisk_begin(dbase, transMode, &jt);  /* can't take address of register var */
 772     tt = jt;                    /* move to a register */
 773     if (code || tt == (struct ubik_trans *)NULL) {
 774         DBRELE(dbase);
 775         return code;
 776     }
 777     if (readAny) {
 778         tt->flags |= TRREADANY;
 779         if (readAny > 1) {
 780             tt->flags |= TRREADWRITE;
 781         }
 782     }
 783     /* label trans and dbase with new tid */
 784     tt->tid.epoch = ubik_epochTime;
 785     /* bump by two, since tidCounter+1 means trans id'd by tidCounter has finished */
 786     tt->tid.counter = (dbase->tidCounter += 2);
 787
 788     if (transMode == UBIK_WRITETRANS) {
 789         /* for a write trans, we have to keep track of the write tid counter too */
 790         dbase->writeTidCounter = tt->tid.counter;
 791
 792         /* next try to start transaction on appropriate number of machines */
 793         code = ContactQuorum_NoArguments(DISK_Begin, tt, 0);
 794         if (code) {
 795             /* we must abort the operation */
 796             udisk_abort(tt);
 797             ContactQuorum_NoArguments(DISK_Abort, tt, 0); /* force aborts to the others */
 798             udisk_end(tt);
 799             DBRELE(dbase);
 800             return code;
 801         }
 802     }
 803
 804     *transPtr = tt;
 805     DBRELE(dbase);
 806     return 0;
 807 }
 808
 809 /*!
 810  * \see BeginTrans()
 811  */
 812 int
 813 ubik_BeginTrans(struct ubik_dbase *dbase, afs_int32 transMode,
 814                 struct ubik_trans **transPtr)
 815 {
 816     return BeginTrans(dbase, transMode, transPtr, 0);
 817 }
 818
 819 /*!
 820  * \see BeginTrans()
 821  */
 822 int
 823 ubik_BeginTransReadAny(struct ubik_dbase *dbase, afs_int32 transMode,
 824                        struct ubik_trans **transPtr)
 825 {
 826     return BeginTrans(dbase, transMode, transPtr, 1);
 827 }
 828
 829 /*!
 830  * \see BeginTrans()
 831  */
 832 int
 833 ubik_BeginTransReadAnyWrite(struct ubik_dbase *dbase, afs_int32 transMode,
 834                             struct ubik_trans **transPtr)
 835 {
 836     return BeginTrans(dbase, transMode, transPtr, 2);
 837 }
 838
 839 /*!
 840  * \brief This routine ends a read or write transaction by aborting it.
 841  */
 842 int
 843 ubik_AbortTrans(struct ubik_trans *transPtr)
 844 {
 845     afs_int32 code;
 846     afs_int32 code2;
 847     struct ubik_dbase *dbase;
 848
 849     dbase = transPtr->dbase;
 850
 851     if (transPtr->flags & TRCACHELOCKED) {
 852         ReleaseReadLock(&dbase->cache_lock);
 853         transPtr->flags &= ~TRCACHELOCKED;
 854     }
 855
 856     ObtainWriteLock(&dbase->cache_lock);
 857
 858     DBHOLD(dbase);
 859     memset(&dbase->cachedVersion, 0, sizeof(struct ubik_version));
 860
 861     ReleaseWriteLock(&dbase->cache_lock);
 862
 863     /* see if we're still up-to-date */
 864     if (!urecovery_AllBetter(dbase, transPtr->flags & TRREADANY)) {
 865         udisk_abort(transPtr);
 866         udisk_end(transPtr);
 867         DBRELE(dbase);
 868         return UNOQUORUM;
 869     }
 870
 871     if (transPtr->type == UBIK_READTRANS) {
 872         code = udisk_abort(transPtr);
 873         udisk_end(transPtr);
 874         DBRELE(dbase);
 875         return code;
 876     }
 877
 878     /* below here, we know we're doing a write transaction */
 879     if (!ubeacon_AmSyncSite()) {
 880         udisk_abort(transPtr);
 881         udisk_end(transPtr);
 882         DBRELE(dbase);
 883         return UNOTSYNC;
 884     }
 885
 886     /* now it is safe to try remote abort */
 887     code = ContactQuorum_NoArguments(DISK_Abort, transPtr, 0);
 888     code2 = udisk_abort(transPtr);
 889     udisk_end(transPtr);
 890     DBRELE(dbase);
 891     return (code ? code : code2);
 892 }
 893
 894 static void
 895 WritebackApplicationCache(struct ubik_dbase *dbase)
 896 {
 897     int code = 0;
 898     if (ubik_SyncWriterCacheProc) {
 899         code = ubik_SyncWriterCacheProc();
 900     }
 901     if (code) {
 902         /* we failed to sync the local cache, so just invalidate the cache;
 903          * we'll try to read the cache in again on the next read */
 904         memset(&dbase->cachedVersion, 0, sizeof(dbase->cachedVersion));
 905     } else {
 906         memcpy(&dbase->cachedVersion, &dbase->version,
 907                sizeof(dbase->cachedVersion));
 908     }
 909 }
 910
 911 /*!
 912  * \brief This routine ends a read or write transaction on the open transaction identified by transPtr.
 913  * \return an error code.
 914  */
 915 int
 916 ubik_EndTrans(struct ubik_trans *transPtr)
 917 {
 918     afs_int32 code;
 919     struct timeval tv;
 920     afs_int32 realStart;
 921     struct ubik_server *ts;
 922     afs_int32 now;
 923     int cachelocked = 0;
 924     struct ubik_dbase *dbase;
 925
 926     if (transPtr->type == UBIK_WRITETRANS) {
 927         code = ubik_Flush(transPtr);
 928         if (code) {
 929             ubik_AbortTrans(transPtr);
 930             return (code);
 931         }
 932     }
 933
 934     dbase = transPtr->dbase;
 935
 936     if (transPtr->flags & TRCACHELOCKED) {
 937         ReleaseReadLock(&dbase->cache_lock);
 938         transPtr->flags &= ~TRCACHELOCKED;
 939     }
 940
 941     if (transPtr->type != UBIK_READTRANS) {
 942         /* must hold cache_lock before DBHOLD'ing */
 943         ObtainWriteLock(&dbase->cache_lock);
 944         cachelocked = 1;
 945     }
 946
 947     DBHOLD(dbase);
 948
 949     /* give up if no longer current */
 950     if (!urecovery_AllBetter(dbase, transPtr->flags & TRREADANY)) {
 951         udisk_abort(transPtr);
 952         udisk_end(transPtr);
 953         DBRELE(dbase);
 954         code = UNOQUORUM;
 955         goto error;
 956     }
 957
 958     if (transPtr->type == UBIK_READTRANS) {     /* reads are easy */
 959         code = udisk_commit(transPtr);
 960         if (code == 0)
 961             goto success;       /* update cachedVersion correctly */
 962         udisk_end(transPtr);
 963         DBRELE(dbase);
 964         goto error;
 965     }
 966
 967     if (!ubeacon_AmSyncSite()) {        /* no longer sync site */
 968         udisk_abort(transPtr);
 969         udisk_end(transPtr);
 970         DBRELE(dbase);
 971         code = UNOTSYNC;
 972         goto error;
 973     }
 974
 975     /* now it is safe to do commit */
 976     code = udisk_commit(transPtr);
 977     if (code == 0) {
 978         /* db data has been committed locally; update the local cache so
 979          * readers can get at it */
 980         WritebackApplicationCache(dbase);
 981
 982         ReleaseWriteLock(&dbase->cache_lock);
 983
 984         code = ContactQuorum_NoArguments(DISK_Commit, transPtr, CStampVersion);
 985
 986     } else {
 987         memset(&dbase->cachedVersion, 0, sizeof(struct ubik_version));
 988         ReleaseWriteLock(&dbase->cache_lock);
 989     }
 990     cachelocked = 0;
 991     if (code) {
 992         /* failed to commit, so must return failure.  Try to clear locks first, just for fun
 993          * Note that we don't know if this transaction will eventually commit at this point.
 994          * If it made it to a site that will be present in the next quorum, we win, otherwise
 995          * we lose.  If we contact a majority of sites, then we won't be here: contacting
 996          * a majority guarantees commit, since it guarantees that one dude will be a
 997          * member of the next quorum. */
 998         ContactQuorum_NoArguments(DISK_ReleaseLocks, transPtr, 0);
 999         udisk_end(transPtr);
1000         DBRELE(dbase);
1001         goto error;
1002     }
1003     /* before we can start sending unlock messages, we must wait until all servers
1004      * that are possibly still functioning on the other side of a network partition
1005      * have timed out.  Check the server structures, compute how long to wait, then
1006      * start the unlocks */
1007     realStart = FT_ApproxTime();
1008     while (1) {
1009         /* wait for all servers to time out */
1010         code = 0;
1011         now = FT_ApproxTime();
1012         /* check if we're still sync site, the guy should either come up
1013          * to us, or timeout.  Put safety check in anyway */
1014         if (now - realStart > 10 * BIGTIME) {
1015             ubik_stats.escapes++;
1016             ubik_print("ubik escaping from commit wait\n");
1017             break;
1018         }
1019         for (ts = ubik_servers; ts; ts = ts->next) {
1020             if (!ts->beaconSinceDown && now <= ts->lastBeaconSent + BIGTIME) {
1021
1022                 /* this guy could have some damaged data, wait for him */
1023                 code = 1;
1024                 tv.tv_sec = 1;  /* try again after a while (ha ha) */
1025                 tv.tv_usec = 0;
1026
1027 #ifdef AFS_PTHREAD_ENV
1028                 /* we could release the dbase outside of the loop, but we do
1029                  * it here, in the loop, to avoid an unnecessary RELE/HOLD
1030                  * if all sites are up */
1031                 DBRELE(dbase);
1032                 select(0, 0, 0, 0, &tv);
1033                 DBHOLD(dbase);
1034 #else
1035                 IOMGR_Select(0, 0, 0, 0, &tv);  /* poll, should we wait on something? */
1036 #endif
1037
1038                 break;
1039             }
1040         }
1041         if (code == 0)
1042             break;              /* no down ones still pseudo-active */
1043     }
1044
1045     /* finally, unlock all the dudes.  We can return success independent of the number of servers
1046      * that really unlock the dbase; the others will do it if/when they elect a new sync site.
1047      * The transaction is committed anyway, since we succeeded in contacting a quorum
1048      * at the start (when invoking the DiskCommit function).
1049      */
1050     ContactQuorum_NoArguments(DISK_ReleaseLocks, transPtr, 0);
1051
1052   success:
1053     udisk_end(transPtr);
1054     /* don't update cachedVersion here; it should have been updated way back
1055      * in ubik_CheckCache, and earlier in this function for writes */
1056     DBRELE(dbase);
1057     if (cachelocked) {
1058         ReleaseWriteLock(&dbase->cache_lock);
1059     }
1060     return 0;
1061
1062   error:
1063     if (!cachelocked) {
1064         ObtainWriteLock(&dbase->cache_lock);
1065     }
1066     memset(&dbase->cachedVersion, 0, sizeof(struct ubik_version));
1067     ReleaseWriteLock(&dbase->cache_lock);
1068     return code;
1069 }
1070
1071 /*!
1072  * \brief This routine reads length bytes into buffer from the current position in the database.
1073  *
1074  * The file pointer is updated appropriately (by adding the number of bytes actually transferred), and the length actually transferred is stored in the long integer pointed to by length.  A short read returns zero for an error code.
1075  *
1076  * \note *length is an INOUT parameter: at the start it represents the size of the buffer, and when done, it contains the number of bytes actually transferred.
1077  */
1078 int
1079 ubik_Read(struct ubik_trans *transPtr, void *buffer,
1080           afs_int32 length)
1081 {
1082     afs_int32 code;
1083
1084     /* reads are easy to do: handle locally */
1085     DBHOLD(transPtr->dbase);
1086     if (!urecovery_AllBetter(transPtr->dbase, transPtr->flags & TRREADANY)) {
1087         DBRELE(transPtr->dbase);
1088         return UNOQUORUM;
1089     }
1090
1091     code =
1092         udisk_read(transPtr, transPtr->seekFile, buffer, transPtr->seekPos,
1093                    length);
1094     if (code == 0) {
1095         transPtr->seekPos += length;
1096     }
1097     DBRELE(transPtr->dbase);
1098     return code;
1099 }
1100
1101 /*!
1102  * \brief This routine will flush the io data in the iovec structures.
1103  *
1104  * It first flushes to the local disk and then uses ContactQuorum to write it
1105  * to the other servers.
1106  */
1107 int
1108 ubik_Flush(struct ubik_trans *transPtr)
1109 {
1110     afs_int32 code, error = 0;
1111
1112     if (transPtr->type != UBIK_WRITETRANS)
1113         return UBADTYPE;
1114     if (!transPtr->iovec_info.iovec_wrt_len
1115         || !transPtr->iovec_info.iovec_wrt_val)
1116         return 0;
1117
1118     DBHOLD(transPtr->dbase);
1119     if (!urecovery_AllBetter(transPtr->dbase, transPtr->flags & TRREADANY))
1120         ERROR_EXIT(UNOQUORUM);
1121     if (!ubeacon_AmSyncSite())  /* only sync site can write */
1122         ERROR_EXIT(UNOTSYNC);
1123
1124     /* Update the rest of the servers in the quorum */
1125     code =
1126         ContactQuorum_DISK_WriteV(transPtr, 0, &transPtr->iovec_info,
1127                                   &transPtr->iovec_data);
1128     if (code) {
1129         udisk_abort(transPtr);
1130         ContactQuorum_NoArguments(DISK_Abort, transPtr, 0); /* force aborts to the others */
1131         transPtr->iovec_info.iovec_wrt_len = 0;
1132         transPtr->iovec_data.iovec_buf_len = 0;
1133         ERROR_EXIT(code);
1134     }
1135
1136     /* Wrote the buffers out, so start at scratch again */
1137     transPtr->iovec_info.iovec_wrt_len = 0;
1138     transPtr->iovec_data.iovec_buf_len = 0;
1139
1140   error_exit:
1141     DBRELE(transPtr->dbase);
1142     return error;
1143 }
1144
1145 int
1146 ubik_Write(struct ubik_trans *transPtr, void *vbuffer,
1147            afs_int32 length)
1148 {
1149     struct ubik_iovec *iovec;
1150     afs_int32 code, error = 0;
1151     afs_int32 pos, len, size;
1152     char * buffer = (char *)vbuffer;
1153
1154     if (transPtr->type != UBIK_WRITETRANS)
1155         return UBADTYPE;
1156     if (!length)
1157         return 0;
1158
1159     if (length > IOVEC_MAXBUF) {
1160         for (pos = 0, len = length; len > 0; len -= size, pos += size) {
1161             size = ((len < IOVEC_MAXBUF) ? len : IOVEC_MAXBUF);
1162             code = ubik_Write(transPtr, buffer+pos, size);
1163             if (code)
1164                 return (code);
1165         }
1166         return 0;
1167     }
1168
1169     if (!transPtr->iovec_info.iovec_wrt_val) {
1170         transPtr->iovec_info.iovec_wrt_len = 0;
1171         transPtr->iovec_info.iovec_wrt_val =
1172             (struct ubik_iovec *)malloc(IOVEC_MAXWRT *
1173                                         sizeof(struct ubik_iovec));
1174         transPtr->iovec_data.iovec_buf_len = 0;
1175         transPtr->iovec_data.iovec_buf_val = (char *)malloc(IOVEC_MAXBUF);
1176         if (!transPtr->iovec_info.iovec_wrt_val
1177             || !transPtr->iovec_data.iovec_buf_val) {
1178             if (transPtr->iovec_info.iovec_wrt_val)
1179                 free(transPtr->iovec_info.iovec_wrt_val);
1180             transPtr->iovec_info.iovec_wrt_val = 0;
1181             if (transPtr->iovec_data.iovec_buf_val)
1182                 free(transPtr->iovec_data.iovec_buf_val);
1183             transPtr->iovec_data.iovec_buf_val = 0;
1184             return UNOMEM;
1185         }
1186     }
1187
1188     /* If this write won't fit in the structure, then flush it out and start anew */
1189     if ((transPtr->iovec_info.iovec_wrt_len >= IOVEC_MAXWRT)
1190         || ((length + transPtr->iovec_data.iovec_buf_len) > IOVEC_MAXBUF)) {
1191         code = ubik_Flush(transPtr);
1192         if (code)
1193             return (code);
1194     }
1195
1196     DBHOLD(transPtr->dbase);
1197     if (!urecovery_AllBetter(transPtr->dbase, transPtr->flags & TRREADANY))
1198         ERROR_EXIT(UNOQUORUM);
1199     if (!ubeacon_AmSyncSite())  /* only sync site can write */
1200         ERROR_EXIT(UNOTSYNC);
1201
1202     /* Write to the local disk */
1203     code =
1204         udisk_write(transPtr, transPtr->seekFile, buffer, transPtr->seekPos,
1205                     length);
1206     if (code) {
1207         udisk_abort(transPtr);
1208         transPtr->iovec_info.iovec_wrt_len = 0;
1209         transPtr->iovec_data.iovec_buf_len = 0;
1210         DBRELE(transPtr->dbase);
1211         return (code);
1212     }
1213
1214     /* Collect writes for the other ubik servers (to be done in bulk) */
1215     iovec = (struct ubik_iovec *)transPtr->iovec_info.iovec_wrt_val;
1216     iovec[transPtr->iovec_info.iovec_wrt_len].file = transPtr->seekFile;
1217     iovec[transPtr->iovec_info.iovec_wrt_len].position = transPtr->seekPos;
1218     iovec[transPtr->iovec_info.iovec_wrt_len].length = length;
1219
1220     memcpy(&transPtr->iovec_data.
1221            iovec_buf_val[transPtr->iovec_data.iovec_buf_len], buffer, length);
1222
1223     transPtr->iovec_info.iovec_wrt_len++;
1224     transPtr->iovec_data.iovec_buf_len += length;
1225     transPtr->seekPos += length;
1226
1227   error_exit:
1228     DBRELE(transPtr->dbase);
1229     return error;
1230 }
1231
1232 /*!
1233  * \brief This sets the file pointer associated with the current transaction
1234  * to the appropriate file and byte position.
1235  *
1236  * Unlike Unix files, a transaction is labelled by both a file number \p fileid
1237  * and a byte position relative to the specified file \p position.
1238  */
1239 int
1240 ubik_Seek(struct ubik_trans *transPtr, afs_int32 fileid,
1241           afs_int32 position)
1242 {
1243     afs_int32 code;
1244
1245     DBHOLD(transPtr->dbase);
1246     if (!urecovery_AllBetter(transPtr->dbase, transPtr->flags & TRREADANY)) {
1247         code = UNOQUORUM;
1248     } else {
1249         transPtr->seekFile = fileid;
1250         transPtr->seekPos = position;
1251         code = 0;
1252     }
1253     DBRELE(transPtr->dbase);
1254     return code;
1255 }
1256
1257 /*!
1258  * \brief This call returns the file pointer associated with the specified
1259  * transaction in \p fileid and \p position.
1260  */
1261 int
1262 ubik_Tell(struct ubik_trans *transPtr, afs_int32 * fileid,
1263           afs_int32 * position)
1264 {
1265     DBHOLD(transPtr->dbase);
1266     *fileid = transPtr->seekFile;
1267     *position = transPtr->seekPos;
1268     DBRELE(transPtr->dbase);
1269     return 0;
1270 }
1271
1272 /*!
1273  * \brief This sets the file size for the currently-selected file to \p length
1274  * bytes, if length is less than the file's current size.
1275  */
1276 int
1277 ubik_Truncate(struct ubik_trans *transPtr, afs_int32 length)
1278 {
1279     afs_int32 code, error = 0;
1280
1281     /* Will also catch if not UBIK_WRITETRANS */
1282     code = ubik_Flush(transPtr);
1283     if (code)
1284         return (code);
1285
1286     DBHOLD(transPtr->dbase);
1287     /* first, check that quorum is still good, and that dbase is up-to-date */
1288     if (!urecovery_AllBetter(transPtr->dbase, transPtr->flags & TRREADANY))
1289         ERROR_EXIT(UNOQUORUM);
1290     if (!ubeacon_AmSyncSite())
1291         ERROR_EXIT(UNOTSYNC);
1292
1293     /* now do the operation locally, and propagate it out */
1294     code = udisk_truncate(transPtr, transPtr->seekFile, length);
1295     if (!code) {
1296         code =
1297             ContactQuorum_DISK_Truncate(transPtr, 0, transPtr->seekFile,
1298                                         length);
1299     }
1300     if (code) {
1301         /* we must abort the operation */
1302         udisk_abort(transPtr);
1303         ContactQuorum_NoArguments(DISK_Abort, transPtr, 0); /* force aborts to the others */
1304         ERROR_EXIT(code);
1305     }
1306
1307   error_exit:
1308     DBRELE(transPtr->dbase);
1309     return error;
1310 }
1311
1312 /*!
1313  * \brief set a lock; all locks are released on transaction end (commit/abort)
1314  */
1315 int
1316 ubik_SetLock(struct ubik_trans *atrans, afs_int32 apos, afs_int32 alen,
1317              int atype)
1318 {
1319     afs_int32 code = 0, error = 0;
1320
1321     if (atype == LOCKWRITE) {
1322         if (atrans->type == UBIK_READTRANS)
1323             return UBADTYPE;
1324         code = ubik_Flush(atrans);
1325         if (code)
1326             return (code);
1327     }
1328
1329     DBHOLD(atrans->dbase);
1330     if (atype == LOCKREAD) {
1331         code = ulock_getLock(atrans, atype, 1);
1332         if (code)
1333             ERROR_EXIT(code);
1334     } else {
1335         /* first, check that quorum is still good, and that dbase is up-to-date */
1336         if (!urecovery_AllBetter(atrans->dbase, atrans->flags & TRREADANY))
1337             ERROR_EXIT(UNOQUORUM);
1338         if (!ubeacon_AmSyncSite())
1339             ERROR_EXIT(UNOTSYNC);
1340
1341         /* now do the operation locally, and propagate it out */
1342         code = ulock_getLock(atrans, atype, 1);
1343         if (code == 0) {
1344             code = ContactQuorum_DISK_Lock(atrans, 0, 0, 1 /*unused */ ,
1345                                            1 /*unused */ , LOCKWRITE);
1346         }
1347         if (code) {
1348             /* we must abort the operation */
1349             udisk_abort(atrans);
1350             ContactQuorum_NoArguments(DISK_Abort, atrans, 0); /* force aborts to the others */
1351             ERROR_EXIT(code);
1352         }
1353     }
1354
1355   error_exit:
1356     DBRELE(atrans->dbase);
1357     return error;
1358 }
1359
1360 /*!
1361  * \brief utility to wait for a version # to change
1362  */
1363 int
1364 ubik_WaitVersion(struct ubik_dbase *adatabase,
1365                  struct ubik_version *aversion)
1366 {
1367     DBHOLD(adatabase);
1368     while (1) {
1369         /* wait until version # changes, and then return */
1370         if (vcmp(*aversion, adatabase->version) != 0) {
1371             DBRELE(adatabase);
1372             return 0;
1373         }
1374 #ifdef AFS_PTHREAD_ENV
1375         CV_WAIT(&adatabase->version_cond, &adatabase->versionLock);
1376 #else
1377         DBRELE(adatabase);
1378         LWP_WaitProcess(&adatabase->version);   /* same vers, just wait */
1379         DBHOLD(adatabase);
1380 #endif
1381     }
1382 }
1383
1384 /*!
1385  * \brief utility to get the version of the dbase a transaction is dealing with
1386  */
1387 int
1388 ubik_GetVersion(struct ubik_trans *atrans,
1389                 struct ubik_version *avers)
1390 {
1391     *avers = atrans->dbase->version;
1392     return 0;
1393 }
1394
1395 /*!
1396  * \brief Facility to simplify database caching.
1397  * \return zero if last trans was done on the local server and was successful.
1398  * \return -1 means bad (NULL) argument.
1399  *
1400  * If return value is non-zero and the caller is a server caching part of the
1401  * Ubik database, it should invalidate that cache.
1402  */
1403 static int
1404 ubik_CacheUpdate(struct ubik_trans *atrans)
1405 {
1406     if (!(atrans && atrans->dbase))
1407         return -1;
1408     return vcmp(atrans->dbase->cachedVersion, atrans->dbase->version) != 0;
1409 }
1410
1411 /**
1412  * check and possibly update cache of ubik db.
1413  *
1414  * If the version of the cached db data is out of date, this calls (*check) to
1415  * update the cache. If (*check) returns success, we update the version of the
1416  * cached db data.
1417  *
1418  * Checking the version of the cached db data is done under a read lock;
1419  * updating the cache (and thus calling (*check)) is done under a write lock
1420  * so is guaranteed not to interfere with another thread's (*check). On
1421  * successful return, a read lock on the cached db data is obtained, which
1422  * will be released by ubik_EndTrans or ubik_AbortTrans.
1423  *
1424  * @param[in] atrans ubik transaction
1425  * @param[in] check  function to call to check/update cache
1426  * @param[in] rock   rock to pass to *check
1427  *
1428  * @return operation status
1429  *   @retval 0       success
1430  *   @retval nonzero error; cachedVersion not updated
1431  *
1432  * @post On success, application cache is read-locked, and cache data is
1433  *       up-to-date
1434  */
1435 int
1436 ubik_CheckCache(struct ubik_trans *atrans, ubik_updatecache_func cbf, void *rock)
1437 {
1438     int ret = 0;
1439
1440     if (!(atrans && atrans->dbase))
1441         return -1;
1442
1443     ObtainReadLock(&atrans->dbase->cache_lock);
1444
1445     while (ubik_CacheUpdate(atrans) != 0) {
1446
1447         ReleaseReadLock(&atrans->dbase->cache_lock);
1448         ObtainSharedLock(&atrans->dbase->cache_lock);
1449
1450         if (ubik_CacheUpdate(atrans) != 0) {
1451
1452             BoostSharedLock(&atrans->dbase->cache_lock);
1453
1454             ret = (*cbf) (atrans, rock);
1455             if (ret == 0) {
1456                 memcpy(&atrans->dbase->cachedVersion, &atrans->dbase->version,
1457                        sizeof(atrans->dbase->cachedVersion));
1458             }
1459         }
1460
1461         /* It would be nice if we could convert from a shared lock to a read
1462          * lock... instead, just release the shared and acquire the read */
1463         ReleaseSharedLock(&atrans->dbase->cache_lock);
1464
1465         if (ret) {
1466             /* if we have an error, don't retry, and don't hold any locks */
1467             return ret;
1468         }
1469
1470         ObtainReadLock(&atrans->dbase->cache_lock);
1471     }
1472
1473     atrans->flags |= TRCACHELOCKED;
1474
1475     return 0;
1476 }
1477
1478 /*!
1479  * "Who said anything about panicking?" snapped Arthur.
1480  * "This is still just the culture shock. You wait till I've settled down
1481  * into the situation and found my bearings. \em Then I'll start panicking!"
1482  * --Authur Dent
1483  *
1484  * \returns There is no return from panic.
1485  */
1486 void
1487 panic(char *format, ...)
1488 {
1489     va_list ap;
1490
1491     va_start(ap, format);
1492     ubik_print("Ubik PANIC: ");
1493     ubik_vprint(format, ap);
1494     va_end(ap);
1495
1496     abort();
1497     ubik_print("BACK FROM ABORT\n");    /* shouldn't come back */
1498     exit(1);                    /* never know, though  */
1499 }
1500
1501 /*!
1502  * This function takes an IP addresses as its parameter. It returns the
1503  * the primary IP address that is on the host passed in, or 0 if not found.
1504  */
1505 afs_uint32
1506 ubikGetPrimaryInterfaceAddr(afs_uint32 addr)
1507 {
1508     struct ubik_server *ts;
1509     int j;
1510
1511     for (ts = ubik_servers; ts; ts = ts->next)
1512         for (j = 0; j < UBIK_MAX_INTERFACE_ADDR; j++)
1513             if (ts->addr[j] == addr)
1514                 return ts->addr[0];     /* net byte order */
1515     return 0;                   /* if not in server database, return error */
1516 }