extra/db: upgrade to 4.7

6 files changed, 470 insertions, 112 deletions

diff --git a/extra/db/APKBUILD b/extra/db/APKBUILD
index 35ee659c0..2efe80293 100644
--- a/extra/db/APKBUILD
+++ b/extra/db/APKBUILD
@@ -1,20 +1,20 @@
 # Maintainer: Natanael Copa <ncopa@alpinelinux.org>
 pkgname=db
-
-# openldap does not build against 4.7.x so we keep an old version here for now.
-pkgver=4.5.20.2
+pkgver=4.7.25.3
 _ver=${pkgver%.*}
-pkgrel=2
-pkgdesc="The Berkeley DB embedded database system 4.5"
+pkgrel=0
+pkgdesc="The Berkeley DB embedded database system 4.7"
 url="http://www.oracle.com/technology/software/products/berkeley-db/index.html"
 license="custom"
 depends="uclibc"
+makedepends="g++"
 subpackages="$pkgname-dev $pkgname-doc"
 # Patches were found here:
-# http://www.oracle.com/technology/products/berkeley-db/db/update/4.6.20/patch.4.6.20.html
+# http://www.oracle.com/technology/products/berkeley-db/db/update/4.7.25/patch.4.7.25.html
 source="http://download-uk.oracle.com/berkeley-db/db-$_ver.tar.gz
 	patch.$_ver.1
 	patch.$_ver.2
