Imported from /home/lorry/working-area/delta_berkeleydb/db-6.1.23.tar.gz.HEADdb-6.1.23master

1 files changed, 552 insertions, 84 deletions

diff --git a/src/common/db_err.c b/src/common/db_err.c
index 6edc37b6..7acaa174 100644
--- a/src/common/db_err.c
+++ b/src/common/db_err.c
@@ -1,7 +1,7 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1996, 2012 Oracle and/or its affiliates.  All rights reserved.
+ * Copyright (c) 1996, 2015 Oracle and/or its affiliates.  All rights reserved.
  *
  * $Id$
  */
@@ -18,6 +18,11 @@
 static void __db_msgcall __P((const DB_ENV *, const char *, va_list));
 static void __db_msgfile __P((const DB_ENV *, const char *, va_list));
 
+#if defined(HAVE_ERROR_HISTORY)
+static void __db_thread_once_func __P((void));
+static void __db_deferred_free __P((void *));
+#endif
+
 /*
  * __db_fchk --
  *	General flags checking routine.
@@ -62,6 +67,9 @@ __db_ferr(env, name, iscombo)
 	const char *name;
 	int iscombo;
 {
+	int ret;
+
+	ret = USR_ERR(env, EINVAL);
 	if (iscombo)
 		__db_errx(env, DB_STR_A("0054",
 		    "illegal flag combination specified to %s", "%s"), name);
@@ -69,7 +77,7 @@ __db_ferr(env, name, iscombo)
 		__db_errx(env, DB_STR_A("0055",
 		    "illegal flag specified to %s", "%s"), name);
 
-	return (EINVAL);
+	return (ret);
 }
 
 /*
@@ -145,9 +153,24 @@ __db_assert(env, e, file, line)
 	if (DB_GLOBAL(j_assert) != NULL)
 		DB_GLOBAL(j_assert)(e, file, line);
 	else {
-		__db_errx(env, DB_STR_A("0059",
-		    "assert failure: %s/%d: \"%s\"",
-		    "%s %d %s"), file, line, e);
+		/*
+		 * If a panic has preceded this assertion failure, print that
+		 * message as well -- it might be relevant.
+		 */
+#ifdef HAVE_FAILCHK_BROADCAST
+		if (PANIC_ISSET(env)) {
+			REGENV *renv;
+			renv = (env == NULL || env->reginfo == NULL) ?
+				NULL : env->reginfo->primary;
+			__db_errx(env, DB_STR_A("0242",
+			    "assert failure (%s/%d: %s) after panic %s",
+			    "%s %d %s %s"), file, line, e,
+			    renv == NULL ? "" : renv->failure_symptom);
+		} else
+#endif
+			__db_errx(env, DB_STR_A("0059",
+			    "assert failure: %s/%d: \"%s\"",
+			    "%s %d %s"), file, line, e);
 
 		__os_abort(env);
 		/* NOTREACHED */
@@ -156,8 +179,49 @@ __db_assert(env, e, file, line)
 #endif
 
 /*
+ * __env_panic_event -
+ *	Notify the application of a db_register, failchk, or generic panic.
+ *
+ * PUBLIC: void __env_panic_event __P((ENV *, int));
+ */
+void
+__env_panic_event(env, errval)
+	ENV *env;
+	int errval;
+{
+	DB_ENV *dbenv;
+	REGENV *renv;
+	u_int32_t event;
+	void *info;
+	DB_EVENT_FAILCHK_INFO failinfo;
+
+	dbenv = env->dbenv;
+	info = &errval;
+	if (dbenv->db_paniccall != NULL)	/* Deprecated */
+		dbenv->db_paniccall(dbenv, errval);
+	/*
+	 * We check for DB_EVENT_FAILCHK and DB_EVENT_REG_PANIC first because
+	 * they are not set by themselves. If one of those is set, it means that
+	 * this panic is somewhat an expected consequence of a previous failure.
+	 */
+	renv = (env->reginfo == NULL) ? NULL : env->reginfo->primary;
+	if (renv != NULL && renv->failure_panic) {
+		event = DB_EVENT_FAILCHK_PANIC;
+		failinfo.error = errval;
+		(void)strncpy(failinfo.symptom,
+		    renv->failure_symptom, sizeof(failinfo.symptom));
+		failinfo.symptom[sizeof(failinfo.symptom) - 1] = '\0';
+		info = &failinfo;
+	} else if (renv != NULL && renv->reg_panic)
+		event = DB_EVENT_REG_PANIC;
+	else
+		event = DB_EVENT_PANIC;
+	DB_EVENT(env, event, info);
+}
+
+/*
  * __env_panic_msg --
- *	Just report that someone else paniced.
+ *	Report that we noticed a panic which had been set somewhere else.
  *
  * PUBLIC: int __env_panic_msg __P((ENV *));
  */
