/*-
* See the file LICENSE for redistribution information.
*
* Copyright (c) 1996, 1997, 1998
* Sleepycat Software. All rights reserved.
*/
#include "config.h"
#ifndef lint
#endif /* not lint */
#ifndef NO_SYSTEM_INCLUDES
#include <string.h>
#endif
#include "db_int.h"
#include "shqueue.h"
#include "db_page.h"
#include "log.h"
#include "hash.h"
#include "btree.h"
/*
* PUBLIC: int __db_addrem_recover
* PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
*
* This log message is generated whenever we add or remove a duplicate
*/
int
int redo;
void *info;
{
if (!redo) {
/*
* We are undoing and the page doesn't exist. That
* is equivalent to having a pagelsn of 0, so we
* would not have to undo anything. In this case,
* don't bother creating a page.
*/
goto done;
} else
goto out;
}
change = 0;
/* Need to redo an add, or undo a delete. */
goto out;
/* Need to undo an add, or redo a delete. */
goto out;
}
if (change)
if (redo)
else
goto out;
ret = 0;
}
/*
* PUBLIC: int __db_split_recover __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
*/
int
int redo;
void *info;
{
if (!redo) {
/*
* We are undoing and the page doesn't exist. That
* is equivalent to having a pagelsn of 0, so we
* would not have to undo anything. In this case,
* don't bother creating a page.
*/
goto done;
} else
goto out;
/*
* There are two types of log messages here, one for the old page
* and one for the new pages created. The original image in the
* SPLITOLD record is used for undo. The image in the SPLITNEW
* is used for redo. We should never have a case where there is
* a redo operation and the SPLITOLD record is on disk, but not
* the SPLITNEW record. Therefore, we only redo NEW messages
* and only undo OLD messages.
*/
change = 0;
/* Need to redo the split described. */
}
/* Put back the old image. */
}
}
goto out;
ret = 0;
}
/*
* PUBLIC: int __db_big_recover __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
*/
int
int redo;
void *info;
{
if (!redo) {
/*
* We are undoing and the page doesn't exist. That
* is equivalent to having a pagelsn of 0, so we
* would not have to undo anything. In this case,
* don't bother creating a page.
*/
ret = 0;
goto ppage;
} else
goto out;
}
/*
* There are three pages we need to check. The one on which we are
* adding data, the previous one whose next_pointer may have
* been updated, and the next one whose prev_pointer may have
* been updated.
*/
change = 0;
/* We are either redo-ing an add, or undoing a delete. */
/*
* We are either undo-ing an add or redo-ing a delete.
* The page is about to be reclaimed in either case, so
* there really isn't anything to do here.
*/
}
if (change)
goto out;
/* Now check the previous page. */
change = 0;
if (!redo) {
/*
* We are undoing and the page doesn't exist.
* That is equivalent to having a pagelsn of 0,
* so we would not have to undo anything. In
* this case, don't bother creating a page.
*/
ret = 0;
goto npage;
} else
DB_MPOOL_CREATE, &pagep)) != 0)
goto out;
/* Redo add, undo delete. */
} else if ((cmp_n == 0 &&
/* Redo delete, undo add. */
}
if (change)
goto out;
}
/* Now check the next page. Can only be set on a delete. */
change = 0;
if (!redo) {
/*
* We are undoing and the page doesn't exist.
* That is equivalent to having a pagelsn of 0,
* so we would not have to undo anything. In
* this case, don't bother creating a page.
*/
goto done;
} else
DB_MPOOL_CREATE, &pagep)) != 0)
goto out;
}
if (change)
goto out;
}
ret = 0;
}
/*
* __db_ovref_recover --
* Recovery function for __db_ovref().
*
* PUBLIC: int __db_ovref_recover __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
*/
int
int redo;
void *info;
{
goto out;
}
modified = 0;
/* Need to redo update described. */
modified = 1;
/* Need to undo update described. */
modified = 1;
}
goto out;
ret = 0;
}
/*
* __db_relink_recover --
* Recovery function for relink.
*
* PUBLIC: int __db_relink_recover
* PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
*/
int
int redo;
void *info;
{
/*
* There are up to three pages we need to check -- the page, and the
* previous and next pages, if they existed. For a page add operation,
* the current page is the result of a split and is being recovered
* elsewhere, so all we need do is recover the next page.
*/
if (redo) {
goto out;
}
goto next;
}
goto next;
modified = 0;
/* Redo the relink. */
modified = 1;
/* Undo the relink. */
modified = 1;
}
goto out;
if (redo) {
goto out;
}
goto prev;
}
modified = 0;
/* Redo the remove or undo the add. */
modified = 1;
/* Undo the remove or redo the add. */
modified = 1;
}
goto out;
goto done;
if (redo) {
goto out;
}
goto done;
}
modified = 0;
/* Redo the relink. */
modified = 1;
/* Undo the relink. */
modified = 1;
}
goto out;
ret = 0;
}
/*
* PUBLIC: int __db_addpage_recover
* PUBLIC: __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
*/
int
int redo;
void *info;
{
/*
* We need to check two pages: the old one and the new one onto
* which we're going to add duplicates. Do the old one first.
*/
goto out;
change = 0;
}
goto out;
if (!redo) {
/*
* We are undoing and the page doesn't exist. That
* is equivalent to having a pagelsn of 0, so we
* would not have to undo anything. In this case,
* don't bother creating a page.
*/
goto done;
} else
goto out;
change = 0;
}
goto out;
ret = 0;
}
/*
* __db_debug_recover --
* Recovery function for debug.
*
* PUBLIC: int __db_debug_recover __P((DB_LOG *, DBT *, DB_LSN *, int, void *));
*/
int
int redo;
void *info;
{
int ret;
ret = 0;
}