Import BSDDB 4.7.25 (as of svn r89086)
This commit is contained in:
Zachary Ware
534
log/log_method.c
Normal file
534
log/log_method.c
Normal file
@@ -0,0 +1,534 @@
|
||||
/*-
|
||||
* See the file LICENSE for redistribution information.
|
||||
*
|
||||
* Copyright (c) 1999,2008 Oracle. All rights reserved.
|
||||
*
|
||||
* $Id: log_method.c 63573 2008-05-23 21:43:21Z trent.nelson $
|
||||
*/
|
||||
|
||||
#include "db_config.h"
|
||||
|
||||
#include "db_int.h"
|
||||
#include "dbinc/log.h"
|
||||
|
||||
/*
|
||||
* __log_env_create --
|
||||
* Log specific initialization of the DB_ENV structure.
|
||||
*
|
||||
* PUBLIC: int __log_env_create __P((DB_ENV *));
|
||||
*/
|
||||
int
|
||||
__log_env_create(dbenv)
|
||||
DB_ENV *dbenv;
|
||||
{
|
||||
/*
|
||||
* !!!
|
||||
* Our caller has not yet had the opportunity to reset the panic
|
||||
* state or turn off mutex locking, and so we can neither check
|
||||
* the panic state or acquire a mutex in the DB_ENV create path.
|
||||
*/
|
||||
dbenv->lg_bsize = 0;
|
||||
dbenv->lg_regionmax = LG_BASE_REGION_SIZE;
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* __log_env_destroy --
|
||||
* Log specific destruction of the DB_ENV structure.
|
||||
*
|
||||
* PUBLIC: void __log_env_destroy __P((DB_ENV *));
|
||||
*/
|
||||
void
|
||||
__log_env_destroy(dbenv)
|
||||
DB_ENV *dbenv;
|
||||
{
|
||||
COMPQUIET(dbenv, NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* PUBLIC: int __log_get_lg_bsize __P((DB_ENV *, u_int32_t *));
|
||||
*/
|
||||
int
|
||||
__log_get_lg_bsize(dbenv, lg_bsizep)
|
||||
DB_ENV *dbenv;
|
||||
u_int32_t *lg_bsizep;
|
||||
{
|
||||
ENV *env;
|
||||
|
||||
env = dbenv->env;
|
||||
|
||||
ENV_NOT_CONFIGURED(env,
|
||||
env->lg_handle, "DB_ENV->get_lg_bsize", DB_INIT_LOG);
|
||||
|
||||
if (LOGGING_ON(env)) {
|
||||
/* Cannot be set after open, no lock required to read. */
|
||||
*lg_bsizep =
|
||||
((LOG *)env->lg_handle->reginfo.primary)->buffer_size;
|
||||
} else
|
||||
*lg_bsizep = dbenv->lg_bsize;
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* __log_set_lg_bsize --
|
||||
* DB_ENV->set_lg_bsize.
|
||||
*
|
||||
* PUBLIC: int __log_set_lg_bsize __P((DB_ENV *, u_int32_t));
|
||||
*/
|
||||
int
|
||||
__log_set_lg_bsize(dbenv, lg_bsize)
|
||||
DB_ENV *dbenv;
|
||||
u_int32_t lg_bsize;
|
||||
{
|
||||
ENV *env;
|
||||
|
||||
env = dbenv->env;
|
||||
|
||||
ENV_ILLEGAL_AFTER_OPEN(env, "DB_ENV->set_lg_bsize");
|
||||
|
||||
dbenv->lg_bsize = lg_bsize;
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* PUBLIC: int __log_get_lg_filemode __P((DB_ENV *, int *));
|
||||
*/
|
||||
int
|
||||
__log_get_lg_filemode(dbenv, lg_modep)
|
||||
DB_ENV *dbenv;
|
||||
int *lg_modep;
|
||||
{
|
||||
DB_LOG *dblp;
|
||||
DB_THREAD_INFO *ip;
|
||||
ENV *env;
|
||||
|
||||
env = dbenv->env;
|
||||
|
||||
ENV_NOT_CONFIGURED(env,
|
||||
env->lg_handle, "DB_ENV->get_lg_filemode", DB_INIT_LOG);
|
||||
|
||||
if (LOGGING_ON(env)) {
|
||||
dblp = env->lg_handle;
|
||||
ENV_ENTER(env, ip);
|
||||
LOG_SYSTEM_LOCK(env);
|
||||
*lg_modep = ((LOG *)dblp->reginfo.primary)->filemode;
|
||||
LOG_SYSTEM_UNLOCK(env);
|
||||
ENV_LEAVE(env, ip);
|
||||
} else
|
||||
*lg_modep = dbenv->lg_filemode;
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* __log_set_lg_filemode --
|
||||
* DB_ENV->set_lg_filemode.
|
||||
*
|
||||
* PUBLIC: int __log_set_lg_filemode __P((DB_ENV *, int));
|
||||
*/
|
||||
int
|
||||
__log_set_lg_filemode(dbenv, lg_mode)
|
||||
DB_ENV *dbenv;
|
||||
int lg_mode;
|
||||
{
|
||||
DB_LOG *dblp;
|
||||
DB_THREAD_INFO *ip;
|
||||
ENV *env;
|
||||
LOG *lp;
|
||||
|
||||
env = dbenv->env;
|
||||
|
||||
ENV_NOT_CONFIGURED(env,
|
||||
env->lg_handle, "DB_ENV->set_lg_filemode", DB_INIT_LOG);
|
||||
|
||||
if (LOGGING_ON(env)) {
|
||||
dblp = env->lg_handle;
|
||||
lp = dblp->reginfo.primary;
|
||||
ENV_ENTER(env, ip);
|
||||
LOG_SYSTEM_LOCK(env);
|
||||
lp->filemode = lg_mode;
|
||||
LOG_SYSTEM_UNLOCK(env);
|
||||
ENV_LEAVE(env, ip);
|
||||
} else
|
||||
dbenv->lg_filemode = lg_mode;
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* PUBLIC: int __log_get_lg_max __P((DB_ENV *, u_int32_t *));
|
||||
*/
|
||||
int
|
||||
__log_get_lg_max(dbenv, lg_maxp)
|
||||
DB_ENV *dbenv;
|
||||
u_int32_t *lg_maxp;
|
||||
{
|
||||
DB_LOG *dblp;
|
||||
DB_THREAD_INFO *ip;
|
||||
ENV *env;
|
||||
|
||||
env = dbenv->env;
|
||||
|
||||
ENV_NOT_CONFIGURED(env,
|
||||
env->lg_handle, "DB_ENV->get_lg_max", DB_INIT_LOG);
|
||||
|
||||
if (LOGGING_ON(env)) {
|
||||
dblp = env->lg_handle;
|
||||
ENV_ENTER(env, ip);
|
||||
LOG_SYSTEM_LOCK(env);
|
||||
*lg_maxp = ((LOG *)dblp->reginfo.primary)->log_nsize;
|
||||
LOG_SYSTEM_UNLOCK(env);
|
||||
ENV_LEAVE(env, ip);
|
||||
} else
|
||||
*lg_maxp = dbenv->lg_size;
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* __log_set_lg_max --
|
||||
* DB_ENV->set_lg_max.
|
||||
*
|
||||
* PUBLIC: int __log_set_lg_max __P((DB_ENV *, u_int32_t));
|
||||
*/
|
||||
int
|
||||
__log_set_lg_max(dbenv, lg_max)
|
||||
DB_ENV *dbenv;
|
||||
u_int32_t lg_max;
|
||||
{
|
||||
DB_LOG *dblp;
|
||||
DB_THREAD_INFO *ip;
|
||||
ENV *env;
|
||||
LOG *lp;
|
||||
int ret;
|
||||
|
||||
env = dbenv->env;
|
||||
ret = 0;
|
||||
|
||||
ENV_NOT_CONFIGURED(env,
|
||||
env->lg_handle, "DB_ENV->set_lg_max", DB_INIT_LOG);
|
||||
|
||||
if (LOGGING_ON(env)) {
|
||||
dblp = env->lg_handle;
|
||||
lp = dblp->reginfo.primary;
|
||||
ENV_ENTER(env, ip);
|
||||
if ((ret = __log_check_sizes(env, lg_max, 0)) == 0) {
|
||||
LOG_SYSTEM_LOCK(env);
|
||||
lp->log_nsize = lg_max;
|
||||
LOG_SYSTEM_UNLOCK(env);
|
||||
}
|
||||
ENV_LEAVE(env, ip);
|
||||
} else
|
||||
dbenv->lg_size = lg_max;
|
||||
|
||||
return (ret);
|
||||
}
|
||||
|
||||
/*
|
||||
* PUBLIC: int __log_get_lg_regionmax __P((DB_ENV *, u_int32_t *));
|
||||
*/
|
||||
int
|
||||
__log_get_lg_regionmax(dbenv, lg_regionmaxp)
|
||||
DB_ENV *dbenv;
|
||||
u_int32_t *lg_regionmaxp;
|
||||
{
|
||||
ENV *env;
|
||||
|
||||
env = dbenv->env;
|
||||
|
||||
ENV_NOT_CONFIGURED(env,
|
||||
env->lg_handle, "DB_ENV->get_lg_regionmax", DB_INIT_LOG);
|
||||
|
||||
if (LOGGING_ON(env)) {
|
||||
/* Cannot be set after open, no lock required to read. */
|
||||
*lg_regionmaxp =
|
||||
((LOG *)env->lg_handle->reginfo.primary)->regionmax;
|
||||
} else
|
||||
*lg_regionmaxp = dbenv->lg_regionmax;
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* __log_set_lg_regionmax --
|
||||
* DB_ENV->set_lg_regionmax.
|
||||
*
|
||||
* PUBLIC: int __log_set_lg_regionmax __P((DB_ENV *, u_int32_t));
|
||||
*/
|
||||
int
|
||||
__log_set_lg_regionmax(dbenv, lg_regionmax)
|
||||
DB_ENV *dbenv;
|
||||
u_int32_t lg_regionmax;
|
||||
{
|
||||
ENV *env;
|
||||
|
||||
env = dbenv->env;
|
||||
|
||||
ENV_ILLEGAL_AFTER_OPEN(env, "DB_ENV->set_lg_regionmax");
|
||||
|
||||
/* Let's not be silly. */
|
||||
if (lg_regionmax != 0 && lg_regionmax < LG_BASE_REGION_SIZE) {
|
||||
__db_errx(env,
|
||||
"log region size must be >= %d", LG_BASE_REGION_SIZE);
|
||||
return (EINVAL);
|
||||
}
|
||||
|
||||
dbenv->lg_regionmax = lg_regionmax;
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* PUBLIC: int __log_get_lg_dir __P((DB_ENV *, const char **));
|
||||
*/
|
||||
int
|
||||
__log_get_lg_dir(dbenv, dirp)
|
||||
DB_ENV *dbenv;
|
||||
const char **dirp;
|
||||
{
|
||||
*dirp = dbenv->db_log_dir;
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* __log_set_lg_dir --
|
||||
* DB_ENV->set_lg_dir.
|
||||
*
|
||||
* PUBLIC: int __log_set_lg_dir __P((DB_ENV *, const char *));
|
||||
*/
|
||||
int
|
||||
__log_set_lg_dir(dbenv, dir)
|
||||
DB_ENV *dbenv;
|
||||
const char *dir;
|
||||
{
|
||||
ENV *env;
|
||||
|
||||
env = dbenv->env;
|
||||
|
||||
if (dbenv->db_log_dir != NULL)
|
||||
__os_free(env, dbenv->db_log_dir);
|
||||
return (__os_strdup(env, dir, &dbenv->db_log_dir));
|
||||
}
|
||||
|
||||
/*
|
||||
* __log_get_flags --
|
||||
* DB_ENV->get_flags.
|
||||
*
|
||||
* PUBLIC: void __log_get_flags __P((DB_ENV *, u_int32_t *));
|
||||
*/
|
||||
void
|
||||
__log_get_flags(dbenv, flagsp)
|
||||
DB_ENV *dbenv;
|
||||
u_int32_t *flagsp;
|
||||
{
|
||||
DB_LOG *dblp;
|
||||
ENV *env;
|
||||
LOG *lp;
|
||||
u_int32_t flags;
|
||||
|
||||
env = dbenv->env;
|
||||
|
||||
if ((dblp = env->lg_handle) == NULL)
|
||||
return;
|
||||
|
||||
lp = dblp->reginfo.primary;
|
||||
|
||||
flags = *flagsp;
|
||||
if (lp->db_log_autoremove)
|
||||
LF_SET(DB_LOG_AUTO_REMOVE);
|
||||
else
|
||||
LF_CLR(DB_LOG_AUTO_REMOVE);
|
||||
if (lp->db_log_inmemory)
|
||||
LF_SET(DB_LOG_IN_MEMORY);
|
||||
else
|
||||
LF_CLR(DB_LOG_IN_MEMORY);
|
||||
*flagsp = flags;
|
||||
}
|
||||
|
||||
/*
|
||||
* __log_set_flags --
|
||||
* DB_ENV->set_flags.
|
||||
*
|
||||
* PUBLIC: void __log_set_flags __P((ENV *, u_int32_t, int));
|
||||
*/
|
||||
void
|
||||
__log_set_flags(env, flags, on)
|
||||
ENV *env;
|
||||
u_int32_t flags;
|
||||
int on;
|
||||
{
|
||||
DB_LOG *dblp;
|
||||
LOG *lp;
|
||||
|
||||
if ((dblp = env->lg_handle) == NULL)
|
||||
return;
|
||||
|
||||
lp = dblp->reginfo.primary;
|
||||
|
||||
if (LF_ISSET(DB_LOG_AUTO_REMOVE))
|
||||
lp->db_log_autoremove = on ? 1 : 0;
|
||||
if (LF_ISSET(DB_LOG_IN_MEMORY))
|
||||
lp->db_log_inmemory = on ? 1 : 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* List of flags we can handle here. DB_LOG_INMEMORY must be
|
||||
* processed before creating the region, leave it out for now.
|
||||
*/
|
||||
#undef OK_FLAGS
|
||||
#define OK_FLAGS \
|
||||
(DB_LOG_AUTO_REMOVE | DB_LOG_DIRECT | \
|
||||
DB_LOG_DSYNC | DB_LOG_IN_MEMORY | DB_LOG_ZERO)
|
||||
#ifndef BREW
|
||||
static
|
||||
#endif
|
||||
const FLAG_MAP LogMap[] = {
|
||||
{ DB_LOG_AUTO_REMOVE, DBLOG_AUTOREMOVE},
|
||||
{ DB_LOG_DIRECT, DBLOG_DIRECT},
|
||||
{ DB_LOG_DSYNC, DBLOG_DSYNC},
|
||||
{ DB_LOG_IN_MEMORY, DBLOG_INMEMORY},
|
||||
{ DB_LOG_ZERO, DBLOG_ZERO}
|
||||
};
|
||||
/*
|
||||
* __log_get_config --
|
||||
* Configure the logging subsystem.
|
||||
*
|
||||
* PUBLIC: int __log_get_config __P((DB_ENV *, u_int32_t, int *));
|
||||
*/
|
||||
int
|
||||
__log_get_config(dbenv, which, onp)
|
||||
DB_ENV *dbenv;
|
||||
u_int32_t which;
|
||||
int *onp;
|
||||
{
|
||||
ENV *env;
|
||||
DB_LOG *dblp;
|
||||
u_int32_t flags;
|
||||
|
||||
env = dbenv->env;
|
||||
if (FLD_ISSET(which, ~OK_FLAGS))
|
||||
return (__db_ferr(env, "DB_ENV->log_get_config", 0));
|
||||
dblp = env->lg_handle;
|
||||
ENV_REQUIRES_CONFIG(env, dblp, "DB_ENV->log_get_config", DB_INIT_LOG);
|
||||
|
||||
__env_fetch_flags(LogMap, sizeof(LogMap), &dblp->flags, &flags);
|
||||
__log_get_flags(dbenv, &flags);
|
||||
if (LF_ISSET(which))
|
||||
*onp = 1;
|
||||
else
|
||||
*onp = 0;
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* __log_set_config --
|
||||
* Configure the logging subsystem.
|
||||
*
|
||||
* PUBLIC: int __log_set_config __P((DB_ENV *, u_int32_t, int));
|
||||
*/
|
||||
int
|
||||
__log_set_config(dbenv, flags, on)
|
||||
DB_ENV *dbenv;
|
||||
u_int32_t flags;
|
||||
int on;
|
||||
{
|
||||
return (__log_set_config_int(dbenv, flags, on, 0));
|
||||
}
|
||||
/*
|
||||
* __log_set_config_int --
|
||||
* Configure the logging subsystem.
|
||||
*
|
||||
* PUBLIC: int __log_set_config_int __P((DB_ENV *, u_int32_t, int, int));
|
||||
*/
|
||||
int
|
||||
__log_set_config_int(dbenv, flags, on, in_open)
|
||||
DB_ENV *dbenv;
|
||||
u_int32_t flags;
|
||||
int on;
|
||||
int in_open;
|
||||
{
|
||||
ENV *env;
|
||||
DB_LOG *dblp;
|
||||
u_int32_t mapped_flags;
|
||||
|
||||
env = dbenv->env;
|
||||
dblp = env->lg_handle;
|
||||
if (FLD_ISSET(flags, ~OK_FLAGS))
|
||||
return (__db_ferr(env, "DB_ENV->log_set_config", 0));
|
||||
ENV_NOT_CONFIGURED(env, dblp, "DB_ENV->log_set_config", DB_INIT_LOG);
|
||||
if (LF_ISSET(DB_LOG_DIRECT) && __os_support_direct_io() == 0) {
|
||||
__db_errx(env,
|
||||
"DB_ENV->log_set_config: direct I/O either not configured or not supported");
|
||||
return (EINVAL);
|
||||
}
|
||||
|
||||
if (LOGGING_ON(env)) {
|
||||
if (!in_open && LF_ISSET(DB_LOG_IN_MEMORY))
|
||||
ENV_ILLEGAL_AFTER_OPEN(env,
|
||||
"DB_ENV->log_set_config: DB_LOG_IN_MEMORY");
|
||||
__log_set_flags(env, flags, on);
|
||||
mapped_flags = 0;
|
||||
__env_map_flags(LogMap, sizeof(LogMap), &flags, &mapped_flags);
|
||||
if (on)
|
||||
F_SET(dblp, mapped_flags);
|
||||
else
|
||||
F_CLR(dblp, mapped_flags);
|
||||
} else {
|
||||
/*
|
||||
* DB_LOG_IN_MEMORY, DB_TXN_NOSYNC and DB_TXN_WRITE_NOSYNC
|
||||
* are mutually incompatible. If we're setting one of them,
|
||||
* clear all current settings.
|
||||
*/
|
||||
if (on && LF_ISSET(DB_LOG_IN_MEMORY))
|
||||
F_CLR(dbenv,
|
||||
DB_ENV_TXN_NOSYNC | DB_ENV_TXN_WRITE_NOSYNC);
|
||||
|
||||
if (on)
|
||||
FLD_SET(dbenv->lg_flags, flags);
|
||||
else
|
||||
FLD_CLR(dbenv->lg_flags, flags);
|
||||
}
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* __log_check_sizes --
|
||||
* Makes sure that the log file size and log buffer size are compatible.
|
||||
*
|
||||
* PUBLIC: int __log_check_sizes __P((ENV *, u_int32_t, u_int32_t));
|
||||
*/
|
||||
int
|
||||
__log_check_sizes(env, lg_max, lg_bsize)
|
||||
ENV *env;
|
||||
u_int32_t lg_max;
|
||||
u_int32_t lg_bsize;
|
||||
{
|
||||
DB_ENV *dbenv;
|
||||
LOG *lp;
|
||||
int inmem;
|
||||
|
||||
dbenv = env->dbenv;
|
||||
|
||||
if (LOGGING_ON(env)) {
|
||||
lp = env->lg_handle->reginfo.primary;
|
||||
inmem = lp->db_log_inmemory;
|
||||
lg_bsize = lp->buffer_size;
|
||||
} else
|
||||
inmem = (FLD_ISSET(dbenv->lg_flags, DB_LOG_IN_MEMORY) != 0);
|
||||
|
||||
if (inmem) {
|
||||
if (lg_bsize == 0)
|
||||
lg_bsize = LG_BSIZE_INMEM;
|
||||
if (lg_max == 0)
|
||||
lg_max = LG_MAX_INMEM;
|
||||
|
||||
if (lg_bsize <= lg_max) {
|
||||
__db_errx(env,
|
||||
"in-memory log buffer must be larger than the log file size");
|
||||
return (EINVAL);
|
||||
}
|
||||
}
|
||||
|
||||
return (0);
|
||||
}
|
||||
Reference in New Issue
Block a user