@@ -165,28 +229,16 @@ int
 __env_panic_msg(env)
 	ENV *env;
 {
-	DB_ENV *dbenv;
 	int ret;
 
-	dbenv = env->dbenv;
-
 	ret = DB_RUNRECOVERY;
+	/* Make a note saying where this panic was detected. */
+	(void)USR_ERR(env, ret);
 
 	__db_errx(env, DB_STR("0060",
 	    "PANIC: fatal region error detected; run recovery"));
 
-	if (dbenv->db_paniccall != NULL)		/* Deprecated */
-		dbenv->db_paniccall(dbenv, ret);
-
-	/* Must check for DB_EVENT_REG_PANIC panic first because it is never
-	 * set by itself.  If set, it means panic came from DB_REGISTER code
-	 * only, otherwise it could be from many possible places in the code.
-	 */
-	if ((env->reginfo != NULL) &&
-	    (((REGENV *)env->reginfo->primary)->reg_panic))
-		DB_EVENT(env, DB_EVENT_REG_PANIC, &ret);
-	else
-		DB_EVENT(env, DB_EVENT_PANIC, &ret);
+	__env_panic_event(env, ret);
 
 	return (ret);
 }
@@ -202,28 +254,13 @@ __env_panic(env, errval)
 	ENV *env;
 	int errval;
 {
-	DB_ENV *dbenv;
-
-	dbenv = env->dbenv;
-
 	if (env != NULL) {
 		__env_panic_set(env, 1);
 
-		__db_err(env, errval, DB_STR("0061", "PANIC"));
+		if (errval != DB_RUNRECOVERY)
+			__db_err(env, errval, DB_STR("0061", "PANIC"));
 
-		if (dbenv->db_paniccall != NULL)	/* Deprecated */
-			dbenv->db_paniccall(dbenv, errval);
-
-		/* Must check for DB_EVENT_REG_PANIC first because it is never
-		 * set by itself.  If set, it means panic came from DB_REGISTER
-		 * code only, otherwise it could be from many possible places
-		 * in the code.
-		 */
-		if ((env->reginfo != NULL) &&
-		    (((REGENV *)env->reginfo->primary)->reg_panic))
-			DB_EVENT(env, DB_EVENT_REG_PANIC, &errval);
-		else
-			DB_EVENT(env, DB_EVENT_PANIC, &errval);
+		__env_panic_event(env, errval);
 	}
 
 #if defined(DIAGNOSTIC) && !defined(CONFIG_TEST)
@@ -302,6 +339,9 @@ db_strerror(error)
 	case DB_LOG_VERIFY_BAD:
 		return (DB_STR("0071",
 		    "DB_LOG_VERIFY_BAD: Log verification failed"));
+	case DB_META_CHKSUM_FAIL:
+		return (DB_STR("0247",
+	    "DB_META_CHKSUM_FAIL: Checksum mismatch detected on a database metadata page"));
 	case DB_NOSERVER:
 		return (DB_STR("0072",
     "DB_NOSERVER: No message dispatch call-back function has been configured"));
@@ -419,18 +459,21 @@ __db_syserr(env, error, fmt, va_alist)
 	DB_ENV *dbenv;
 
 	dbenv = env == NULL ? NULL : env->dbenv;
+	if (env != NULL)
+		(void)USR_ERR(env, error);
 
 	/*
 	 * The same as DB->err, except we don't default to writing to stderr
 	 * after any output channel has been configured, and we use a system-
 	 * specific function to translate errors to strings.
 	 */
-	DB_REAL_ERR(dbenv, error, DB_ERROR_SYSTEM, 0, fmt);
+	DB_REAL_ERR(dbenv,
+	    error, error == 0 ? DB_ERROR_NOT_SET : DB_ERROR_SYSTEM, 0, fmt);
 }
 
 /*
  * __db_err --
- *	Standard error routine.
+ *	Standard error routine with an error code.
  *
  * PUBLIC: void __db_err __P((const ENV *, int, const char *, ...))
  * PUBLIC:    __attribute__ ((__format__ (__printf__, 3, 4)));
@@ -450,6 +493,10 @@ __db_err(env, error, fmt, va_alist)
 
 	dbenv = env == NULL ? NULL : env->dbenv;
 
+	/* (If no deferred messages yet, at least?) add this calls' info.
+	(void)USR_ERR(env, error);
+	*/
+
 	/*
 	 * The same as DB->err, except we don't default to writing to stderr
 	 * once an output channel has been configured.
@@ -459,7 +506,7 @@ __db_err(env, error, fmt, va_alist)
 
 /*
  * __db_errx --
- *	Standard error routine.
+ *	Standard error routine without any error code.
  *
  * PUBLIC: void __db_errx __P((const ENV *, const char *, ...))
  * PUBLIC:    __attribute__ ((__format__ (__printf__, 2, 3)));
@@ -500,25 +547,54 @@ __db_errcall(dbenv, error, error_set, fmt, ap)
 	const char *fmt;
 	va_list ap;
 {
-	char *p;
-	char buf[2048];		/* !!!: END OF THE STACK DON'T TRUST SPRINTF. */
-	char sysbuf[1024];	/* !!!: END OF THE STACK DON'T TRUST SPRINTF. */
+	char *end, *p;
+	char buf[2048 + DB_ERROR_HISTORY_SIZE];
+	char sysbuf[1024];
+#ifdef HAVE_ERROR_HISTORY
+	DB_MSGBUF *deferred_mb;
+	ptrdiff_t len;
+#endif
 
 	p = buf;