+	patch.$_ver.3
 	"
 
 build () { 
@@ -41,6 +41,7 @@ build () {
 		"$pkgdir"/usr/share/licenses/$pkgname/LICENSE
 }
 
-md5sums="b0f1c777708cb8e9d37fb47e7ed3312d  db-4.5.20.tar.gz
-a571e239b9041d7990df287cbc59ad6f  patch.4.5.20.1
-b7a7086a067ba116f5a8464362c9a9a7  patch.4.5.20.2"
+md5sums="ec2b87e833779681a0c3a814aa71359e  db-4.7.25.tar.gz
+5fdf101259e5164dea1c8c86214fde38  patch.4.7.25.1
+bd410a11c71fee52fddb6aa2d8d4f80c  patch.4.7.25.2
+6fcd69f64f5b34bfe8f0a63cc2e402c1  patch.4.7.25.3"
diff --git a/extra/db/patch.4.5.20.1 b/extra/db/patch.4.5.20.1
deleted file mode 100644
index 370ac3e7d..000000000
--- a/extra/db/patch.4.5.20.1
+++ /dev/null
@@ -1,37 +0,0 @@
-*** sequence/sequence.c.orig	27 Sep 2006 14:56:17 -0000	12.39
---- sequence/sequence.c	26 Oct 2006 07:36:05 -0000
-***************
-*** 228,233 ****
---- 228,236 ----
-  	seq->seq_data.ulen = seq->seq_data.size = sizeof(seq->seq_record);
-  	seq->seq_rp = &seq->seq_record;
-  
-+ 	if ((ret = __dbt_usercopy(dbenv, keyp)) != 0)
-+ 		goto err;
-+ 
-  	memset(&seq->seq_key, 0, sizeof(DBT));
-  	if ((ret = __os_malloc(dbenv, keyp->size, &seq->seq_key.data)) != 0)
-  		goto err;
-***************
-*** 365,370 ****
---- 368,374 ----
-  		ret = t_ret;
-  
-  	ENV_LEAVE(dbenv, ip);
-+ 	__dbt_userfree(dbenv, keyp, NULL, NULL);
-  	return (ret);
-  }
-  
-***************
-*** 764,769 ****
---- 768,777 ----
-  	DBT *key;
-  {
-  	SEQ_ILLEGAL_BEFORE_OPEN(seq, "DB_SEQUENCE->get_key");
-+ 
-+ 	if (F_ISSET(key, DB_DBT_USERCOPY))
-+ 		return (__db_retcopy(seq->seq_dbp->dbenv, key,
-+ 		    seq->seq_key.data, seq->seq_key.size, NULL, 0));
-  
-  	key->data = seq->seq_key.data;
-  	key->size = key->ulen = seq->seq_key.size;
diff --git a/extra/db/patch.4.5.20.2 b/extra/db/patch.4.5.20.2
deleted file mode 100644
index fe49c4648..000000000
--- a/extra/db/patch.4.5.20.2
+++ /dev/null
@@ -1,66 +0,0 @@
-*** rep/rep_method.c.orig	Fri Oct 20 08:34:06 2006
---- rep/rep_method.c	Fri Oct 27 12:09:04 2006
-***************
-*** 526,535 ****
-  		 * will allow the client to either perform recovery or
-  		 * simply join in.
-  		 */
-! 		if (announce)
-  			(void)__rep_send_message(dbenv,
-  			    DB_EID_BROADCAST, REP_NEWCLIENT, NULL, dbt, 0, 0);
-! 		else
-  			(void)__rep_send_message(dbenv,
-  			    DB_EID_BROADCAST, REP_ALIVE_REQ, NULL, NULL, 0, 0);
-  	}
---- 526,537 ----
-  		 * will allow the client to either perform recovery or
-  		 * simply join in.
-  		 */
-! 		if (announce) {
-! 			if ((ret = __dbt_usercopy(dbenv, dbt)) != 0)
-! 				goto err;
-  			(void)__rep_send_message(dbenv,
-  			    DB_EID_BROADCAST, REP_NEWCLIENT, NULL, dbt, 0, 0);
-! 		} else
-  			(void)__rep_send_message(dbenv,
-  			    DB_EID_BROADCAST, REP_ALIVE_REQ, NULL, NULL, 0, 0);
-  	}
-***************
-*** 553,558 ****
---- 555,561 ----
-  	}
-  	if (pending_event != DB_EVENT_NO_SUCH_EVENT)
-  		DB_EVENT(dbenv, pending_event, NULL);
-+ 	__dbt_userfree(dbenv, dbt, NULL, NULL);
-  	return (ret);
-  }
-  
-*** rep/rep_record.c.orig	Fri Oct 20 08:34:06 2006
---- rep/rep_record.c	Mon Nov 13 10:46:29 2006
-***************
-*** 163,168 ****
---- 163,176 ----
-  		return (EINVAL);
-  	}
-  
-+ 	if ((ret = __dbt_usercopy(dbenv, control)) != 0 ||
-+  	    (ret = __dbt_usercopy(dbenv, rec)) != 0) {
-+  		__dbt_userfree(dbenv, control, rec, NULL);
-+  		__db_errx(dbenv,
-+  	"DB_ENV->rep_process_message: error retrieving DBT contents");
-+  		return ret;
-+  	}
-+ 
-  	ret = 0;
-  	db_rep = dbenv->rep_handle;
-  	rep = db_rep->region;
-***************
-*** 621,626 ****
---- 629,635 ----
-  			*ret_lsnp = rp->lsn;
-  		ret = DB_REP_NOTPERM;
-  	}
-+ 	__dbt_userfree(dbenv, control, rec, NULL);
-  	return (ret);
-  }
-  
diff --git a/extra/db/patch.4.7.25.1 b/extra/db/patch.4.7.25.1
new file mode 100644
index 000000000..3c7e23ce0
--- /dev/null
+++ b/extra/db/patch.4.7.25.1
@@ -0,0 +1,75 @@
+*** sequence/sequence.c.orig	2008-05-05 13:25:09.000000000 -0700

+--- sequence/sequence.c	2008-08-15 09:58:46.000000000 -0700

+***************

+*** 187,193 ****

+  	if ((ret = __db_get_flags(dbp, &tflags)) != 0)

+  		goto err;

+  

+! 	if (DB_IS_READONLY(dbp)) {

+  		ret = __db_rdonly(dbp->env, "DB_SEQUENCE->open");

+  		goto err;

+  	}

+--- 187,197 ----

+  	if ((ret = __db_get_flags(dbp, &tflags)) != 0)

+  		goto err;

+  

+! 	/*

+! 	 * We can let replication clients open sequences, but must

+! 	 * check later that they do not update them.

+! 	 */

+! 	if (F_ISSET(dbp, DB_AM_RDONLY)) {

+  		ret = __db_rdonly(dbp->env, "DB_SEQUENCE->open");

+  		goto err;

+  	}

+***************

+*** 244,249 ****

+--- 248,258 ----

+  		if ((ret != DB_NOTFOUND && ret != DB_KEYEMPTY) ||

+  		    !LF_ISSET(DB_CREATE))

+  			goto err;

++ 		if (IS_REP_CLIENT(env) &&

++ 		    !F_ISSET(dbp, DB_AM_NOT_DURABLE)) {

++ 			ret = __db_rdonly(env, "DB_SEQUENCE->open");

++ 			goto err;

++ 		}

