440 lines
15 KiB
C
440 lines
15 KiB
C
/*-
|
|
* See the file LICENSE for redistribution information.
|
|
*
|
|
* Copyright (c) 1996,2008 Oracle. All rights reserved.
|
|
*
|
|
* $Id: log.h 63573 2008-05-23 21:43:21Z trent.nelson $
|
|
*/
|
|
|
|
#ifndef _DB_LOG_H_
|
|
#define _DB_LOG_H_
|
|
|
|
#include "dbinc/db_swap.h"
|
|
|
|
#if defined(__cplusplus)
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*******************************************************
|
|
* DBREG:
|
|
* The DB file register code keeps track of open files. It's stored
|
|
* in the log subsystem's shared region, and so appears in the log.h
|
|
* header file, but is logically separate.
|
|
*******************************************************/
|
|
/*
|
|
* The per-process table that maps log file-id's to DB structures.
|
|
*/
|
|
typedef struct __db_entry {
|
|
DB *dbp; /* Open dbp for this file id. */
|
|
int deleted; /* File was not found during open. */
|
|
} DB_ENTRY;
|
|
|
|
/*
|
|
* FNAME --
|
|
* File name and id.
|
|
*/
|
|
struct __fname {
|
|
SH_TAILQ_ENTRY q; /* File name queue. */
|
|
|
|
pid_t pid; /* Process that owns this. */
|
|
int32_t id; /* Logging file id. */
|
|
int32_t old_id; /* Saved logging file id. */
|
|
DBTYPE s_type; /* Saved DB type. */
|
|
|
|
roff_t fname_off; /* File name offset. */
|
|
roff_t dname_off; /* Database name offset. */
|
|
db_pgno_t meta_pgno; /* Page number of the meta page. */
|
|
u_int8_t ufid[DB_FILE_ID_LEN]; /* Unique file id. */
|
|
|
|
u_int32_t create_txnid; /*
|
|
* Txn ID of the DB create, stored so
|
|
* we can log it at register time.
|
|
*/
|
|
db_mutex_t mutex; /* mutex from db handle. */
|
|
/* number of txn referencing + 1 for the db handle. */
|
|
u_int32_t txn_ref;
|
|
|
|
#define DB_FNAME_CLOSED 0x01 /* DBP was closed. */
|
|
#define DB_FNAME_DURABLE 0x02 /* File is durable. */
|
|
#define DB_FNAME_INMEM 0x04 /* File is in memory. */
|
|
#define DB_FNAME_NOTLOGGED 0x08 /* Log of close failed. */
|
|
#define DB_FNAME_RECOVER 0x10 /* File was opened by recovery code. */
|
|
#define DB_FNAME_RESTORED 0x20 /* File may be in restored txn. */
|
|
u_int32_t flags;
|
|
};
|
|
|
|
/* File open/close register log record opcodes. */
|
|
#define DBREG_CHKPNT 1 /* Checkpoint: file name/id dump. */
|
|
#define DBREG_CLOSE 2 /* File close. */
|
|
#define DBREG_OPEN 3 /* File open. */
|
|
#define DBREG_PREOPEN 4 /* Open in mpool only. */
|
|
#define DBREG_RCLOSE 5 /* File close after recovery. */
|
|
#define DBREG_REOPEN 6 /* Open for in-memory database. */
|
|
|
|
/*******************************************************
|
|
* LOG:
|
|
* The log subsystem information.
|
|
*******************************************************/
|
|
struct __hdr; typedef struct __hdr HDR;
|
|
struct __log; typedef struct __log LOG;
|
|
struct __log_persist; typedef struct __log_persist LOGP;
|
|
|
|
#define LFPREFIX "log." /* Log file name prefix. */
|
|
#define LFNAME "log.%010d" /* Log file name template. */
|
|
#define LFNAME_V1 "log.%05d" /* Log file name template, rev 1. */
|
|
|
|
#define LG_MAX_DEFAULT (10 * MEGABYTE) /* 10 MB. */
|
|
#define LG_MAX_INMEM (256 * 1024) /* 256 KB. */
|
|
#define LG_BSIZE_INMEM (1 * MEGABYTE) /* 1 MB. */
|
|
|
|
/*
|
|
* Allocate a few bytes under a power-of-two value. BDB doesn't care if it's
|
|
* a power-of-two or not, and requesting slightly under a power-of-two allows
|
|
* stupid allocators to avoid wasting space.
|
|
*/
|
|
#define LG_BASE_REGION_SIZE (65000) /* 64KB - 536B */
|
|
#define LG_BSIZE_DEFAULT (32000) /* 32 KB - 768B */
|
|
#define LG_CURSOR_BUF_SIZE (32000) /* 32KB - 768B */
|
|
|
|
/*
|
|
* DB_LOG
|
|
* Per-process log structure.
|
|
*/
|
|
struct __db_log {
|
|
/*
|
|
* These fields need to be protected for multi-threaded support.
|
|
*/
|
|
db_mutex_t mtx_dbreg; /* Mutex for thread protection. */
|
|
|
|
DB_ENTRY *dbentry; /* Recovery file-id mapping. */
|
|
#define DB_GROW_SIZE 64
|
|
int32_t dbentry_cnt; /* Entries. Grows by DB_GROW_SIZE. */
|
|
|
|
/*
|
|
* These fields are only accessed when the region lock is held, so
|
|
* they do not have to be protected by the thread lock as well.
|
|
*/
|
|
u_int32_t lfname; /* Log file "name". */
|
|
DB_FH *lfhp; /* Log file handle. */
|
|
time_t lf_timestamp; /* Log file timestamp. */
|
|
|
|
u_int8_t *bufp; /* Region buffer. */
|
|
|
|
/* These fields are not thread protected. */
|
|
ENV *env; /* Environment */
|
|
REGINFO reginfo; /* Region information. */
|
|
|
|
#define DBLOG_AUTOREMOVE 0x01 /* Autoremove log files. */
|
|
#define DBLOG_DIRECT 0x02 /* Do direct I/O on the log. */
|
|
#define DBLOG_DSYNC 0x04 /* Set OS_DSYNC on the log. */
|
|
#define DBLOG_FORCE_OPEN 0x08 /* Force the DB open even if it appears
|
|
* to be deleted. */
|
|
#define DBLOG_INMEMORY 0x10 /* Logging is in memory. */
|
|
#define DBLOG_OPENFILES 0x20 /* Prepared files need to be open. */
|
|
#define DBLOG_RECOVER 0x40 /* We are in recovery. */
|
|
#define DBLOG_ZERO 0x80 /* Zero fill the log. */
|
|
u_int32_t flags;
|
|
};
|
|
|
|
/*
|
|
* HDR --
|
|
* Log record header.
|
|
*/
|
|
struct __hdr {
|
|
u_int32_t prev; /* Previous offset. */
|
|
u_int32_t len; /* Current length. */
|
|
u_int8_t chksum[DB_MAC_KEY]; /* Current checksum. */
|
|
u_int8_t iv[DB_IV_BYTES]; /* IV */
|
|
u_int32_t orig_size; /* Original size of log record */
|
|
/* !!! - 'size' is not written to log, must be last in hdr */
|
|
size_t size; /* Size of header to use */
|
|
};
|
|
|
|
/*
|
|
* LOG_HDR_SUM -- XOR in prev and len
|
|
* This helps avoids the race misreading the log while it
|
|
* it is being updated.
|
|
*/
|
|
#define LOG_HDR_SUM(crypto, hdr, sum) do { \
|
|
if (crypto) { \
|
|
((u_int32_t *)sum)[0] ^= ((HDR *)hdr)->prev; \
|
|
((u_int32_t *)sum)[1] ^= ((HDR *)hdr)->len; \
|
|
} else { \
|
|
((u_int32_t *)sum)[0] ^= \
|
|
((HDR *)hdr)->prev ^ ((HDR *)hdr)->len; \
|
|
} \
|
|
} while (0)
|
|
|
|
/*
|
|
* We use HDR internally, and then when we write out, we write out
|
|
* prev, len, and then a 4-byte checksum if normal operation or
|
|
* a crypto-checksum and IV and original size if running in crypto
|
|
* mode. We must store the original size in case we pad. Set the
|
|
* size when we set up the header. We compute a DB_MAC_KEY size
|
|
* checksum regardless, but we can safely just use the first 4 bytes.
|
|
*/
|
|
#define HDR_NORMAL_SZ 12
|
|
#define HDR_CRYPTO_SZ 12 + DB_MAC_KEY + DB_IV_BYTES
|
|
|
|
struct __log_persist {
|
|
u_int32_t magic; /* DB_LOGMAGIC */
|
|
u_int32_t version; /* DB_LOGVERSION */
|
|
|
|
u_int32_t log_size; /* Log file size. */
|
|
u_int32_t notused; /* Historically the log file mode. */
|
|
};
|
|
|
|
/* Macros to lock/unlock the log region as a whole. */
|
|
#define LOG_SYSTEM_LOCK(env) \
|
|
MUTEX_LOCK(env, ((LOG *) \
|
|
(env)->lg_handle->reginfo.primary)->mtx_region)
|
|
#define LOG_SYSTEM_UNLOCK(env) \
|
|
MUTEX_UNLOCK(env, ((LOG *) \
|
|
(env)->lg_handle->reginfo.primary)->mtx_region)
|
|
|
|
/*
|
|
* LOG --
|
|
* Shared log region. One of these is allocated in shared memory,
|
|
* and describes the log.
|
|
*/
|
|
struct __log {
|
|
db_mutex_t mtx_region; /* Region mutex. */
|
|
|
|
db_mutex_t mtx_filelist; /* Mutex guarding file name list. */
|
|
|
|
LOGP persist; /* Persistent information. */
|
|
|
|
SH_TAILQ_HEAD(__fq1) fq; /* List of file names. */
|
|
int32_t fid_max; /* Max fid allocated. */
|
|
roff_t free_fid_stack; /* Stack of free file ids. */
|
|
u_int free_fids; /* Height of free fid stack. */
|
|
u_int free_fids_alloced; /* N free fid slots allocated. */
|
|
|
|
/*
|
|
* The lsn LSN is the file offset that we're about to write and which
|
|
* we will return to the user.
|
|
*/
|
|
DB_LSN lsn; /* LSN at current file offset. */
|
|
|
|
/*
|
|
* The f_lsn LSN is the LSN (returned to the user) that "owns" the
|
|
* first byte of the buffer. If the record associated with the LSN
|
|
* spans buffers, it may not reflect the physical file location of
|
|
* the first byte of the buffer.
|
|
*/
|
|
DB_LSN f_lsn; /* LSN of first byte in the buffer. */
|
|
size_t b_off; /* Current offset in the buffer. */
|
|
u_int32_t w_off; /* Current write offset in the file. */
|
|
u_int32_t len; /* Length of the last record. */
|
|
|
|
DB_LSN active_lsn; /* Oldest active LSN in the buffer. */
|
|
size_t a_off; /* Offset in the buffer of first active
|
|
file. */
|
|
|
|
/*
|
|
* The s_lsn LSN is the last LSN that we know is on disk, not just
|
|
* written, but synced. This field is protected by the flush mutex
|
|
* rather than by the region mutex.
|
|
*/
|
|
db_mutex_t mtx_flush; /* Mutex guarding flushing. */
|
|
int in_flush; /* Log flush in progress. */
|
|
DB_LSN s_lsn; /* LSN of the last sync. */
|
|
|
|
DB_LOG_STAT stat; /* Log statistics. */
|
|
|
|
/*
|
|
* This timestamp is updated anytime someone unlinks log
|
|
* files. This can happen when calling __log_vtruncate
|
|
* or replication internal init when it unlinks log files.
|
|
*
|
|
* The timestamp is used so that other processes that might
|
|
* have file handles to log files know to close/reopen them
|
|
* so they're not potentially writing to now-removed files.
|
|
*/
|
|
time_t timestamp; /* Log trunc timestamp. */
|
|
|
|
/*
|
|
* !!!
|
|
* NOTE: the next group of fields are NOT protected by the log
|
|
* region lock. They are protected by REP->mtx_clientdb. If you
|
|
* need access to both, you must acquire REP->mtx_clientdb
|
|
* before acquiring the log region lock.
|
|
*
|
|
* The waiting_lsn is used by the replication system. It is the
|
|
* first LSN that we are holding without putting in the log, because
|
|
* we received one or more log records out of order. Associated with
|
|
* the waiting_lsn is the number of log records that we still have to
|
|
* receive before we decide that we should request it again.
|
|
*
|
|
* The max_wait_lsn is used to control retransmission in the face
|
|
* of dropped messages. If we are requesting all records from the
|
|
* current gap (i.e., chunk of the log that we are missing), then
|
|
* the max_wait_lsn contains the first LSN that we are known to have
|
|
* in the __db.rep.db. If we requested only a single record, then
|
|
* the max_wait_lsn has the LSN of that record we requested.
|
|
*/
|
|
/* BEGIN fields protected by rep->mtx_clientdb. */
|
|
DB_LSN waiting_lsn; /* First log record after a gap. */
|
|
DB_LSN verify_lsn; /* LSN we are waiting to verify. */
|
|
DB_LSN max_wait_lsn; /* Maximum LSN requested. */
|
|
DB_LSN max_perm_lsn; /* Maximum PERMANENT LSN processed. */
|
|
db_timespec max_lease_ts; /* Maximum Lease timestamp seen. */
|
|
db_timespec wait_ts; /* Time to wait before requesting. */
|
|
db_timespec rcvd_ts; /* Initial received time to wait. */
|
|
db_timespec last_ts; /* Last time of insert in temp db. */
|
|
/*
|
|
* The ready_lsn is also used by the replication system. It is the
|
|
* next LSN we expect to receive. It's normally equal to "lsn",
|
|
* except at the beginning of a log file, at which point it's set
|
|
* to the LSN of the first record of the new file (after the
|
|
* header), rather than to 0.
|
|
*/
|
|
DB_LSN ready_lsn;
|
|
/*
|
|
* The bulk_buf is used by replication for bulk transfer. While this
|
|
* is protected by REP->mtx_clientdb, this doesn't contend with the
|
|
* above fields because the above are used by clients and the bulk
|
|
* fields below are used by a master.
|
|
*/
|
|
roff_t bulk_buf; /* Bulk transfer buffer in region. */
|
|
uintptr_t bulk_off; /* Current offset into bulk buffer. */
|
|
u_int32_t bulk_len; /* Length of buffer. */
|
|
u_int32_t bulk_flags; /* Bulk buffer flags. */
|
|
/* END fields protected by rep->mtx_clientdb. */
|
|
|
|
/*
|
|
* During initialization, the log system walks forward through the
|
|
* last log file to find its end. If it runs into a checkpoint
|
|
* while it's doing so, it caches it here so that the transaction
|
|
* system doesn't need to walk through the file again on its
|
|
* initialization.
|
|
*/
|
|
DB_LSN cached_ckp_lsn;
|
|
|
|
u_int32_t regionmax; /* Configured size of the region. */
|
|
|
|
roff_t buffer_off; /* Log buffer offset in the region. */
|
|
u_int32_t buffer_size; /* Log buffer size. */
|
|
|
|
u_int32_t log_size; /* Log file's size. */
|
|
u_int32_t log_nsize; /* Next log file's size. */
|
|
|
|
int filemode; /* Log file permissions mode. */
|
|
|
|
/*
|
|
* DB_LOG_AUTOREMOVE and DB_LOG_INMEMORY: not protected by a mutex,
|
|
* all we care about is if they're zero or non-zero.
|
|
*/
|
|
int db_log_autoremove;
|
|
int db_log_inmemory;
|
|
|
|
u_int32_t ncommit; /* Number of txns waiting to commit. */
|
|
DB_LSN t_lsn; /* LSN of first commit */
|
|
SH_TAILQ_HEAD(__commit) commits;/* list of txns waiting to commit. */
|
|
SH_TAILQ_HEAD(__free) free_commits;/* free list of commit structs. */
|
|
|
|
/*
|
|
* In-memory logs maintain a list of the start positions of all log
|
|
* files currently active in the in-memory buffer. This is to make the
|
|
* lookup from LSN to log buffer offset efficient.
|
|
*/
|
|
SH_TAILQ_HEAD(__logfile) logfiles;
|
|
SH_TAILQ_HEAD(__free_logfile) free_logfiles;
|
|
};
|
|
|
|
/*
|
|
* __db_commit structure --
|
|
* One of these is allocated for each transaction waiting to commit.
|
|
*/
|
|
struct __db_commit {
|
|
db_mutex_t mtx_txnwait; /* Mutex for txn to wait on. */
|
|
DB_LSN lsn; /* LSN of commit record. */
|
|
SH_TAILQ_ENTRY links; /* Either on free or waiting list. */
|
|
|
|
#define DB_COMMIT_FLUSH 0x0001 /* Flush the log when you wake up. */
|
|
u_int32_t flags;
|
|
};
|
|
|
|
/*
|
|
* Check for the proper progression of Log Sequence Numbers.
|
|
* If we are rolling forward the LSN on the page must be greater
|
|
* than or equal to the previous LSN in log record.
|
|
* We ignore NOT LOGGED LSNs. The user did an unlogged update.
|
|
* We should eventually see a log record that matches and continue
|
|
* forward.
|
|
* A ZERO LSN implies a page that was allocated prior to the recovery
|
|
* start point and then truncated later in the log. An allocation of a
|
|
* page after this page will extend the file, leaving a hole. We want to
|
|
* ignore this page until it is truncated again.
|
|
*
|
|
*/
|
|
|
|
#define CHECK_LSN(e, redo, cmp, lsn, prev) \
|
|
if (DB_REDO(redo) && (cmp) < 0 && \
|
|
((!IS_NOT_LOGGED_LSN(*(lsn)) && !IS_ZERO_LSN(*(lsn))) || \
|
|
IS_REP_CLIENT(e))) { \
|
|
ret = __db_check_lsn(e, lsn, prev); \
|
|
goto out; \
|
|
}
|
|
|
|
/*
|
|
* Helper for in-memory logs -- check whether an offset is in range
|
|
* in a ring buffer (inclusive of start, exclusive of end).
|
|
*/
|
|
struct __db_filestart {
|
|
u_int32_t file;
|
|
size_t b_off;
|
|
|
|
SH_TAILQ_ENTRY links; /* Either on free or waiting list. */
|
|
};
|
|
|
|
#define RINGBUF_LEN(lp, start, end) \
|
|
((start) < (end) ? \
|
|
(end) - (start) : (lp)->buffer_size - ((start) - (end)))
|
|
|
|
/*
|
|
* Internal macro to set pointer to the begin_lsn for generated
|
|
* logging routines. If begin_lsn is already set then do nothing.
|
|
* Return a pointer to the last lsn too.
|
|
*/
|
|
#undef DB_SET_TXN_LSNP
|
|
#define DB_SET_TXN_LSNP(txn, blsnp, llsnp) do { \
|
|
DB_LSN *__lsnp; \
|
|
TXN_DETAIL *__td; \
|
|
__td = (txn)->td; \
|
|
*(llsnp) = &__td->last_lsn; \
|
|
while (__td->parent != INVALID_ROFF) \
|
|
__td = R_ADDR(&(txn)->mgrp->reginfo, __td->parent); \
|
|
__lsnp = &__td->begin_lsn; \
|
|
if (IS_ZERO_LSN(*__lsnp)) \
|
|
*(blsnp) = __lsnp; \
|
|
} while (0)
|
|
|
|
/*
|
|
* These are used in __log_backup to determine which LSN in the
|
|
* checkpoint record to compare and return.
|
|
*/
|
|
#define CKPLSN_CMP 0
|
|
#define LASTCKP_CMP 1
|
|
|
|
/*
|
|
* Status codes indicating the validity of a log file examined by
|
|
* __log_valid().
|
|
*/
|
|
typedef enum {
|
|
DB_LV_INCOMPLETE,
|
|
DB_LV_NONEXISTENT,
|
|
DB_LV_NORMAL,
|
|
DB_LV_OLD_READABLE,
|
|
DB_LV_OLD_UNREADABLE
|
|
} logfile_validity;
|
|
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif
|
|
|
|
#include "dbinc_auto/dbreg_auto.h"
|
|
#include "dbinc_auto/dbreg_ext.h"
|
|
#include "dbinc_auto/log_ext.h"
|
|
#endif /* !_DB_LOG_H_ */
|