+	/* Reserve 1 byte at the end for '\0'. */
+	end = buf + sizeof(buf) - 1;
 	if (fmt != NULL)
 		p += vsnprintf(buf, sizeof(buf), fmt, ap);
+
 	if (error_set != DB_ERROR_NOT_SET)
-		p += snprintf(p,
-		    sizeof(buf) - (size_t)(p - buf), ": %s",
+		p += snprintf(p, (size_t)(end - p), ": %s",
 		    error_set == DB_ERROR_SET ? db_strerror(error) :
 		    __os_strerror(error, sysbuf, sizeof(sysbuf)));
 
+#ifdef HAVE_ERROR_HISTORY
+	/*
+	 * Append any messages (e.g., diagnostics) stashed away in the deferred
+	 * msgbuf. Strncpy() can't be trusted to append '\0', do it "manually".
+	 */
+	if ((deferred_mb = __db_deferred_get()) != NULL &&
+	    (len = deferred_mb->cur - deferred_mb->buf) != 0) {
+		p += snprintf(p,
+		    (size_t)(end - p), "\nErrors during this API call:");
+		if (len > (end - p))
+			len = end - p;
+		if (len != 0) {
+			memmove(p, deferred_mb->buf, (size_t)len);
+			p[len] = '\0';
+		}
+	}
+#endif
+
 	dbenv->db_errcall(dbenv, dbenv->db_errpfx, buf);
 }
 
 /*
  * __db_errfile --
- *	Do the error message work for FILE *s.
+ *	Do the error message work for FILE *s. Combine the messages into a
+ *	single fprintf() call, to avoid interspersed output when there are
+ *	multiple active threads.
+ *
+ *	Display a ": " after the dbenv prefix, if it has one.
+ *	Display a ": " before the error message string, if it error was set.
  *
  * PUBLIC: void __db_errfile
  * PUBLIC:    __P((const DB_ENV *, int, db_error_set_t, const char *, va_list));
@@ -532,29 +608,62 @@ __db_errfile(dbenv, error, error_set, fmt, ap)
 	va_list ap;
 {
 	FILE *fp;
-	int need_sep;
-	char sysbuf[1024];	/* !!!: END OF THE STACK DON'T TRUST SPRINTF. */
+	char *defintro, *defmsgs, *error_str, *prefix, *sep1, *sep2;
+	char sysbuf[200];
+	char prefix_buf[200];
+	char full_fmt[4096];
+#ifdef HAVE_ERROR_HISTORY
+	DB_MSGBUF *deferred_mb;
+	size_t room;
+#endif
 
