#include "db_config.h"
#ifndef lint
static const char revid[] = "$Id: db_err.c,v 1.2 2004/03/30 01:21:22 jtownsen Exp $";
#endif
#ifndef NO_SYSTEM_INCLUDES
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#endif
#include "db_int.h"
#include "dbinc/db_page.h"
#include "dbinc/db_am.h"
#include "dbinc/db_shash.h"
#include "dbinc/lock.h"
#include "dbinc/log.h"
#include "dbinc/txn.h"
int
__db_fchk(dbenv, name, flags, ok_flags)
DB_ENV *dbenv;
const char *name;
u_int32_t flags, ok_flags;
{
return (LF_ISSET(~ok_flags) ? __db_ferr(dbenv, name, 0) : 0);
}
int
__db_fcchk(dbenv, name, flags, flag1, flag2)
DB_ENV *dbenv;
const char *name;
u_int32_t flags, flag1, flag2;
{
return (LF_ISSET(flag1) &&
LF_ISSET(flag2) ? __db_ferr(dbenv, name, 1) : 0);
}
int
__db_ferr(dbenv, name, iscombo)
const DB_ENV *dbenv;
const char *name;
int iscombo;
{
__db_err(dbenv, "illegal flag %sspecified to %s",
iscombo ? "combination " : "", name);
return (EINVAL);
}
int
__db_fnl(dbenv, name)
const DB_ENV *dbenv;
const char *name;
{
__db_err(dbenv,
"%s: the DB_DIRTY_READ and DB_RMW flags require locking", name);
return (EINVAL);
}
int
__db_pgerr(dbp, pgno, errval)
DB *dbp;
db_pgno_t pgno;
int errval;
{
__db_err(dbp->dbenv,
"unable to create/retrieve page %lu", (u_long)pgno);
return (__db_panic(dbp->dbenv, errval));
}
int
__db_pgfmt(dbenv, pgno)
DB_ENV *dbenv;
db_pgno_t pgno;
{
__db_err(dbenv, "page %lu: illegal page type or format", (u_long)pgno);
return (__db_panic(dbenv, EINVAL));
}
#ifdef DIAGNOSTIC
void
__db_assert(failedexpr, file, line)
const char *failedexpr, *file;
int line;
{
(void)fprintf(stderr,
"__db_assert: \"%s\" failed: file \"%s\", line %d\n",
failedexpr, file, line);
(void)fflush(stderr);
abort();
}
#endif
int
__db_panic_msg(dbenv)
DB_ENV *dbenv;
{
__db_err(dbenv, "PANIC: fatal region error detected; run recovery");
if (dbenv->db_paniccall != NULL)
dbenv->db_paniccall(dbenv, DB_RUNRECOVERY);
return (DB_RUNRECOVERY);
}
int
__db_panic(dbenv, errval)
DB_ENV *dbenv;
int errval;
{
if (dbenv != NULL) {
PANIC_SET(dbenv, 1);
__db_err(dbenv, "PANIC: %s", db_strerror(errval));
if (dbenv->db_paniccall != NULL)
dbenv->db_paniccall(dbenv, errval);
}
#if defined(DIAGNOSTIC) && !defined(CONFIG_TEST)
abort();
#endif
return (DB_RUNRECOVERY);
}
char *
db_strerror(error)
int error;
{
char *p;
if (error == 0)
return ("Successful return: 0");
if (error > 0) {
if ((p = strerror(error)) != NULL)
return (p);
goto unknown_err;
}
switch (error) {
case DB_DONOTINDEX:
return ("DB_DONOTINDEX: Secondary index callback returns null");
case DB_FILEOPEN:
return ("DB_FILEOPEN: Rename or remove while file is open.");
case DB_KEYEMPTY:
return ("DB_KEYEMPTY: Non-existent key/data pair");
case DB_KEYEXIST:
return ("DB_KEYEXIST: Key/data pair already exists");
case DB_LOCK_DEADLOCK:
return
("DB_LOCK_DEADLOCK: Locker killed to resolve a deadlock");
case DB_LOCK_NOTGRANTED:
return ("DB_LOCK_NOTGRANTED: Lock not granted");
case DB_NOSERVER:
return ("DB_NOSERVER: Fatal error, no RPC server");
case DB_NOSERVER_HOME:
return ("DB_NOSERVER_HOME: Home unrecognized at server");
case DB_NOSERVER_ID:
return ("DB_NOSERVER_ID: Identifier unrecognized at server");
case DB_NOTFOUND:
return ("DB_NOTFOUND: No matching key/data pair found");
case DB_OLD_VERSION:
return ("DB_OLDVERSION: Database requires a version upgrade");
case DB_PAGE_NOTFOUND:
return ("DB_PAGE_NOTFOUND: Requested page not found");
case DB_REP_DUPMASTER:
return ("DB_REP_DUPMASTER: A second master site appeared");
case DB_REP_HANDLE_DEAD:
return ("DB_REP_HANDLE_DEAD: Handle is no longer valid.");
case DB_REP_HOLDELECTION:
return ("DB_REP_HOLDELECTION: Need to hold an election");
case DB_REP_ISPERM:
return ("DB_REP_ISPERM: Permanent record written");
case DB_REP_NEWMASTER:
return ("DB_REP_NEWMASTER: A new master has declared itself");
case DB_REP_NEWSITE:
return ("DB_REP_NEWSITE: A new site has entered the system");
case DB_REP_NOTPERM:
return ("DB_REP_NOTPERM: Permanent log record not written.");
case DB_REP_OUTDATED:
return
("DB_REP_OUTDATED: Insufficient logs on master to recover");
case DB_REP_UNAVAIL:
return ("DB_REP_UNAVAIL: Unable to elect a master");
case DB_RUNRECOVERY:
return ("DB_RUNRECOVERY: Fatal error, run database recovery");
case DB_SECONDARY_BAD:
return
("DB_SECONDARY_BAD: Secondary index inconsistent with primary");
case DB_VERIFY_BAD:
return ("DB_VERIFY_BAD: Database verification failed");
default:
break;
}
unknown_err: {
static char ebuf[40];
(void)snprintf(ebuf, sizeof(ebuf), "Unknown error: %d", error);
return (ebuf);
}
}
void
#ifdef STDC_HEADERS
__db_err(const DB_ENV *dbenv, const char *fmt, ...)
#else
__db_err(dbenv, fmt, va_alist)
const DB_ENV *dbenv;
const char *fmt;
va_dcl
#endif
{
DB_REAL_ERR(dbenv, 0, 0, 0, fmt);
}
#define OVERFLOW_ERROR "internal buffer overflow, process aborted\n"
#ifndef STDERR_FILENO
#define STDERR_FILENO 2
#endif
void
__db_errcall(dbenv, error, error_set, fmt, ap)
const DB_ENV *dbenv;
int error, error_set;
const char *fmt;
va_list ap;
{
char *p;
char errbuf[2048];
p = errbuf;
if (fmt != NULL)
p += vsnprintf(errbuf, sizeof(errbuf), fmt, ap);
if (error_set)
p += snprintf(p,
sizeof(errbuf) - (size_t)(p - errbuf), ": %s",
db_strerror(error));
#ifndef HAVE_VSNPRINTF
if ((size_t)(p - errbuf) > sizeof(errbuf)) {
write(
STDERR_FILENO, OVERFLOW_ERROR, sizeof(OVERFLOW_ERROR) - 1);
abort();
}
#endif
dbenv->db_errcall(dbenv->db_errpfx, errbuf);
}
void
__db_errfile(dbenv, error, error_set, fmt, ap)
const DB_ENV *dbenv;
int error, error_set;
const char *fmt;
va_list ap;
{
FILE *fp;
fp = dbenv == NULL ||
dbenv->db_errfile == NULL ? stderr : dbenv->db_errfile;
if (dbenv != NULL && dbenv->db_errpfx != NULL)
(void)fprintf(fp, "%s: ", dbenv->db_errpfx);
if (fmt != NULL) {
(void)vfprintf(fp, fmt, ap);
if (error_set)
(void)fprintf(fp, ": ");
}
if (error_set)
(void)fprintf(fp, "%s", db_strerror(error));
(void)fprintf(fp, "\n");
(void)fflush(fp);
}
void
#ifdef STDC_HEADERS
__db_logmsg(const DB_ENV *dbenv,
DB_TXN *txnid, const char *opname, u_int32_t flags, const char *fmt, ...)
#else
__db_logmsg(dbenv, txnid, opname, flags, fmt, va_alist)
const DB_ENV *dbenv;
DB_TXN *txnid;
const char *opname, *fmt;
u_int32_t flags;
va_dcl
#endif
{
DBT opdbt, msgdbt;
DB_LSN lsn;
va_list ap;
char __logbuf[2048];
if (!LOGGING_ON(dbenv))
return;
#ifdef STDC_HEADERS
va_start(ap, fmt);
#else
va_start(ap);
#endif
memset(&opdbt, 0, sizeof(opdbt));
opdbt.data = (void *)opname;
opdbt.size = (u_int32_t)(strlen(opname) + 1);
memset(&msgdbt, 0, sizeof(msgdbt));
msgdbt.data = __logbuf;
msgdbt.size = (u_int32_t)vsnprintf(__logbuf, sizeof(__logbuf), fmt, ap);
#ifndef HAVE_VSNPRINTF
if (msgdbt.size > sizeof(__logbuf)) {
write(
STDERR_FILENO, OVERFLOW_ERROR, sizeof(OVERFLOW_ERROR) - 1);
abort();
}
#endif
(void)__db_debug_log(
(DB_ENV *)dbenv, txnid, &lsn, flags, &opdbt, -1, &msgdbt, NULL, 0);
va_end(ap);
}
int
__db_unknown_flag(dbenv, routine, flag)
DB_ENV *dbenv;
char *routine;
u_int32_t flag;
{
__db_err(dbenv, "%s: Unknown flag: 0x%x", routine, (u_int)flag);
DB_ASSERT(0);
return (EINVAL);
}
int
__db_unknown_type(dbenv, routine, type)
DB_ENV *dbenv;
char *routine;
DBTYPE type;
{
__db_err(dbenv, "%s: Unknown db type: 0x%x", routine, (u_int)type);
DB_ASSERT(0);
return (EINVAL);
}
int
__db_check_txn(dbp, txn, assoc_lid, read_op)
DB *dbp;
DB_TXN *txn;
u_int32_t assoc_lid;
int read_op;
{
DB_ENV *dbenv;
dbenv = dbp->dbenv;
if (IS_RECOVERING(dbenv) || F_ISSET(dbp, DB_AM_RECOVER))
return (0);
if (txn == NULL) {
if (!read_op && F_ISSET(dbp, DB_AM_TXN)) {
__db_err(dbenv,
"DB handle previously used in transaction, missing transaction handle");
return (EINVAL);
}
if (dbp->cur_lid >= TXN_MINIMUM)
goto open_err;
} else {
if (dbp->cur_lid >= TXN_MINIMUM && dbp->cur_lid != txn->txnid)
goto open_err;
if (!TXN_ON(dbenv))
return (__db_not_txn_env(dbenv));
if (!F_ISSET(dbp, DB_AM_TXN)) {
__db_err(dbenv,
"Transaction specified for a DB handle opened outside a transaction");
return (EINVAL);
}
}
if (!read_op && dbp->associate_lid != DB_LOCK_INVALIDID &&
txn != NULL && dbp->associate_lid != assoc_lid) {
__db_err(dbenv,
"Operation forbidden while secondary index is being created");
return (EINVAL);
}
return (0);
open_err:
__db_err(dbenv,
"Transaction that opened the DB handle is still active");
return (EINVAL);
}
int
__db_not_txn_env(dbenv)
DB_ENV *dbenv;
{
__db_err(dbenv, "DB environment not configured for transactions");
return (EINVAL);
}
int
__db_rec_toobig(dbenv, data_len, fixed_rec_len)
DB_ENV *dbenv;
u_int32_t data_len, fixed_rec_len;
{
__db_err(dbenv, "%s: length of %lu larger than database's value of %lu",
"Record length error", (u_long)data_len, (u_long)fixed_rec_len);
return (EINVAL);
}
int
__db_rec_repl(dbenv, data_size, data_dlen)
DB_ENV *dbenv;
u_int32_t data_size, data_dlen;
{
__db_err(dbenv,
"%s: replacement length %lu differs from replaced length %lu",
"Record length error", (u_long)data_size, (u_long)data_dlen);
return (EINVAL);
}