+  		ret = 0;

+  

+  		rp = &seq->seq_record;

+***************

+*** 296,302 ****

+  	 */

+  	rp = seq->seq_data.data;

+  	if (rp->seq_version == DB_SEQUENCE_OLDVER) {

+! oldver:		rp->seq_version = DB_SEQUENCE_VERSION;

+  		if (!F_ISSET(env, ENV_LITTLEENDIAN)) {

+  			if (IS_DB_AUTO_COMMIT(dbp, txn)) {

+  				if ((ret =

+--- 305,316 ----

+  	 */

+  	rp = seq->seq_data.data;

+  	if (rp->seq_version == DB_SEQUENCE_OLDVER) {

+! oldver:		if (IS_REP_CLIENT(env) &&

+! 		    !F_ISSET(dbp, DB_AM_NOT_DURABLE)) {

+! 			ret = __db_rdonly(env, "DB_SEQUENCE->open");

+! 			goto err;

+! 		}

+! 		rp->seq_version = DB_SEQUENCE_VERSION;

+  		if (!F_ISSET(env, ENV_LITTLEENDIAN)) {

+  			if (IS_DB_AUTO_COMMIT(dbp, txn)) {

+  				if ((ret =

+***************

+*** 707,712 ****

+--- 721,733 ----

+  

+  	MUTEX_LOCK(env, seq->mtx_seq);

+  

++ 	if (handle_check && IS_REP_CLIENT(env) &&

++ 	    !F_ISSET(dbp, DB_AM_NOT_DURABLE)) {

++ 		ret = __db_rdonly(env, "DB_SEQUENCE->get");

++ 		goto err;

++ 	}

++ 

++ 

+  	if (rp->seq_min + delta > rp->seq_max) {

+  		__db_errx(env, "Sequence overflow");

+  		ret = EINVAL;

diff --git a/extra/db/patch.4.7.25.2 b/extra/db/patch.4.7.25.2
new file mode 100644
index 000000000..1f42dcec7
--- /dev/null
+++ b/extra/db/patch.4.7.25.2
@@ -0,0 +1,71 @@
+Index: lock/lock.c

+===================================================================

+RCS file: /a/CVSROOT/db/lock/lock.c,v

+retrieving revision 12.61

+diff -c -r12.61 lock.c

+*** lock/lock.c	22 Jul 2008 12:08:53 -0000	12.61

+--- lock/lock.c	19 Aug 2008 17:28:24 -0000

+***************

+*** 1278,1287 ****

+  		SH_TAILQ_REMOVE(

+  		    &lt->obj_tab[obj_ndx], sh_obj, links, __db_lockobj);

+  		if (sh_obj->lockobj.size > sizeof(sh_obj->objdata)) {

+! 			LOCK_REGION_LOCK(env);

+  			__env_alloc_free(&lt->reginfo,

+  			    SH_DBT_PTR(&sh_obj->lockobj));

+! 			LOCK_REGION_UNLOCK(env);

+  		}

+  		SH_TAILQ_INSERT_HEAD(

+  		    &FREE_OBJS(lt, part_id), sh_obj, links, __db_lockobj);

+--- 1278,1289 ----

+  		SH_TAILQ_REMOVE(

+  		    &lt->obj_tab[obj_ndx], sh_obj, links, __db_lockobj);

+  		if (sh_obj->lockobj.size > sizeof(sh_obj->objdata)) {

+! 			if (region->part_t_size != 1)

+! 				LOCK_REGION_LOCK(env);

+  			__env_alloc_free(&lt->reginfo,

+  			    SH_DBT_PTR(&sh_obj->lockobj));

+! 			if (region->part_t_size != 1)

+! 				LOCK_REGION_UNLOCK(env);

+  		}

+  		SH_TAILQ_INSERT_HEAD(

+  		    &FREE_OBJS(lt, part_id), sh_obj, links, __db_lockobj);

+***************

+*** 1470,1484 ****

+  		if (obj->size <= sizeof(sh_obj->objdata))

+  			p = sh_obj->objdata;

+  		else {

+! 			LOCK_REGION_LOCK(env);

+  			if ((ret =

+  			    __env_alloc(&lt->reginfo, obj->size, &p)) != 0) {

+  				__db_errx(env,

+  				    "No space for lock object storage");

+! 				LOCK_REGION_UNLOCK(env);

+  				goto err;

+  			}

+! 			LOCK_REGION_UNLOCK(env);

+  		}

+  

+  		memcpy(p, obj->data, obj->size);

+--- 1472,1492 ----

+  		if (obj->size <= sizeof(sh_obj->objdata))

+  			p = sh_obj->objdata;

+  		else {

+! 			/*

+! 			 * If we have only one partition, the region is locked.

+! 			 */

+! 			if (region->part_t_size != 1)

+! 				LOCK_REGION_LOCK(env);

+  			if ((ret =

+  			    __env_alloc(&lt->reginfo, obj->size, &p)) != 0) {

+  				__db_errx(env,

+  				    "No space for lock object storage");

+! 				if (region->part_t_size != 1)

+! 					LOCK_REGION_UNLOCK(env);

+  				goto err;

+  			}

+! 			if (region->part_t_size != 1)

+! 				LOCK_REGION_UNLOCK(env);

+  		}

+  

+  		memcpy(p, obj->data, obj->size);

diff --git a/extra/db/patch.4.7.25.3 b/extra/db/patch.4.7.25.3
new file mode 100644
index 000000000..b58a43074
--- /dev/null
+++ b/extra/db/patch.4.7.25.3
@@ -0,0 +1,314 @@
+*** lock/lock_deadlock.c	2008-03-11 00:31:33.000000000 +1100

+--- lock/lock_deadlock.c	2008-12-16 21:54:18.000000000 +1100

+***************

+*** 121,127 ****

+  	DB_LOCKTAB *lt;

+  	db_timespec now;

+  	locker_info *idmap;

+! 	u_int32_t *bitmap, *copymap, **deadp, **free_me, *tmpmap;

+  	u_int32_t i, cid, keeper, killid, limit, nalloc, nlockers;

+  	u_int32_t lock_max, txn_max;

+  	int ret, status;

+--- 121,127 ----

+  	DB_LOCKTAB *lt;

+  	db_timespec now;

+  	locker_info *idmap;

+! 	u_int32_t *bitmap, *copymap, **deadp, **deadlist, *tmpmap;

+  	u_int32_t i, cid, keeper, killid, limit, nalloc, nlockers;

+  	u_int32_t lock_max, txn_max;

+  	int ret, status;

+***************

+*** 133,139 ****

+  	if (IS_REP_CLIENT(env))

+  		atype = DB_LOCK_MINWRITE;

+  

+! 	free_me = NULL;

+  

+  	lt = env->lk_handle;

+  	if (rejectp != NULL)

+--- 133,140 ----

+  	if (IS_REP_CLIENT(env))

+  		atype = DB_LOCK_MINWRITE;

+  

+! 	copymap = tmpmap = NULL;

+! 	deadlist = NULL;

+  

+  	lt = env->lk_handle;

+  	if (rejectp != NULL)

+***************

+*** 179,189 ****

+  	memcpy(copymap, bitmap, nlockers * sizeof(u_int32_t) * nalloc);

+  

+  	if ((ret = __os_calloc(env, sizeof(u_int32_t), nalloc, &tmpmap)) != 0)

+! 		goto err1;

+  

+  	/* Find a deadlock. */

+  	if ((ret =

+! 	    __dd_find(env, bitmap, idmap, nlockers, nalloc, &deadp)) != 0)

+  		return (ret);

+  

+  	/*

+--- 180,190 ----

+  	memcpy(copymap, bitmap, nlockers * sizeof(u_int32_t) * nalloc);

+  

+  	if ((ret = __os_calloc(env, sizeof(u_int32_t), nalloc, &tmpmap)) != 0)

+! 		goto err;

+  

+  	/* Find a deadlock. */

+  	if ((ret =

+! 	    __dd_find(env, bitmap, idmap, nlockers, nalloc, &deadlist)) != 0)

+  		return (ret);

+  

+  	/*

+***************

+*** 204,211 ****

+  		txn_max = TXN_MAXIMUM;

+  

+  	killid = BAD_KILLID;

+! 	free_me = deadp;

+! 	for (; *deadp != NULL; deadp++) {

+  		if (rejectp != NULL)

+  			++*rejectp;

+  		killid = (u_int32_t)(*deadp - bitmap) / nalloc;

+--- 205,211 ----

+  		txn_max = TXN_MAXIMUM;

+  

+  	killid = BAD_KILLID;

+! 	for (deadp = deadlist; *deadp != NULL; deadp++) {

+  		if (rejectp != NULL)

+  			++*rejectp;

+  		killid = (u_int32_t)(*deadp - bitmap) / nalloc;

+***************

+*** 342,352 ****

+  			__db_msg(env,

+  			    "Aborting locker %lx", (u_long)idmap[killid].id);

+  	}

+! 	__os_free(env, tmpmap);

+! err1:	__os_free(env, copymap);

+! 

+! err:	if (free_me != NULL)

+! 		__os_free(env, free_me);

+  	__os_free(env, bitmap);

+  	__os_free(env, idmap);

+  

+--- 342,353 ----

+  			__db_msg(env,

+  			    "Aborting locker %lx", (u_long)idmap[killid].id);

+  	}

+! err:	if(copymap != NULL)

+! 		__os_free(env, copymap);

+! 	if (deadlist != NULL)

+! 		__os_free(env, deadlist);

+! 	if(tmpmap != NULL)

+! 		__os_free(env, tmpmap);

+  	__os_free(env, bitmap);

+  	__os_free(env, idmap);

+  

+***************

+*** 360,365 ****

+--- 361,377 ----

+  

+  #define	DD_INVALID_ID	((u_int32_t) -1)

+  

++ /*

++  * __dd_build --

++  *	Build the lock dependency bit maps.

++  * Notes on syncronization:  

++  *	LOCK_SYSTEM_LOCK is used to hold objects locked when we have

++  *		a single partition.

++  *	LOCK_LOCKERS is held while we are walking the lockers list and

++  *		to single thread the use of lockerp->dd_id.

++  *	LOCK_DD protects the DD list of objects.

++  */

++ 

+  static int

+  __dd_build(env, atype, bmp, nlockers, allocp, idmap, rejectp)

+  	ENV *env;

+***************

+*** 393,398 ****

+--- 405,411 ----

+  	 * In particular we do not build the conflict array and our caller

+  	 * needs to expect this.

+  	 */

++ 	LOCK_SYSTEM_LOCK(lt, region);

+  	if (atype == DB_LOCK_EXPIRE) {

+  skip:		LOCK_DD(env, region);

+  		op = SH_TAILQ_FIRST(&region->dd_objs, __db_lockobj);

+***************

+*** 430,446 ****

+  			OBJECT_UNLOCK(lt, region, indx);

+  		}

+  		UNLOCK_DD(env, region);

+  		goto done;

+  	}

+  

+  	/*

+! 	 * We'll check how many lockers there are, add a few more in for

+! 	 * good measure and then allocate all the structures.  Then we'll

+! 	 * verify that we have enough room when we go back in and get the

+! 	 * mutex the second time.

+  	 */

+! retry:	count = region->stat.st_nlockers;

+  	if (count == 0) {

+  		*nlockers = 0;

+  		return (0);

+  	}

+--- 443,460 ----

+  			OBJECT_UNLOCK(lt, region, indx);

+  		}

+  		UNLOCK_DD(env, region);

++ 		LOCK_SYSTEM_UNLOCK(lt, region);

+  		goto done;

+  	}

+  

+  	/*

+! 	 * Allocate after locking the region

+! 	 * to make sure the structures are large enough.

+  	 */

+! 	LOCK_LOCKERS(env, region);

+! 	count = region->stat.st_nlockers;

+  	if (count == 0) {

++ 		UNLOCK_LOCKERS(env, region);

+  		*nlockers = 0;

+  		return (0);

+  	}

+***************

+*** 448,497 ****

+  	if (FLD_ISSET(env->dbenv->verbose, DB_VERB_DEADLOCK))

+  		__db_msg(env, "%lu lockers", (u_long)count);

+  

+- 	count += 20;

+  	nentries = (u_int32_t)DB_ALIGN(count, 32) / 32;

+  

+! 	/*

+! 	 * Allocate enough space for a count by count bitmap matrix.

+! 	 *

+! 	 * XXX

+! 	 * We can probably save the malloc's between iterations just

+! 	 * reallocing if necessary because count grew by too much.

+! 	 */

+  	if ((ret = __os_calloc(env, (size_t)count,

+! 	    sizeof(u_int32_t) * nentries, &bitmap)) != 0)

+  		return (ret);

+  

+  	if ((ret = __os_calloc(env,

+  	    sizeof(u_int32_t), nentries, &tmpmap)) != 0) {

+  		__os_free(env, bitmap);

+  		return (ret);

+  	}

+  

+  	if ((ret = __os_calloc(env,

+  	    (size_t)count, sizeof(locker_info), &id_array)) != 0) {

+  		__os_free(env, bitmap);

+  		__os_free(env, tmpmap);

+  		return (ret);

+  	}

+  

+  	/*

+- 	 * Now go back in and actually fill in the matrix.

+- 	 */

+- 	if (region->stat.st_nlockers > count) {

+- 		__os_free(env, bitmap);

+- 		__os_free(env, tmpmap);

+- 		__os_free(env, id_array);

+- 		goto retry;

+- 	}

+- 

+- 	/*

+  	 * First we go through and assign each locker a deadlock detector id.

+  	 */

+  	id = 0;

+- 	LOCK_LOCKERS(env, region);

+  	SH_TAILQ_FOREACH(lip, &region->lockers, ulinks, __db_locker) {

+  		if (lip->master_locker == INVALID_ROFF) {

+  			lip->dd_id = id++;

+  			id_array[lip->dd_id].id = lip->id;

+  			switch (atype) {

+--- 462,498 ----

+  	if (FLD_ISSET(env->dbenv->verbose, DB_VERB_DEADLOCK))

+  		__db_msg(env, "%lu lockers", (u_long)count);

+  

+  	nentries = (u_int32_t)DB_ALIGN(count, 32) / 32;

+  

+! 	/* Allocate enough space for a count by count bitmap matrix. */

+  	if ((ret = __os_calloc(env, (size_t)count,

+! 	    sizeof(u_int32_t) * nentries, &bitmap)) != 0) {

+! 		UNLOCK_LOCKERS(env, region);

+  		return (ret);

++ 	}

+  

+  	if ((ret = __os_calloc(env,

+  	    sizeof(u_int32_t), nentries, &tmpmap)) != 0) {

++ 		UNLOCK_LOCKERS(env, region);

+  		__os_free(env, bitmap);

+  		return (ret);

+  	}

+  

+  	if ((ret = __os_calloc(env,

+  	    (size_t)count, sizeof(locker_info), &id_array)) != 0) {

++ 		UNLOCK_LOCKERS(env, region);

+  		__os_free(env, bitmap);

+  		__os_free(env, tmpmap);

+  		return (ret);

+  	}

+  

+  	/*

+  	 * First we go through and assign each locker a deadlock detector id.

+  	 */

+  	id = 0;

+  	SH_TAILQ_FOREACH(lip, &region->lockers, ulinks, __db_locker) {

+  		if (lip->master_locker == INVALID_ROFF) {

++ 			DB_ASSERT(env, id < count);

+  			lip->dd_id = id++;

+  			id_array[lip->dd_id].id = lip->id;

+  			switch (atype) {

+***************

+*** 510,516 ****

+  			lip->dd_id = DD_INVALID_ID;

+  

+  	}

+- 	UNLOCK_LOCKERS(env, region);

+  

+  	/*

+  	 * We only need consider objects that have waiters, so we use

+--- 511,516 ----

+***************

+*** 669,675 ****

+  	 * status after building the bit maps so that we will not detect

+  	 * a blocked transaction without noting that it is already aborting.

+  	 */

+- 	LOCK_LOCKERS(env, region);

+  	for (id = 0; id < count; id++) {

+  		if (!id_array[id].valid)

+  			continue;

+--- 669,674 ----

+***************

+*** 738,743 ****

+--- 737,743 ----

+  			id_array[id].in_abort = 1;

+  	}

+  	UNLOCK_LOCKERS(env, region);

++ 	LOCK_SYSTEM_UNLOCK(lt, region);

+  

+  	/*

+  	 * Now we can release everything except the bitmap matrix that we

+***************

+*** 839,844 ****

+--- 839,845 ----

+  	ret = 0;

+  

+  	/* We must lock so this locker cannot go away while we abort it. */

++ 	LOCK_SYSTEM_LOCK(lt, region);

+  	LOCK_LOCKERS(env, region);

+  

+  	/*

+***************

+*** 895,900 ****

+--- 896,902 ----

+  done:	OBJECT_UNLOCK(lt, region, info->last_ndx);

+  err:

+  out:	UNLOCK_LOCKERS(env, region);

++ 	LOCK_SYSTEM_UNLOCK(lt, region);

+  	return (ret);

+  }

+