+	prefix = sep1 = sep2 = error_str = "";
 	fp = dbenv == NULL ||
 	    dbenv->db_errfile == NULL ? stderr : dbenv->db_errfile;
-	need_sep = 0;
+	if (fmt == NULL)
+		fmt = "";
 
 	if (dbenv != NULL && dbenv->db_errpfx != NULL) {
-		(void)fprintf(fp, "%s", dbenv->db_errpfx);
-		need_sep = 1;
+		prefix = __db_fmt_quote(prefix_buf,
+		    sizeof(prefix_buf), dbenv->db_errpfx);
+		sep1 = ": ";
 	}
-	if (fmt != NULL && fmt[0] != '\0') {
-		if (need_sep)
-			(void)fprintf(fp, ": ");
-		need_sep = 1;
-		(void)vfprintf(fp, fmt, ap);
+	switch (error_set) {
+	case DB_ERROR_NOT_SET:
+		break;
+	case DB_ERROR_SET:
+		error_str = db_strerror(error);
+		sep2 = ": ";
+		break;
+	case DB_ERROR_SYSTEM:
+		error_str = __os_strerror(error, sysbuf, sizeof(sysbuf));
+		sep2 = ": ";
+		break;
 	}
-	if (error_set != DB_ERROR_NOT_SET)
-		(void)fprintf(fp, "%s%s",
-		    need_sep ? ": " : "",
-		    error_set == DB_ERROR_SET ? db_strerror(error) :
-		    __os_strerror(error, sysbuf, sizeof(sysbuf)));
-	(void)fprintf(fp, "\n");
+#ifdef HAVE_ERROR_HISTORY
+	if ((deferred_mb = __db_deferred_get()) != NULL &&
+	    deferred_mb->cur != deferred_mb->buf) {
+		defmsgs =
+		    __db_fmt_quote(deferred_mb->buf, deferred_mb->len, NULL);
+		defintro = "\nErrors during this API call:";
+		/*
+		 * If there are more deferred messages than will be displayed
+		 * change the introductory message to warn of the truncation.
+		 */
+		room = sizeof(full_fmt) - (strlen(sep1) +
+		    strlen(fmt) + strlen(sep2) + strlen(error_str));
+		if (deferred_mb->len + strlen(defintro) > room) {
+			defintro =
+			    "\nFirst recorded errors during this API call:";
+			memmove(defmsgs + room - 4, "...\n", 4);
+		}
+
+	} else
+#endif
+		defmsgs = defintro = "";
+	(void)snprintf(full_fmt, sizeof(full_fmt), "%s%s%s%s%s%s%s\n", prefix,
+	    sep1, fmt, sep2, error_str, defintro, defmsgs);
+	(void)vfprintf(fp, full_fmt, ap);
 	(void)fflush(fp);
 }
 
@@ -562,15 +671,15 @@ __db_errfile(dbenv, error, error_set, fmt, ap)
  * __db_msgadd --
  *	Aggregate a set of strings into a buffer for the callback API.
  *
- * PUBLIC: void __db_msgadd __P((ENV *, DB_MSGBUF *, const char *, ...))
+ * PUBLIC: void __db_msgadd __P((const ENV *, DB_MSGBUF *, const char *, ...))
  * PUBLIC:    __attribute__ ((__format__ (__printf__, 3, 4)));
  */
 void
 #ifdef STDC_HEADERS
-__db_msgadd(ENV *env, DB_MSGBUF *mbp, const char *fmt, ...)
+__db_msgadd(const ENV *env, DB_MSGBUF *mbp, const char *fmt, ...)
 #else
 __db_msgadd(env, mbp, fmt, va_alist)
-	ENV *env;
+	const ENV *env;
 	DB_MSGBUF *mbp;
 	const char *fmt;
 	va_dcl
@@ -592,17 +701,17 @@ __db_msgadd(env, mbp, fmt, va_alist)
  *	Aggregate a set of strings into a buffer for the callback API.
  *
  * PUBLIC: void __db_msgadd_ap
- * PUBLIC:     __P((ENV *, DB_MSGBUF *, const char *, va_list));
+ * PUBLIC:     __P((const ENV *, DB_MSGBUF *, const char *, va_list));
  */
 void
 __db_msgadd_ap(env, mbp, fmt, ap)
