summaryrefslogtreecommitdiff
path: root/db2/log/log.c
diff options
context:
space:
mode:
Diffstat (limited to 'db2/log/log.c')
-rw-r--r--db2/log/log.c438
1 files changed, 438 insertions, 0 deletions
diff --git a/db2/log/log.c b/db2/log/log.c
new file mode 100644
index 0000000000..1684ce8cc8
--- /dev/null
+++ b/db2/log/log.c
@@ -0,0 +1,438 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997
+ * Sleepycat Software. All rights reserved.
+ */
+#include "config.h"
+
+#ifndef lint
+static const char sccsid[] = "@(#)log.c 10.24 (Sleepycat) 8/16/97";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#endif
+
+#include "db_int.h"
+#include "shqueue.h"
+#include "db_shash.h"
+#include "log.h"
+#include "db_dispatch.h"
+#include "txn_auto.h"
+#include "common_ext.h"
+
+static int __log_recover __P((DB_ENV *, DB_LOG *));
+
+/*
+ * log_open --
+ * Initialize and/or join a log.
+ */
+int
+log_open(path, flags, mode, dbenv, lpp)
+ const char *path;
+ int flags;
+ int mode;
+ DB_ENV *dbenv;
+ DB_LOG **lpp;
+{
+ DB_LOG *dblp;
+ LOG *lp;
+ size_t len;
+ int fd, newregion, ret, retry_cnt;
+
+ /* Validate arguments. */
+#ifdef HAVE_SPINLOCKS
+#define OKFLAGS (DB_CREATE | DB_THREAD)
+#else
+#define OKFLAGS (DB_CREATE)
+#endif
+ if ((ret = __db_fchk(dbenv, "log_open", flags, OKFLAGS)) != 0)
+ return (ret);
+
+ /*
+ * We store 4-byte offsets into the file, so the maximum file
+ * size can't be larger than that.
+ */
+ if (dbenv != NULL && dbenv->lg_max > UINT32_T_MAX) {
+ __db_err(dbenv, "log_open: maximum file size too large");
+ return (EINVAL);
+ }
+
+ /* Create and initialize the DB_LOG structure. */
+ if ((dblp = (DB_LOG *)calloc(1, sizeof(DB_LOG))) == NULL)
+ return (ENOMEM);
+
+ dblp->dbenv = dbenv;
+ dblp->lfd = -1;
+ ZERO_LSN(dblp->c_lsn);
+ dblp->c_fd = -1;
+ if (LF_ISSET(DB_THREAD)) {
+ F_SET(dblp, DB_AM_THREAD);
+ (void)__db_mutex_init(&dblp->mutex, -1);
+ }
+
+ /*
+ * The log region isn't fixed size because we store the registered
+ * file names there. Make it fairly large so that we don't have to
+ * grow it.
+ */
+ len = 30 * 1024;
+
+ /* Map in the region. */
+ retry_cnt = newregion = 0;
+retry: if (LF_ISSET(DB_CREATE)) {
+ ret = __db_rcreate(dbenv, DB_APP_LOG, path,
+ DB_DEFAULT_LOG_FILE, mode, len, &fd, &dblp->maddr);
+ if (ret == 0) {
+ /* Put the LOG structure first in the region. */
+ lp = dblp->maddr;
+
+ /* Initialize the rest of the region as free space. */
+ dblp->addr = (u_int8_t *)dblp->maddr + sizeof(LOG);
+ __db_shalloc_init(dblp->addr, len - sizeof(LOG));
+
+ /* Initialize the LOG structure. */
+ lp->persist.lg_max = dbenv == NULL ? 0 : dbenv->lg_max;
+ if (lp->persist.lg_max == 0)
+ lp->persist.lg_max = DEFAULT_MAX;
+ lp->persist.magic = DB_LOGMAGIC;
+ lp->persist.version = DB_LOGVERSION;
+ lp->persist.mode = mode;
+ SH_TAILQ_INIT(&lp->fq);
+
+ /* Initialize LOG LSNs. */
+ lp->lsn.file = 1;
+ lp->lsn.offset = 0;
+
+ newregion = 1;
+ } else if (ret != EEXIST)
+ return (ret);
+ }
+
+ /* If we didn't or couldn't create the region, try and join it. */
+ if (!newregion &&
+ (ret = __db_ropen(dbenv, DB_APP_LOG,
+ path, DB_DEFAULT_LOG_FILE, 0, &fd, &dblp->maddr)) != 0) {
+ /*
+ * If we fail because the file isn't available, wait a
+ * second and try again.
+ */
+ if (ret == EAGAIN && ++retry_cnt < 3) {
+ (void)__db_sleep(1, 0);
+ goto retry;
+ }
+ return (ret);
+ }
+
+ /* Set up the common information. */
+ dblp->lp = dblp->maddr;
+ dblp->addr = (u_int8_t *)dblp->maddr + sizeof(LOG);
+ dblp->fd = fd;
+
+ /*
+ * If doing recovery, try and recover any previous log files
+ * before releasing the lock.
+ */
+ if (newregion) {
+ if ((ret = __log_recover(dbenv, dblp)) != 0) {
+ log_unlink(path, 1, dbenv);
+ return (ret);
+ }
+ UNLOCK_LOGREGION(dblp);
+ }
+ *lpp = dblp;
+ return (0);
+}
+
+/*
+ * __log_recover --
+ * Recover a log.
+ */
+static int
+__log_recover(dbenv, dblp)
+ DB_ENV *dbenv;
+ DB_LOG *dblp;
+{
+ DBT dbt;
+ DB_LSN lsn;
+ LOG *lp;
+ u_int32_t chk;
+ int cnt, found_checkpoint, ret;
+
+ lp = dblp->lp;
+
+ /*
+ * Find a log file. If none exist, we simply return, leaving
+ * everything initialized to a new log.
+ */
+ if ((ret = __log_find(dbenv, lp, &cnt)) != 0)
+ return (ret);
+ if (cnt == 0)
+ return (0);
+
+ /* We have a log file name, find the last one. */
+ while (cnt < MAXLFNAME)
+ if (__log_valid(dbenv, lp, ++cnt) != 0) {
+ --cnt;
+ break;
+ }
+
+ /*
+ * We have the last useful log file and we've loaded any persistent
+ * information. Pretend that the log is larger than it can possibly
+ * be, and read this file, looking for a checkpoint and its end.
+ */
+ dblp->c_lsn.file = cnt;
+ dblp->c_lsn.offset = 0;
+ lsn = dblp->c_lsn;
+ lp->lsn.file = cnt + 1;
+ lp->lsn.offset = 0;
+
+ /* Set the cursor. Shouldn't fail, leave error messages on. */
+ memset(&dbt, 0, sizeof(dbt));
+ if ((ret = __log_get(dblp, &lsn, &dbt, DB_SET, 0)) != 0)
+ return (ret);
+
+ /*
+ * Read to the end of the file, saving checkpoints. This will fail
+ * at some point, so turn off error messages.
+ */
+ found_checkpoint = 0;
+ while (__log_get(dblp, &lsn, &dbt, DB_NEXT, 1) == 0) {
+ if (dbt.size < sizeof(u_int32_t))
+ continue;
+ memcpy(&chk, dbt.data, sizeof(u_int32_t));
+ if (chk == DB_txn_ckp) {
+ lp->c_lsn = lsn;
+ found_checkpoint = 1;
+ }
+ }
+
+ /*
+ * We know where the end of the log is. Since that record is on disk,
+ * it's also the last-synced LSN.
+ */
+ lp->lsn = lsn;
+ lp->lsn.offset += dblp->c_len;
+ lp->s_lsn = lp->lsn;
+
+ /* Set up the current buffer information, too. */
+ lp->len = dblp->c_len;
+ lp->b_off = 0;
+ lp->w_off = lp->lsn.offset;
+
+ /*
+ * It's possible that we didn't find a checkpoint because there wasn't
+ * one in the last log file. Start searching.
+ */
+ while (!found_checkpoint && cnt > 1) {
+ dblp->c_lsn.file = --cnt;
+ dblp->c_lsn.offset = 0;
+ lsn = dblp->c_lsn;
+
+ /* Set the cursor. Shouldn't fail, leave error messages on. */
+ if ((ret = __log_get(dblp, &lsn, &dbt, DB_SET, 0)) != 0)
+ return (ret);
+
+ /*
+ * Read to the end of the file, saving checkpoints. Shouldn't
+ * fail, leave error messages on.
+ */
+ while (__log_get(dblp, &lsn, &dbt, DB_NEXT, 0) == 0) {
+ if (dbt.size < sizeof(u_int32_t))
+ continue;
+ memcpy(&chk, dbt.data, sizeof(u_int32_t));
+ if (chk == DB_txn_ckp) {
+ lp->c_lsn = lsn;
+ found_checkpoint = 1;
+ }
+ }
+ }
+
+ /* If we never find a checkpoint, that's okay, just 0 it out. */
+ if (!found_checkpoint) {
+ lp->c_lsn.file = 1;
+ lp->c_lsn.offset = 0;
+ }
+
+ __db_err(dbenv,
+ "Recovering the log: last valid LSN: file: %lu offset %lu",
+ (u_long)lp->lsn.file, (u_long)lp->lsn.offset);
+
+ /* Reset the cursor. */
+ ZERO_LSN(dblp->c_lsn);
+
+ return (0);
+}
+
+/*
+ * __log_find --
+ * Try to find a log file.
+ *
+ * PUBLIC: int __log_find __P((DB_ENV *, LOG *, int *));
+ */
+int
+__log_find(dbenv, lp, valp)
+ DB_ENV *dbenv;
+ LOG *lp;
+ int *valp;
+{
+ int cnt, fcnt, logval, ret;
+ const char *dir;
+ char **names, *p, *q;
+
+ /* Find the directory name. */
+ if ((ret = __log_name(dbenv, 1, &p)) != 0)
+ return (ret);
+ if ((q = __db_rpath(p)) == NULL)
+ dir = PATH_DOT;
+ else {
+ *q = '\0';
+ dir = p;
+ }
+
+ /* Get the list of file names. */
+ ret = __db_dir(dbenv, dir, &names, &fcnt);
+ FREES(p);
+ if (ret != 0)
+ return (ret);
+
+ /*
+ * Search for a valid log file name, return a value of 0 on
+ * failure.
+ */
+ *valp = 0;
+ for (cnt = fcnt, logval = 0; --cnt >= 0;)
+ if (strncmp(names[cnt], "log.", sizeof("log.") - 1) == 0) {
+ logval = atoi(names[cnt] + 4);
+ if (logval != 0 &&
+ __log_valid(dbenv, lp, logval) == 0) {
+ *valp = logval;
+ break;
+ }
+ }
+
+ /* Discard the list. */
+ __db_dirf(dbenv, names, fcnt);
+
+ return (ret);
+}
+
+/*
+ * log_valid --
+ * Validate a log file.
+ *
+ * PUBLIC: int __log_valid __P((DB_ENV *, LOG *, int));
+ */
+int
+__log_valid(dbenv, lp, cnt)
+ DB_ENV *dbenv;
+ LOG *lp;
+ int cnt;
+{
+ LOGP persist;
+ ssize_t nw;
+ int fd, ret;
+ char *p;
+
+ if ((ret = __log_name(dbenv, cnt, &p)) != 0)
+ return (ret);
+
+ fd = -1;
+ if ((ret = __db_fdopen(p,
+ DB_RDONLY | DB_SEQUENTIAL,
+ DB_RDONLY | DB_SEQUENTIAL, 0, &fd)) != 0 ||
+ (ret = __db_lseek(fd, 0, 0, sizeof(HDR), SEEK_SET)) != 0 ||
+ (ret = __db_read(fd, &persist, sizeof(LOGP), &nw)) != 0 ||
+ nw != sizeof(LOGP)) {
+ if (ret == 0)
+ ret = EIO;
+ if (fd != -1) {
+ (void)__db_close(fd);
+ __db_err(dbenv,
+ "Ignoring log file: %s: %s", p, strerror(ret));
+ }
+ goto err;
+ }
+ (void)__db_close(fd);
+
+ if (persist.magic != DB_LOGMAGIC) {
+ __db_err(dbenv,
+ "Ignoring log file: %s: magic number %lx, not %lx",
+ p, (u_long)persist.magic, (u_long)DB_LOGMAGIC);
+ ret = EINVAL;
+ goto err;
+ }
+ if (persist.version < DB_LOGOLDVER || persist.version > DB_LOGVERSION) {
+ __db_err(dbenv,
+ "Ignoring log file: %s: unsupported log version %lu",
+ p, (u_long)persist.version);
+ ret = EINVAL;
+ goto err;
+ }
+
+ if (lp != NULL) {
+ lp->persist.lg_max = persist.lg_max;
+ lp->persist.mode = persist.mode;
+ }
+ ret = 0;
+
+err: FREES(p);
+ return (ret);
+}
+
+/*
+ * log_close --
+ * Close a log.
+ */
+int
+log_close(dblp)
+ DB_LOG *dblp;
+{
+ int ret, t_ret;
+
+ ret = 0;
+
+ /* Close the region. */
+ if ((t_ret =
+ __db_rclose(dblp->dbenv, dblp->fd, dblp->maddr)) != 0 && ret == 0)
+ ret = t_ret;
+
+ /* Close open files, release allocated memory. */
+ if (dblp->lfd != -1 && (t_ret = __db_close(dblp->lfd)) != 0 && ret == 0)
+ ret = t_ret;
+ if (dblp->c_dbt.data != NULL)
+ FREE(dblp->c_dbt.data, dblp->c_dbt.ulen);
+ if (dblp->c_fd != -1 &&
+ (t_ret = __db_close(dblp->c_fd)) != 0 && ret == 0)
+ ret = t_ret;
+
+ /* Free the structure. */
+ if (dblp->dbentry != NULL)
+ FREE(dblp->dbentry, (dblp->dbentry_cnt * sizeof(DB_ENTRY)));
+ FREE(dblp, sizeof(DB_LOG));
+
+ return (ret);
+}
+
+/*
+ * log_unlink --
+ * Exit a log.
+ */
+int
+log_unlink(path, force, dbenv)
+ const char *path;
+ int force;
+ DB_ENV *dbenv;
+{
+ return (__db_runlink(dbenv,
+ DB_APP_LOG, path, DB_DEFAULT_LOG_FILE, force));
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-27 12:59:47 +0000