#include <afsconfig.h>
#include <afs/param.h>
+#include <roken.h>
#include <sys/types.h>
#include <string.h>
#include <stdarg.h>
#include <errno.h>
-#include <assert.h>
#ifdef AFS_NT40_ENV
#include <winsock2.h>
#include <rx/xdr.h>
#include <rx/rx.h>
#include <afs/afsutil.h>
+#include <afs/cellconfig.h>
#define UBIK_INTERNALS
#include "ubik.h"
* \brief sync site
*
* routine called when a non-sync site server goes down; restarts recovery
- * process to send missing server the new db when it comes back up.
+ * process to send missing server the new db when it comes back up for
+ * non-sync site servers.
*
* \note This routine should not do anything with variables used by non-sync site servers.
*/
int
-urecovery_LostServer(void)
+urecovery_LostServer(struct ubik_server *ts)
{
+ ubeacon_ReinitServer(ts);
#if !defined(AFS_PTHREAD_ENV)
/* No corresponding LWP_WaitProcess found anywhere for this -- klm */
LWP_NoYieldSignal(&urecovery_state);
* \brief this routine aborts the current remote transaction, if any, if the tid is wrong
*/
int
-urecovery_CheckTid(struct ubik_tid *atid)
+urecovery_CheckTid(struct ubik_tid *atid, int abortalways)
{
if (ubik_currentTrans) {
/* there is remote write trans, see if we match, see if this
* is a new transaction */
if (atid->epoch != ubik_currentTrans->tid.epoch
- || atid->counter > ubik_currentTrans->tid.counter) {
+ || atid->counter > ubik_currentTrans->tid.counter || abortalways) {
/* don't match, abort it */
/* If the thread is not waiting for lock - ok to end it */
-#if !defined(UBIK_PAUSE)
if (ubik_currentTrans->locktype != LOCKWAIT) {
-#endif /* UBIK_PAUSE */
udisk_end(ubik_currentTrans);
-#if !defined(UBIK_PAUSE)
}
-#endif /* UBIK_PAUSE */
ubik_currentTrans = (struct ubik_trans *)0;
}
}
} else if (opcode == LOGABORT)
panic("log abort\n");
else if (opcode == LOGEND) {
+ struct ubik_version version;
tpos += 4;
code =
(*adbase->read) (adbase, LOGFILE, (char *)buffer, tpos,
2 * sizeof(afs_int32));
if (code != 2 * sizeof(afs_int32))
return UBADLOG;
- code = (*adbase->setlabel) (adbase, 0, (ubik_version *)buffer);
+ version.epoch = ntohl(buffer[0]);
+ version.counter = ntohl(buffer[1]);
+ code = (*adbase->setlabel) (adbase, 0, &version);
if (code)
return code;
+ ubik_print("Successfully replayed log for interrupted "
+ "transaction; db version is now %ld.%ld\n",
+ (long) version.epoch, (long) version.counter);
logIsGood = 1;
break; /* all done now */
} else if (opcode == LOGTRUNCATE) {
(*adbase->setlabel) (adbase, 0, &adbase->version);
}
#ifdef AFS_PTHREAD_ENV
- assert(pthread_cond_broadcast(&adbase->version_cond) == 0);
+ CV_BROADCAST(&adbase->version_cond);
#else
LWP_NoYieldSignal(&adbase->version);
#endif
struct ubik_server *bestServer = NULL;
struct ubik_server *ts;
int dbok, doingRPC, now;
- afs_int32 lastProbeTime, lastDBVCheck;
+ afs_int32 lastProbeTime;
/* if we're the sync site, the best db version we've found yet */
static struct ubik_version bestDBVersion;
struct ubik_version tversion;
struct ubik_stat ubikstat;
struct in_addr inAddr;
char hoststr[16];
-#ifndef OLD_URECOVERY
char pbuffer[1028];
- int flen, fd = -1;
+ int fd = -1;
afs_int32 pass;
-#endif
/* otherwise, begin interaction */
urecovery_state = 0;
lastProbeTime = 0;
- lastDBVCheck = 0;
while (1) {
/* Run through this loop every 4 seconds */
tv.tv_sec = 4;
*/
urecovery_state &= ~UBIK_RECHAVEDB;
}
- lastDBVCheck = FT_ApproxTime();
urecovery_state |= UBIK_RECFOUNDDB;
urecovery_state &= ~UBIK_RECSENTDB;
}
-#if defined(UBIK_PAUSE)
- /* it's not possible for UBIK_RECFOUNDDB not to be set here.
- * However, we might have lost UBIK_RECSYNCSITE, and that
- * IS important.
- */
- if (!(urecovery_state & UBIK_RECSYNCSITE))
- continue; /* lost sync */
-#else
if (!(urecovery_state & UBIK_RECFOUNDDB))
continue; /* not ready */
-#endif /* UBIK_PAUSE */
/* If we, the sync site, do not have the best db version, then
* go and get it from the server that does.
goto FetchEndCall;
}
-#ifdef OLD_URECOVERY
- /* Truncate the file first */
- code = (*ubik_dbase->truncate) (ubik_dbase, file, 0);
- if (code) {
- ubik_dprint("truncate io error=%d\n", code);
- goto FetchEndCall;
- }
- tversion.counter = 0;
-#endif
/* give invalid label during file transit */
tversion.epoch = 0;
code = (*ubik_dbase->setlabel) (ubik_dbase, file, &tversion);
ubik_dprint("setlabel io error=%d\n", code);
goto FetchEndCall;
}
-#ifndef OLD_URECOVERY
- flen = length;
afs_snprintf(pbuffer, sizeof(pbuffer), "%s.DB%s%d.TMP", ubik_dbase->pathName, (file<0)?"SYS":"", (file<0)?-file:file);
fd = open(pbuffer, O_CREAT | O_RDWR | O_TRUNC, 0600);
if (fd < 0) {
close(fd);
goto FetchEndCall;
}
-#endif
pass = 0;
while (length > 0) {
close(fd);
goto FetchEndCall;
}
-#ifdef OLD_URECOVERY
- nbytes =
- (*ubik_dbase->write) (ubik_dbase, file, tbuffer, offset,
- tlen);
-#else
nbytes = write(fd, tbuffer, tlen);
pass++;
-#endif
if (nbytes != tlen) {
code = UIOERROR;
close(fd);
offset += tlen;
length -= tlen;
}
-#ifndef OLD_URECOVERY
code = close(fd);
if (code)
goto FetchEndCall;
-#endif
code = EndDISK_GetFile(rxcall, &tversion);
FetchEndCall:
tcode = rx_EndCall(rxcall, code);
urecovery_state |= UBIK_RECHAVEDB;
memcpy(&ubik_dbase->version, &tversion,
sizeof(struct ubik_version));
-#ifdef OLD_URECOVERY
- (*ubik_dbase->sync) (ubik_dbase, 0); /* get data out first */
-#else
afs_snprintf(tbuffer, sizeof(tbuffer), "%s.DB%s%d", ubik_dbase->pathName, (file<0)?"SYS":"", (file<0)?-file:file);
#ifdef AFS_NT40_ENV
afs_snprintf(pbuffer, sizeof(pbuffer), "%s.DB%s%d.OLD", ubik_dbase->pathName, (file<0)?"SYS":"", (file<0)?-file:file);
if (!code)
code = rename(pbuffer, tbuffer);
if (!code) {
- (*ubik_dbase->open) (ubik_dbase, 0);
-#endif
+ (*ubik_dbase->open) (ubik_dbase, file);
/* after data is good, sync disk with correct label */
code =
(*ubik_dbase->setlabel) (ubik_dbase, 0,
&ubik_dbase->version);
-#ifndef OLD_URECOVERY
}
#ifdef AFS_NT40_ENV
afs_snprintf(pbuffer, sizeof(pbuffer), "%s.DB%s%d.OLD", ubik_dbase->pathName, (file<0)?"SYS":"", (file<0)?-file:file);
unlink(pbuffer);
#endif
-#endif
}
if (code) {
-#ifndef OLD_URECOVERY
unlink(pbuffer);
/*
* We will effectively invalidate the old data forever now.
* Unclear if we *should* but we do.
*/
-#endif
ubik_dbase->version.epoch = 0;
ubik_dbase->version.counter = 0;
ubik_print("Ubik: Synchronize database failed (error = %d)\n",
}
udisk_Invalidate(ubik_dbase, 0); /* data has changed */
#ifdef AFS_PTHREAD_ENV
- assert(pthread_cond_broadcast(&ubik_dbase->version_cond) == 0);
+ CV_BROADCAST(&ubik_dbase->version_cond);
#else
LWP_NoYieldSignal(&ubik_dbase->version);
#endif
DBRELE(ubik_dbase);
}
-#if defined(UBIK_PAUSE)
- if (!(urecovery_state & UBIK_RECSYNCSITE))
- continue; /* lost sync */
-#endif /* UBIK_PAUSE */
if (!(urecovery_state & UBIK_RECHAVEDB))
continue; /* not ready */
(*ubik_dbase->setlabel) (ubik_dbase, 0, &ubik_dbase->version);
udisk_Invalidate(ubik_dbase, 0); /* data may have changed */
#ifdef AFS_PTHREAD_ENV
- assert(pthread_cond_broadcast(&ubik_dbase->version_cond) == 0);
+ CV_BROADCAST(&ubik_dbase->version_cond);
#else
LWP_NoYieldSignal(&ubik_dbase->version);
#endif
break;
}
}
- assert(i); /* at least one interface address for this server */
+ osi_Assert(i); /* at least one interface address for this server */
#ifdef AFS_PTHREAD_ENV
DBRELE(ubik_dbase);