-	ENV *env;
+	const ENV *env;
 	DB_MSGBUF *mbp;
 	const char *fmt;
 	va_list ap;
 {
-	size_t len, olen;
-	char buf[2048];		/* !!!: END OF THE STACK DON'T TRUST SPRINTF. */
+	size_t len, nlen, olen;
+	char buf[2048];
 
 	len = (size_t)vsnprintf(buf, sizeof(buf), fmt, ap);
 
@@ -613,9 +722,16 @@ __db_msgadd_ap(env, mbp, fmt, ap)
 	 */
 	olen = (size_t)(mbp->cur - mbp->buf);
 	if (olen + len >= mbp->len) {
-		if (__os_realloc(env, mbp->len + len + 256, &mbp->buf))
+		/* Don't write too much for preallocated DB_MSGBUFs. */
+		if (F_ISSET(mbp, DB_MSGBUF_PREALLOCATED)) {
+			memset(mbp->cur, '*', mbp->len - olen);
+			mbp->cur = mbp->buf + mbp->len;
 			return;
-		mbp->len += (len + 256);
+		}
+		nlen = mbp->len + len + (env == NULL ? 8192 : 256);
+		if (__os_realloc(env, nlen, &mbp->buf))
+			return;
+		mbp->len = nlen;
 		mbp->cur = mbp->buf + olen;
 	}
 
@@ -648,6 +764,42 @@ __db_msg(env, fmt, va_alist)
 }
 
 /*
+ * __db_debug_msg --
+ *	Save a message to be displayed only if this API call returns an error.
+ *	The message is discarded if this API call succeeds.
+ *
+ * PUBLIC: void __db_debug_msg __P((const ENV *, const char *, ...));
+ */
+void
+#ifdef STDC_HEADERS
+__db_debug_msg(const ENV *env, const char *fmt, ...)
+#else
+__db_debug_msg(env, fmt, va_alist)
+	const ENV *env;
+	const char *fmt;
+	va_dcl
+#endif
+{
+#ifdef HAVE_ERROR_HISTORY
+	DB_MSGBUF *mb;
+	va_list ap;
+
+	if (env == NULL || (mb = __db_deferred_get()) == NULL)
+		return;
+
+#ifdef STDC_HEADERS
+	va_start(ap, fmt);
+#else
+	va_start(ap);
+#endif
+	__db_msgadd_ap(env, mb, fmt, ap);
+	va_end(ap);
+#endif
+	COMPQUIET(env, NULL);
+	COMPQUIET(fmt, NULL);
+}
+
+/*
  * __db_repmsg --
  *	Replication system message routine.
  *
@@ -665,7 +817,7 @@ __db_repmsg(env, fmt, va_alist)
 #endif
 {
 	va_list ap;
-	char buf[2048];		/* !!!: END OF THE STACK DON'T TRUST SPRINTF. */
+	char buf[2048];
 
 #ifdef STDC_HEADERS
 	va_start(ap, fmt);
@@ -679,7 +831,7 @@ __db_repmsg(env, fmt, va_alist)
 
 /*
  * __db_msgcall --
- *	Do the message work for callback functions.
+ *	Do the message work for callback functions in DB_REAL_MSG().
  */
 static void
 __db_msgcall(dbenv, fmt, ap)
@@ -687,16 +839,15 @@ __db_msgcall(dbenv, fmt, ap)
 	const char *fmt;
 	va_list ap;
 {
-	char buf[2048];		/* !!!: END OF THE STACK DON'T TRUST SPRINTF. */
+	char buf[2048];
 
 	(void)vsnprintf(buf, sizeof(buf), fmt, ap);
-
 	dbenv->db_msgcall(dbenv, buf);
 }
 
 /*
  * __db_msgfile --
- *	Do the message work for FILE *s.
+ *	Do the message work for FILE *s in DB_REAL_MSG().
  */
 static void
 __db_msgfile(dbenv, fmt, ap)
@@ -805,6 +956,13 @@ __db_check_txn(dbp, txn, assoc_locker, read_op)
 	if (IS_RECOVERING(env) || F_ISSET(dbp, DB_AM_RECOVER))
 		return (0);
 
+	if (txn != NULL && dbp->blob_threshold &&
+	    F_ISSET(txn, (TXN_READ_UNCOMMITTED | TXN_SNAPSHOT))) {
+	    __db_errx(env, DB_STR("0237",
+"Blob enabled databases do not support DB_READ_UNCOMMITTED and TXN_SNAPSHOT"));
+		return (EINVAL);
+	}
+
 	/*
 	 * Check for common transaction errors:
 	 *	an operation on a handle whose open commit hasn't completed.
@@ -1095,9 +1253,9 @@ __db_space_err(dbp)
 
 /*
  * __db_failed --
- *	Common failed thread  message.
+ *	Common failed thread message, e.g., after it is seen to have crashed.
  *
- * PUBLIC: int __db_failed __P((const ENV *,
+  PUBLIC: int __db_failed __P((const ENV *,
  * PUBLIC:      const char *, pid_t, db_threadid_t));
  */
 int
@@ -1108,11 +1266,321 @@ __db_failed(env, msg, pid, tid)
 	db_threadid_t tid;
 {
 	DB_ENV *dbenv;
-	char buf[DB_THREADID_STRLEN];
+	int ret;
+	char tidstr[DB_THREADID_STRLEN], failmsg[DB_FAILURE_SYMPTOM_SIZE];
 
 	dbenv = env->dbenv;
+	(void)dbenv->thread_id_string(dbenv, pid, tid, tidstr);
+	ret = USR_ERR(env, DB_RUNRECOVERY);
+	snprintf(failmsg, sizeof(failmsg), DB_STR_A("0113",
+	    "Thread/process %s failed: %s", "%s %s"), tidstr, msg);
+	(void)__env_failure_remember(env, failmsg);
+	__db_errx(env, "%s", failmsg);
+	return (ret);
+}
 
-	__db_errx(env, DB_STR_A("0113", "Thread/process %s failed: %s",
-	    "%s %s"), dbenv->thread_id_string(dbenv, pid, tid, buf),  msg);
-	return (DB_RUNRECOVERY);
+/*
+ * __env_failure_remember --
+ *	If this failure of a process in the environment is about to set panic
+ *	for the first time, record that a crashed thread was thw culprit.
+ *	Do nothing if panic has already been set. There are no mutexes here;
+ *	in order to avoid hanging on any crashed threads.
+ *
+ * PUBLIC: int __env_failure_remember __P((const ENV *, const char *));
+ */
+int
+__env_failure_remember(env, reason)
+	const ENV *env;
+	const char *reason;
+{
+	REGENV *renv;
+
+	renv = env->reginfo->primary;
+	if (renv == NULL || renv->panic || renv->failure_panic)
+		return (0);
+	renv->failure_panic = 1;
+	if (renv->failure_symptom[0] == '\0') {
+		(void)strncpy(renv->failure_symptom,
+		    reason, sizeof(renv->failure_symptom));
+		renv->failure_symptom[sizeof(renv->failure_symptom) - 1] = '\0';
+	}
+	return (0);
+}
+
+#if defined(HAVE_ERROR_HISTORY)
+/*
+ * __db_deferred_free --
+ *	Pthread_exit() calls this to release DB_GLOBAL(msgs_key)'s
+ *	thread-local storage.
+ */
+static void
+__db_deferred_free(void *p)
+{
+	DB_MSGBUF *mb;
+
+	if ((mb = p) != NULL) {
+		(void)pthread_setspecific(DB_GLOBAL(msgs_key), NULL);
+		if (mb->buf != NULL)
+			__os_free(NULL, mb->buf);
+		free(mb);
+	}
+}
+
+/*
+ * __db_thread_once_func --
+ *	The pthread_once() functions to initialize thread local storage.
+ */
+static void
+__db_thread_once_func()
+{
+	(void)pthread_key_create(&DB_GLOBAL(msgs_key), __db_deferred_free);
+}
+
+/*
+ * __db_thread_init --
+ *	Initialization hook to be called at least once per process, before
+ *	deferring any messages.
+ *
+ * PUBLIC: #ifdef HAVE_ERROR_HISTORY
+ * PUBLIC: void __db_thread_init __P((void));
+ * PUBLIC: #endif
+ */
+void
+__db_thread_init()
+{
+	/*
+	 * Assign the thread-local storage identifier. Tell thread exit to clean
+	 * up withl __db_deferred_free().
+	 */
+	(void)pthread_once(&DB_GLOBAL(thread_once), __db_thread_once_func);
+}
+
+/*
+ * __db_diags --
+ *
+ *	Save the context which triggers the "first notice" of an error code;
+ *	i.e., its creation. It doesn't touch anything when err == 0.
+ *
+ * PUBLIC: #ifdef HAVE_ERROR_HISTORY
+ * PUBLIC: int __db_diags __P((const ENV *, int));
+ * PUBLIC: #endif
+ */
+ int
+__db_diags(env, err)
+	const ENV *env;
+	int err;
+{
+	DB_MSGBUF *mb;
+
+	if (err != 0 && (mb = __db_deferred_get()) != NULL)
+		(void)__db_remember_context(env, mb, err);
+	return (err);
+}
+
+/*
+ * __db_deferred_get --
+ *	Get this thread's deferred DB_MSGBUF, possibly allocating it.
+ *
+ * PUBLIC: #ifdef HAVE_ERROR_HISTORY
+ * PUBLIC: DB_MSGBUF *__db_deferred_get __P((void));
+ * PUBLIC: #endif
+ */
+DB_MSGBUF *
+__db_deferred_get()
+{
+	DB_MSGBUF *mb;
+
+	if ((mb = pthread_getspecific(DB_GLOBAL(msgs_key))) == NULL) {
+		if ((mb = calloc(1, sizeof(*mb))) != NULL)
+			if (pthread_setspecific(DB_GLOBAL(msgs_key), mb) != 0) {
+				/* Nothing else is safe do on an error. */
+				free(mb);
+				mb = NULL;
+			}
+	}
+	return (mb);
+}
+
+/*
+ * __db_deferred_discard --
+ *	Discard any saved-up deferred messages, at e.g. the end of the command.
+ *
+ * PUBLIC: #ifdef HAVE_ERROR_HISTORY
+ * PUBLIC: void __db_deferred_discard __P((void));
+ * PUBLIC: #endif
+ */
+void
+__db_deferred_discard()
+{
+	DB_MSGBUF *mb;
+
+	if ((mb = pthread_getspecific(DB_GLOBAL(msgs_key))) != NULL)
+		mb->cur = mb->buf;
+}
+
+/*
+ * __db_remember_context
+ *	Save the context which triggers the "first notice" of an error code;
+ *	i.e., its creation. Include the time, thread, recent portion of the
+ *	stack, and the error number. Add replication info too?
+ *
+ *	Return the error number passed in, or 0?
+ *
+ * PUBLIC: #ifdef HAVE_ERROR_HISTORY
+ * PUBLIC: int __db_remember_context __P((const ENV *, DB_MSGBUF *, int));
+ * PUBLIC: #endif
+ */
+ int
+ __db_remember_context(env, mb, err)
+	const ENV *env;
+	DB_MSGBUF *mb;
+	int err;
+{
+	DB_ENV *dbenv;
+	LOG *lp;
+	db_timespec now;
+	pid_t pid;
+	db_threadid_t tid;
+	char threadid[DB_THREADID_STRLEN], timestr[CTIME_BUFLEN];
+
+	/* Limit the amount of context messges which are remembered. */
+	if (mb->len >= DB_ERROR_HISTORY_SIZE)
+		return (0);
+
+	lp = NULL;
+	if (env == NULL) {
+		dbenv = NULL;
+		threadid[0] = '\0';
+	} else {
+		dbenv = env->dbenv;
+		dbenv->thread_id(dbenv, &pid, &tid);
+		(void)dbenv->thread_id_string(dbenv, pid, tid, threadid);
+		if (LOGGING_ON(env) && !IS_RECOVERING(env))
+			lp = env->lg_handle->reginfo.primary;
+	}
+
+	__os_gettime(env, &now, 0);
+	(void)__db_ctimespec(&now, timestr);
+	__db_msgadd(env, mb, "\n[%s][%s] %s",
+	    timestr, threadid, db_strerror(err));
+	if (lp != NULL)
+		__db_msgadd(env, mb, " lsn [%lu][%lu]",
+		    (u_long)lp->lsn.file, (u_long)lp->lsn.offset);
+
+#if defined(HAVE_BACKTRACE) && defined(HAVE_BACKTRACE_SYMBOLS)
+	/*
+	 * Add many frames of stack trace to the record, skipping the first two
+	 * frames: __os_stack_msgadd() and __db_remember_context().
+	 */
+	__db_msgadd(env, mb, " from\n");
+	__os_stack_msgadd(env, mb, 15, 2, NULL);
+#endif
+
+	return (0);
+}
+#endif
+
+/*
+ * __db_ctimespec --
+ *	Format a timespec in microseconds, similar to a terse __os_ctime(),
+ *	storing the results into a CTIME_BUFLEN sized buffer.
+ *	The result format depends on the availability of localtime, etc
+ *		MM/DD HH:MM:SS.uuuuuu	if strftime is available, or
+ *		Jan DD HH:MM:SS.uuuuuu	if only __os_ctime() is available.
+ *	Both are small enough to use __os_ctime() sized buffer, e.g. 26.
+ *	The other fields (year, day-of-week, ...) are intentionally removed.
+ *
+ * PUBLIC: char * __db_ctimespec __P((const db_timespec *, char *));
+ */
+char *
+__db_ctimespec(timespec, buf)
+	const db_timespec *timespec;
+	char *buf;
+{
+	char *d, date[CTIME_BUFLEN];
+#ifdef HAVE_STRFTIME
+	struct tm *tm_p;
+#ifdef HAVE_LOCALTIME_R
+	struct tm tm;
+#endif
+#endif
+
+	/* Print the time readably if possible; else print seconds. */
+#ifdef HAVE_STRFTIME
+#ifdef HAVE_LOCALTIME_R
+	tm_p = localtime_r(&timespec->tv_sec, &tm);
+#else
+	tm_p = localtime(&timespec->tv_sec);
+#endif
+	if (tm_p != NULL) {
+		d = date;
+		(void)strftime(d, sizeof(date), DB_GLOBAL(time_format), tm_p);
+	}
+	else
+#endif
+	{
+		/* Trim off the leading day-of-week; then the trailing year. */
+		d = __os_ctime(&timespec->tv_sec, date) + 4;
+		d[sizeof("Jan 01 00:00:00")] = '\0';
+	}
+	(void)snprintf(buf, CTIME_BUFLEN,
+	    "%s.%06lu", d, (u_long)(timespec->tv_nsec / NS_PER_US));
+	buf[CTIME_BUFLEN - 1] = '\0';	/* In case of buggy snprintf. */
+	return (buf);
+}
+
+/*
+ * __db_fmt_quote --
+ *	Copy a printf format string, quoting (doubling) each '%' along the way.
+ *	Use this when inserting a user-defined string into a *printf format.
+ *	If the src parameter is NULL, then quote in-place, shifting the
+ *	rest of the string down by one character for each quote.
+ *
+ * PUBLIC: char *__db_fmt_quote __P((char *, size_t, const char *));
+ */
+char *
+__db_fmt_quote(dest, destsize, src)
+	char *dest;
+	size_t destsize;
+	const char *src;
+{
+	char *d, *end;
+	const char *s;
+	size_t len;
+
+	/* Stop early enough so that dest always has room for a '\0'. */
+	end = dest + destsize - 1;
+	if (src == NULL) {
+		d = dest;
+		while ((d = strchr(d, '%')) != NULL && d[1] != '\0') {
+			/*
+			 * Shift the rest of the string by one byte to make
+			 * space for another '%'. By starting at d and adding 1
+			 * to the length, we double the '%' while copying the
+			 * string and its terminating '\0'.
+			 */
+			len = strlen(d) + 1;
+			memmove(d + 1, d, len);
+			/*
+			 * We're done if the string now is larger than the
+			 * reserved size; else advance over both '%'s.
+			 */
+			if (d + len >= end) {
+				DB_ASSERT(NULL, d + len == end);
+				*end = '\0';
+				break;
+			}
+			d += 2;
+		}
+	} else {
+		for (s = src, d = dest; *s != '\0' && d < end; d++, s++)
+			if ((*d = *s) == '%') {
+				/* Discard a % at the end of the string. */
+				if (s[1] == '\0')
+					break;
+				*++d = '%';
+			}
+		*d = '\0';
+	}
+	return (dest);
 }