Add support for filesystem-based replica initialization.

10 files changed, 733 insertions, 81 deletions

diff --git a/ldap/servers/slapd/back-ldbm/Makefile b/ldap/servers/slapd/back-ldbm/Makefile
index c86ec0b3..f570d7e3 100644
--- a/ldap/servers/slapd/back-ldbm/Makefile
+++ b/ldap/servers/slapd/back-ldbm/Makefile
@@ -55,7 +55,8 @@ LIBBACK_LDBM_OBJS=	idl.o idl_shim.o idl_new.o idl_common.o cache.o dn2entry.o \
 	ldbm_bind.o \
 	ldbm_unbind.o \
 	ancestorid.o \
-	ldbm_attrcrypt.o
+	ldbm_attrcrypt.o \
+	dbhelp.o
 
 OBJS = $(addprefix $(OBJDEST)/, $(LIBBACK_LDBM_OBJS))
 
diff --git a/ldap/servers/slapd/back-ldbm/archive.c b/ldap/servers/slapd/back-ldbm/archive.c
index 2daee2c5..10f79cfc 100644
--- a/ldap/servers/slapd/back-ldbm/archive.c
+++ b/ldap/servers/slapd/back-ldbm/archive.c
@@ -11,6 +11,7 @@ int ldbm_back_archive2ldbm( Slapi_PBlock *pb )
 {
     struct ldbminfo    *li;
     char *directory = NULL;
+	char *backendname = NULL;
     int return_value = -1;
     int task_flags = 0;
     int run_from_cmdline = 0;
@@ -19,6 +20,7 @@ int ldbm_back_archive2ldbm( Slapi_PBlock *pb )
 
     slapi_pblock_get( pb, SLAPI_PLUGIN_PRIVATE, &li );
     slapi_pblock_get( pb, SLAPI_SEQ_VAL, &directory );
+	slapi_pblock_get( pb, SLAPI_BACKEND_INSTANCE_NAME, &backendname);
     slapi_pblock_get( pb, SLAPI_BACKEND_TASK, &task );
     slapi_pblock_get( pb, SLAPI_TASK_FLAGS, &task_flags );
     li->li_flags = run_from_cmdline = (task_flags & TASK_RUNNING_FROM_COMMANDLINE);
@@ -122,7 +124,7 @@ int ldbm_back_archive2ldbm( Slapi_PBlock *pb )
     }
 
     /* tell the database to restore */
-    return_value = dblayer_restore(li, directory, task);
+    return_value = dblayer_restore(li, directory, task, backendname);
     if (0 != return_value) {
         LDAPDebug( LDAP_DEBUG_ANY,
                   "archive2db: Failed to read backup file set. "
diff --git a/ldap/servers/slapd/back-ldbm/dbhelp.c b/ldap/servers/slapd/back-ldbm/dbhelp.c
new file mode 100644
index 00000000..df4ae1d0
--- /dev/null
+++ b/ldap/servers/slapd/back-ldbm/dbhelp.c
@@ -0,0 +1,271 @@
+/** BEGIN COPYRIGHT BLOCK
+ * Copyright 2005 Red Hat Inc.
+ * All rights reserved.
+ * END COPYRIGHT BLOCK **/
+
+/* 
+ * File for helper functions related to BerkeleyDB.
+ * This exists because dblayer.c is 5k+ lines long, 
+ * so it seems time to move code to a new file.
+ */
+
+#include "back-ldbm.h"
+#include "dblayer.h"
+
+static int dblayer_copy_file_keybykey(DB_ENV *env, char *source_file_name, char *destination_file_name, int overwrite, dblayer_private *priv)
+{
+	int retval = 0;
+	int retval_cleanup = 0;
+	DB *source_file = NULL;
+	DB *destination_file = NULL;
+	DBC *source_cursor = NULL;
+	int dbtype = 0;
+	int dbflags = 0;
+	int dbpagesize = 0;
+	int cursor_flag = 0;
+	int finished = 0;
+	int mode = 0;
+
+	if (priv->dblayer_file_mode)
+		mode = priv->dblayer_file_mode;
+	dblayer_set_env_debugging(env, priv);
+
+	LDAPDebug( LDAP_DEBUG_TRACE, "=> dblayer_copy_file_keybykey\n", 0, 0, 0 );
+	/* Open the source file */
+	retval = db_create(&source_file, env, 0);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, Create error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+	retval = source_file->open(source_file, NULL, source_file_name, NULL, DB_UNKNOWN, DB_RDONLY, 0);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, Open error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+	/* Get the info we need from the source file */
+	retval = source_file->get_flags(source_file, &dbflags);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, get_flags error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+	retval = source_file->get_type(source_file, &dbtype);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, get_type error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+	retval = source_file->get_pagesize(source_file, &dbpagesize);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, get_pagesize error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+	/* Open the destination file
+	 * and make sure that it has the correct page size, the correct access method, and the correct flags (dup etc)
+	 */
+	retval = db_create(&destination_file, env, 0);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, Create error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+	retval = destination_file->set_flags(destination_file,dbflags);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, set_flags error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+	retval = destination_file->set_pagesize(destination_file,dbpagesize);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, set_pagesize error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+	retval = destination_file->open(destination_file, NULL, destination_file_name, NULL, dbtype, DB_CREATE | DB_EXCL, mode);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, Open error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+	/* Open a cursor on the source file */
+	retval = source_file->cursor(source_file,NULL,&source_cursor,0);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, Create cursor error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+	/* Seek to the first key */
+	cursor_flag = DB_FIRST;
+	/* Loop seeking to the next key until they're all done */
+	while (!finished) {
+		DBT key = {0};
+		DBT data = {0};
+		retval = source_cursor->c_get(source_cursor, &key, &data, cursor_flag);
+		if (retval) {
+			/* DB_NOTFOUND is expected when we find the end, log a message for any other error.
+			 * In either case, set finished=1 so we can hop down and close the cursor. */
+			if ( DB_NOTFOUND != retval )
+			{
+				LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, c_get error %d: %s\n", retval, db_strerror(retval), 0);
+				goto error;
+			}
+			retval = 0; /* DB_NOTFOUND was OK... */
+			finished = 1;
+		} else {
+			/* For each key, insert into the destination file */
+			retval = destination_file->put(destination_file, NULL, &key, &data, 0);
+			if (retval) {
+				LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, put error %d: %s\n", retval, db_strerror(retval), 0);
+				goto error;
+			}
+			cursor_flag = DB_NEXT;
+		}
+	}
+
+error:
+	/* Close the cursor */
+	if (source_cursor) {
+		retval_cleanup = source_cursor->c_close(source_cursor);
+		if (retval_cleanup) {
+			LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, Close cursor error %d: %s\n", retval_cleanup, db_strerror(retval_cleanup), 0);
+			retval += retval_cleanup;
+		}
+	}
+	/* Close the source file */
+	if (source_file) {
+		retval_cleanup = source_file->close(source_file,0);
+		source_file = NULL;
+		if (retval_cleanup) {
+			LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, Close error %d: %s\n", retval_cleanup, db_strerror(retval_cleanup), 0); 
+			retval += retval_cleanup;
+		}
+	}
+	/* Close the destination file */
+	if (destination_file) {
+		retval_cleanup = destination_file->close(destination_file,0);
+		destination_file = NULL;
+		if (retval_cleanup) {
+			LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_keybykey, Close error %d: %s\n", retval_cleanup, db_strerror(retval_cleanup), 0);
+			retval += retval_cleanup;
+		}
+	}
+
+	LDAPDebug( LDAP_DEBUG_TRACE, "<= dblayer_copy_file_keybykey\n", 0, 0, 0 );
+	return retval;
+}
+
+int dblayer_copy_file_resetlsns(char *home_dir ,char *source_file_name, char *destination_file_name, int overwrite, dblayer_private *priv)
+{
+	int retval = 0;
+	int mode = 0;
+	DB_ENV *env = NULL;
+
+	LDAPDebug( LDAP_DEBUG_TRACE, "=> dblayer_copy_file_resetlsns\n", 0, 0, 0 );
+	/* Make the environment */
+
+	if (priv->dblayer_file_mode)
+		mode = priv->dblayer_file_mode;
+	retval = dblayer_make_private_simple_env(home_dir,&env);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_resetlsns: Call to dblayer_make_private_simple_env failed!\n" 
+			"Unable to open an environment.", 0, 0, 0);
+	}
+	/* Do the copy */
+	retval = dblayer_copy_file_keybykey(env, source_file_name, destination_file_name, overwrite, priv);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_resetlsns: Copy not completed successfully.", 0, 0, 0);
+	}
+	/* Close the environment */
+	if (env) {
+		int retval2 = 0;
+		retval2 = env->close(env,0);
+		if (retval2) {
+			if (0 == retval) {
+				retval = retval2;
+				LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_resetlsns, error %d: %s\n", retval, db_strerror(retval), 0);
+			}
+		}
+	}
+
+	LDAPDebug( LDAP_DEBUG_TRACE, "<= dblayer_copy_file_resetlsns\n", 0, 0, 0 );
+	return retval;
+}
+
+void dblayer_set_env_debugging(DB_ENV *pEnv, dblayer_private *priv)
+{
+	pEnv->set_errpfx(pEnv, "ns-slapd");
+    if (priv->dblayer_verbose) {
+        pEnv->set_verbose(pEnv, DB_VERB_CHKPOINT, 1);    /* 1 means on */
+        pEnv->set_verbose(pEnv, DB_VERB_DEADLOCK, 1);    /* 1 means on */
+        pEnv->set_verbose(pEnv, DB_VERB_RECOVERY, 1);    /* 1 means on */
+        pEnv->set_verbose(pEnv, DB_VERB_WAITSFOR, 1);    /* 1 means on */
+    }
+    if (priv->dblayer_debug) {
+        pEnv->set_errcall(pEnv, dblayer_log_print);
+    }
+
+}
+
+/* Make an environment to be used for isolated recovery (e.g. during a partial restore operation) */
+int dblayer_make_private_recovery_env(char *db_home_dir, dblayer_private *priv, DB_ENV **env)
+{
+	int retval = 0;
+	DB_ENV *ret_env = NULL;
+
+	LDAPDebug( LDAP_DEBUG_TRACE, "=> dblayer_make_private_recovery_env\n", 0, 0, 0 );
+	if (NULL == env) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_make_private_recovery_env: Null environment.  Cannot continue.", 0, 0, 0);
+		return -1;
+	}
+	*env = NULL;
+
+	retval = db_env_create(&ret_env,0);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_make_private_recovery_env, Create error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+	dblayer_set_env_debugging(ret_env, priv);
+
+	retval = ret_env->open(ret_env,db_home_dir, DB_INIT_TXN | DB_RECOVER_FATAL | DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE,0);
+	if (0 == retval) {
+		*env = ret_env;
+	} else {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_make_private_recovery_env, Open error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+
+error:
+	LDAPDebug( LDAP_DEBUG_TRACE, "<= dblayer_make_private_recovery_env\n", 0, 0, 0 );
+	return retval;
+}
+
+/* Make an environment to be used for simple non-transacted database operations, e.g. fixup during upgrade */
+int dblayer_make_private_simple_env(char *db_home_dir, DB_ENV **env)
+{
+	int retval = 0;
+	DB_ENV *ret_env = NULL;
+
+	LDAPDebug( LDAP_DEBUG_TRACE, "=> dblayer_make_private_simple_env\n", 0, 0, 0 );
+	if (NULL == env) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_make_private_simple_env: Null environment.  Cannot continue.", 0, 0, 0);
+		return -1;
+	}
+	*env = NULL;
+
+	retval = db_env_create(&ret_env,0);
+	if (retval) {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_make_private_simple_env, error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+
+	retval = ret_env->open(ret_env,db_home_dir,DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE,0);
+	if (0 == retval) {
+		*env = ret_env;
+	} else {
+		LDAPDebug(LDAP_DEBUG_ANY, "dblayer_make_private_simple_env, error %d: %s\n", retval, db_strerror(retval), 0);
+		goto error;
+	}
+
+error:
+	LDAPDebug( LDAP_DEBUG_TRACE, "<= dblayer_make_private_simple_env\n", 0, 0, 0 );
+	return retval;
+}
+
+char* last_four_chars(const char* s)
+{
+    size_t l = strlen(s);
+    return ((char*)s + (l - 4));
+}
diff --git a/ldap/servers/slapd/back-ldbm/dblayer.c b/ldap/servers/slapd/back-ldbm/dblayer.c
index c852b475..41c2f4c1 100644
--- a/ldap/servers/slapd/back-ldbm/dblayer.c
+++ b/ldap/servers/slapd/back-ldbm/dblayer.c
@@ -131,6 +131,9 @@
 #endif
 #endif
 
+#define NEWDIR_MODE 0755
+
+
 static int perf_threadmain(void *param);
 static int checkpoint_threadmain(void *param);
 static int trickle_threadmain(void *param);
@@ -142,6 +145,7 @@ static int dblayer_override_libdb_functions(DB_ENV *pEnv, dblayer_private *priv)
 static int dblayer_force_checkpoint(struct ldbminfo *li);
 static int log_flush_threadmain(void *param);
 static int dblayer_delete_transaction_logs(const char * log_dir);
+static int dblayer_is_logfilename(const char* path);
 
 static int dblayer_start_log_flush_thread(dblayer_private *priv);
 static int dblayer_start_deadlock_thread(struct ldbminfo *li);
@@ -152,7 +156,6 @@ static int trans_batch_count=1;
 static int trans_batch_limit=0;
 static PRBool log_flush_thread=PR_FALSE;
 static int dblayer_db_remove_ex(dblayer_private_env *env, char const path[], char const dbName[], PRBool use_lock);
-static char* last_four_chars(const char* s);
 
 #define MEGABYTE (1024 * 1024)
 #define GIGABYTE (1024 * MEGABYTE)
@@ -285,7 +288,7 @@ static void dblayer_reset_env(struct ldbminfo *li)
 }
 
 /* Callback function for libdb to spit error info into our log */
-static void dblayer_log_print(const char* prefix, char *buffer)
+void dblayer_log_print(const char* prefix, char *buffer)
 {
     /* We ignore the prefix since we know who we are anyway */
     LDAPDebug(LDAP_DEBUG_ANY,"libdb: %s\n", buffer, 0, 0);    
@@ -605,21 +608,13 @@ static void dblayer_init_dbenv(DB_ENV *pEnv, dblayer_private *priv)
     dblayer_select_ncache(mysize, &myncache); 
     priv->dblayer_ncache = myncache;
 
-    pEnv->set_errpfx(pEnv, "ns-slapd");
+    dblayer_set_env_debugging(pEnv,priv);
+
     pEnv->set_lg_max(pEnv, priv->dblayer_logfile_size);
     pEnv->set_cachesize(pEnv, mysize / GIGABYTE, mysize % GIGABYTE, myncache);
     pEnv->set_lk_max_locks(pEnv, priv->dblayer_lock_config);
     pEnv->set_lk_max_objects(pEnv, priv->dblayer_lock_config);
     pEnv->set_lk_max_lockers(pEnv, priv->dblayer_lock_config); 
-    if (priv->dblayer_verbose) {
-        pEnv->set_verbose(pEnv, DB_VERB_CHKPOINT, 1);    /* 1 means on */
-        pEnv->set_verbose(pEnv, DB_VERB_DEADLOCK, 1);    /* 1 means on */
-        pEnv->set_verbose(pEnv, DB_VERB_RECOVERY, 1);    /* 1 means on */
-        pEnv->set_verbose(pEnv, DB_VERB_WAITSFOR, 1);    /* 1 means on */
-    }
-    if (priv->dblayer_debug) {
-        pEnv->set_errcall(pEnv, dblayer_log_print);
-    }
 
     /* shm_key required for named_regions (DB_SYSTEM_MEM) */
     pEnv->set_shm_key(pEnv, priv->dblayer_shm_key);
@@ -3972,8 +3967,12 @@ static int dblayer_force_checkpoint(struct ldbminfo *li)
   return ret;
 }
 
-
-static int _dblayer_delete_instance_dir(ldbm_instance *inst)
+/* TEL:  Added startdb flag.  If set (1), the DB environment will be started so
+ * that dblayer_db_remove_ex will be used to remove the database files instead
+ * of simply deleting them.  That is important when doing a selective restoration
+ * of a single backend (FRI).  If not set (0), the traditional remove is used.
+ */
+static int _dblayer_delete_instance_dir(ldbm_instance *inst, int startdb)
 {
     PRDir *dirhandle = NULL;
     PRDirEntry *direntry = NULL;
@@ -3987,6 +3986,16 @@ static int _dblayer_delete_instance_dir(ldbm_instance *inst)
 
     if (NULL != li)
     {
+		if (startdb)
+		{
+			rval = dblayer_start(li, DBLAYER_NORMAL_MODE);
+			if (rval)
+			{
+				LDAPDebug(LDAP_DEBUG_ANY, "_dblayer_delete_instance_dir: dblayer_start failed! %s (%d)\n",
+					dblayer_strerror(rval), rval, 0);
+				goto done;
+			}
+		}
         priv = (dblayer_private*)li->li_dblayer_private;
         if (NULL != priv)
         {
@@ -4045,6 +4054,15 @@ static int _dblayer_delete_instance_dir(ldbm_instance *inst)
         }
     }
     PR_CloseDir(dirhandle);
+	if (pEnv && startdb)
+	{
+		rval = dblayer_close(li, DBLAYER_NORMAL_MODE);
+		if (rval)
+		{
+			LDAPDebug(LDAP_DEBUG_ANY, "_dblayer_delete_instance_dir: dblayer_close failed! %s (%d)\n",
+				dblayer_strerror(rval), rval, 0);
+		}
+	}
 done:
     /* remove the directory itself too */
     if (0 == rval)
@@ -4067,20 +4085,23 @@ int dblayer_delete_instance_dir(backend *be)
     return ret;
   } else {
     ldbm_instance *inst = (ldbm_instance *)be->be_instance_info;
-    return _dblayer_delete_instance_dir(inst);
+    return _dblayer_delete_instance_dir(inst, 0);
   }
 }
 
-/* delete an entire db/ directory, including all instances under it!
+
+/* delete an entire db/ directory, including either all instances, or
+ * just a single instance (leaving the others intact), if the instance param is non-NULL !
  * this is used mostly for restores.
  * dblayer is assumed to be closed.
  */
-int dblayer_delete_database(struct ldbminfo *li)
+int dblayer_delete_database_ex(struct ldbminfo *li, char *instance)
 {
     dblayer_private *priv = NULL;
     Object *inst_obj;
     PRDir *dirhandle = NULL;
     PRDirEntry *direntry = NULL;
+	PRFileInfo fileinfo;
     char filename[MAXPATHLEN];
     char *log_dir;
     int ret;
@@ -4095,13 +4116,25 @@ int dblayer_delete_database(struct ldbminfo *li)
         ldbm_instance *inst = (ldbm_instance *)object_get_data(inst_obj);
 
         if (inst->inst_be->be_instance_info != NULL) {
-            ret = _dblayer_delete_instance_dir(inst);
-            if (ret != 0)
-            {
-                LDAPDebug(LDAP_DEBUG_ANY,
-                "dblayer_delete_database: WARNING _dblayer_delete_instance_dir failed (%d)\n", ret, 0, 0);
-                return ret;
-            }
+			if ((NULL != instance) && (strcmp(inst->inst_name,instance) != 0)) 
+			{
+				LDAPDebug(LDAP_DEBUG_ANY,
+					"dblayer_delete_database: skipping instance %s\n",inst->inst_name , 0, 0);	
+			} else 
+			{
+				if (NULL == instance)
+				{
+					ret = _dblayer_delete_instance_dir(inst, 0 /* Do not start DB environment: traditional */);
+				} else {
+					ret = _dblayer_delete_instance_dir(inst, 1 /* Start DB environment: for FRI */);
+				}
+				if (ret != 0)
+				{
+					LDAPDebug(LDAP_DEBUG_ANY,
+					"dblayer_delete_database: WARNING _dblayer_delete_instance_dir failed (%d)\n", ret, 0, 0);
+					return ret;
+				}	
+			}
         }
     }
 
@@ -4116,11 +4149,26 @@ int dblayer_delete_database(struct ldbminfo *li)
     }
     while (NULL != (direntry = PR_ReadDir(dirhandle, PR_SKIP_DOT |
                                           PR_SKIP_DOT_DOT))) {
+		int rval_tmp = 0;
         if (! direntry->name)
             break;
-        sprintf(filename, "%s/%s", priv->dblayer_home_directory,
-                direntry->name);
-        PR_Delete(filename);
+
+		sprintf(filename, "%s/%s", priv->dblayer_home_directory, 
+			direntry->name);
+
+		/* Do not call PR_Delete on the instance directories if they exist.
+		 * It would not work, but we still should not do it. */
+        rval_tmp = PR_GetFileInfo(filename, &fileinfo);
+        if (rval_tmp == PR_SUCCESS && fileinfo.type != PR_FILE_DIRECTORY)
+		{
+			/* Skip deleting log files; that should be handled below.
+			 * (Note, we don't want to use "filename," because that is qualified and would
+			 * not be compatibile with what dblayer_is_logfilename expects.) */
+			if (!dblayer_is_logfilename(direntry->name))
+			{       
+				PR_Delete(filename);
+			}
+		}
     }
 
     PR_CloseDir(dirhandle);
@@ -4134,16 +4182,28 @@ int dblayer_delete_database(struct ldbminfo *li)
     {
         log_dir = dblayer_get_home_dir(li, NULL);
     }
-    ret = dblayer_delete_transaction_logs(log_dir);
-    if(ret) {
-      LDAPDebug(LDAP_DEBUG_ANY,
-      "dblayer_delete_database: dblayer_delete_transaction_logs failed (%d)\n",
-      ret, 0, 0);
-      return -1;
-    }
+	if (instance == NULL)
+	{
+		ret = dblayer_delete_transaction_logs(log_dir);
+		if(ret) {
+		  LDAPDebug(LDAP_DEBUG_ANY,
+		  "dblayer_delete_database: dblayer_delete_transaction_logs failed (%d)\n",
+		  ret, 0, 0);
+		  return -1;
+		}
+	}
     return 0;
 }
 
+/* delete an entire db/ directory, including all instances under it!
+ * this is used mostly for restores.
+ * dblayer is assumed to be closed.
+ */
+int dblayer_delete_database(struct ldbminfo *li)
+{
+	return dblayer_delete_database_ex(li, NULL);
+}
+
 
 /* 
  * Return the size of the database (in kilobytes).  XXXggood returning
@@ -4207,11 +4267,6 @@ int dblayer_database_size(struct ldbminfo *li, unsigned int *size)
     return return_value;
 }
 
-static char* last_four_chars(const char* s)
-{
-    size_t l = strlen(s);
-    return ((char*)s + (l - 4));
-}
 
 static int count_dbfiles_in_dir(char *directory, int *count, int recurse)
 {
@@ -4365,6 +4420,8 @@ error:
  * The argument cnt is used to count the number of files that were copied.
  *
  * This function is used during db2bak and bak2db.
+ * DBDB added resetlsns arg which is used in partial restore (because the LSNs need to be reset to avoid
+ * confusing transaction logging code).
  */
 int dblayer_copy_directory(struct ldbminfo *li,
                            Slapi_Task *task,
@@ -4373,7 +4430,8 @@ int dblayer_copy_directory(struct ldbminfo *li,
                            int restore,
                            int *cnt,
                            int instance_dir_flag,
-                           int indexonly)
+                           int indexonly,
+						   int resetlsns)
 {
     dblayer_private *priv = NULL;
     char            *new_src_dir = NULL;
@@ -4523,8 +4581,14 @@ int dblayer_copy_directory(struct ldbminfo *li,
             }
 
             /* copy filename1 to filename2 */
-            return_value = dblayer_copyfile(filename1, filename2,
+			/* If the file is a database file, and resetlsns is set, then we need to do a key by key copy */
+			if (strcmp(LDBM_FILENAME_SUFFIX, last_four_chars(filename1)) == 0 && resetlsns) {
+				return_value = dblayer_copy_file_resetlsns(src_dir, filename1, filename2,
+                                            0, priv);
+			} else {
+				return_value = dblayer_copyfile(filename1, filename2,
                                             0, priv->dblayer_file_mode);
+			}
             slapi_ch_free((void**)&filename1);
             slapi_ch_free((void**)&filename2);
             if (0 > return_value)
@@ -4640,7 +4704,7 @@ int dblayer_backup(struct ldbminfo *li, char *dest_dir, Slapi_Task *task)
             inst_dirp = dblayer_get_full_inst_dir(inst->inst_li, inst,
                                                     inst_dir, MAXPATHLEN);
             return_value = dblayer_copy_directory(li, task, inst_dirp,
-                                        dest_dir, 0 /* backup */, &cnt, 0, 0);
+                                        dest_dir, 0 /* backup */, &cnt, 0, 0, 0);
             if (return_value != 0) {
                 LDAPDebug(LDAP_DEBUG_ANY,
                     "ERROR: error copying directory (%s -> %s): err=%d\n",
@@ -4895,9 +4959,198 @@ static int doskip(const char *filename)
     return 0;
 }
 
+static int dblayer_copy_dirand_contents(char* src_dir, char* dst_dir, int mode, Slapi_Task *task)
+{
+  int return_value  = 0;
+  int tmp_rval;
+  char filename1[MAXPATHLEN];
+  char filename2[MAXPATHLEN];
+  PRDir *dirhandle = NULL;
+  PRDirEntry *direntry = NULL;
+  PRFileInfo info;
+
+  dirhandle = PR_OpenDir(src_dir);
+  if (NULL != dirhandle) 
+  {
+
+	while (NULL != (direntry = PR_ReadDir(dirhandle, PR_SKIP_DOT | PR_SKIP_DOT_DOT))) 
+	{
+      if (NULL == direntry->name) {
+         /* NSPR doesn't behave like the docs say it should */
+        break;
+      }
+
+
+       sprintf(filename1, "%s/%s", src_dir, direntry->name);
+       sprintf(filename2, "%s/%s", dst_dir, direntry->name);
+       LDAPDebug(LDAP_DEBUG_ANY, "Moving file %s\n",
+                          filename2, 0, 0);
+      /* Is this entry a directory? */
+      tmp_rval = PR_GetFileInfo(filename1, &info);
+      if (tmp_rval == PR_SUCCESS && PR_FILE_DIRECTORY == info.type) 
+	  {
+		 PR_MkDir(filename2,NEWDIR_MODE);
+		   return_value = dblayer_copy_dirand_contents(filename1, filename2,
+                                               mode,task);
+			if (return_value) 
+			{
+				if (task) 
+				{
+					slapi_task_log_notice(task,
+					"Failed to copy directory %s", filename1);
+				}
+				break;
+			}
+	   } else {
+			if (task) 
+			{
+				slapi_task_log_notice(task, "Moving file %s",
+                                          filename2);
+				slapi_task_log_status(task, "Moving file %s",
+                                          filename2);
+			}
+			return_value = dblayer_copyfile(filename1, filename2, 0,
+                                               mode);
+	   }
+       if (0 > return_value)
+         break;
+                
+    }
+  }
+  return return_value;
+}
+
+static int dblayer_fri_trim(char *fri_dir_path, char* bename)
+{
+	int retval = 0;
+	int tmp_rval;
+	char filename[MAXPATHLEN];
+	PRDir *dirhandle = NULL;
+	PRDirEntry *direntry = NULL;
+	PRFileInfo info;
+
+	dirhandle = PR_OpenDir(fri_dir_path);
+	if (NULL != dirhandle) 
+	{
+
+		while (NULL != (direntry = PR_ReadDir(dirhandle, PR_SKIP_DOT | PR_SKIP_DOT_DOT))) 
+		{
+			if (NULL == direntry->name) {
+			/* NSPR doesn't behave like the docs say it should */
+			break;
+			}
+
+			sprintf(filename, "%s/%s", fri_dir_path, direntry->name);
+
+			/* Is this entry a directory? */
+			tmp_rval = PR_GetFileInfo(filename, &info);
+			if (tmp_rval == PR_SUCCESS && PR_FILE_DIRECTORY == info.type)
+			{
+				if(strcmp(direntry->name,bename)!=0)
+				{
+					LDAPDebug(LDAP_DEBUG_ANY, "Removing file %s from staging area\n",
+                         filename, 0, 0);
+					ldbm_delete_dirs(filename);
+				}
+				continue;
+			}
+
+			if ((strcmp(direntry->name,"DBVERSION") == 0)||
+				    (strncmp(direntry->name,"__",2) == 0)||
+					(strncmp(direntry->name,"log",3) == 0)){
+				LDAPDebug(LDAP_DEBUG_ANY, "Removing file %s from staging area\n",
+                         filename, 0, 0);
+				PR_Delete(filename);
+			}
+
+		}
+	}
+	PR_CloseDir(dirhandle);
+	return retval;
+}
+
+/* Recover a stand-alone environment , used in filesystem replica intialization restore */
+static int dblayer_recover_environment_path(char *dbhome_dir, dblayer_private *priv)
+{
+	int retval = 0;
+	DB_ENV *env = NULL;
+	/* Make an environment for recovery */
+	retval = dblayer_make_private_recovery_env(dbhome_dir, priv, &env);
+	if (retval) {
+		goto error;
+	}
+	if (env) {
+		retval = env->close(env,0);
+		if (retval) {
+		}
+	}
+error:
+	return retval;
+}
+
+
+static int dblayer_fri_restore(char *home_dir, char *src_dir, dblayer_private *priv, Slapi_Task *task, char** new_src_dir, char* bename)
+{
+		int retval = 0;
+		size_t fribak_dir_length = 0;
+		char *fribak_dir_path = NULL;
+		char *fribak_dir_name = "fribak";
+		int mode = priv->dblayer_file_mode;
+
+		*new_src_dir = NULL;
+
+
+		/* First create the recovery directory */
+		fribak_dir_length = strlen(home_dir) + strlen(fribak_dir_name) + 4; /* 4 for the '/../' */
+		fribak_dir_path = (char *) slapi_ch_malloc(fribak_dir_length + 1); /* add one for the terminator */		
+		sprintf(fribak_dir_path,"%s/../%s",home_dir,fribak_dir_name);
+		if((-1 == PR_MkDir(fribak_dir_path,NEWDIR_MODE)))
+		{
+		  LDAPDebug(LDAP_DEBUG_ANY, "dblayer_fri_restore: %s exists\n",fribak_dir_path, 0, 0);
+		  LDAPDebug(LDAP_DEBUG_ANY, "dblayer_fri_restore: Removing %s.\n",fribak_dir_path, 0, 0);
+		  retval = ldbm_delete_dirs(fribak_dir_path);
+		  if (retval)
+		  {
+			LDAPDebug(LDAP_DEBUG_ANY, "dblayer_fri_restore: Removal of %s failed!\n", fribak_dir_path, 0, 0);
+			goto error;
+		  }
+		  PR_MkDir(fribak_dir_path,NEWDIR_MODE);
+		  if (retval != PR_SUCCESS)
+		  {
+			LDAPDebug(LDAP_DEBUG_ANY, "dblayer_fri_restore: Creation of %s failed!\n", fribak_dir_path, 0, 0);
+			goto error;
+		  }
+		}
+		/* Next copy over the entire backup file set to the recovery directory */
+		/* We do this because we want to run recovery there, and we need all the files for that */
+		retval = dblayer_copy_dirand_contents(src_dir, fribak_dir_path, mode, task);
+		if (retval) 
+		{
+			LDAPDebug(LDAP_DEBUG_ANY, "dblayer_fri_restore: Copy contents to %s failed!\n", fribak_dir_path, 0, 0);
+			goto error;
+		}
+		/* Next, run recovery on the files */
+		retval = dblayer_recover_environment_path(fribak_dir_path, priv);
+		if (retval) 
+		{
+			LDAPDebug(LDAP_DEBUG_ANY, "dblayer_fri_restore: Recovery failed!\n", 0, 0, 0);
+			goto error;
+		}
+		/* Files nicely recovered, next we stip out what we don't need from the backup set */
+		retval = dblayer_fri_trim(fribak_dir_path,bename);
+		if (retval) 
+		{
+			LDAPDebug(LDAP_DEBUG_ANY, "dblayer_fri_restore: Trim failed!\n", 0, 0, 0);
+			goto error;
+		}
+		*new_src_dir = fribak_dir_path;
+	error:
+		return retval;
+}
+
 /* Destination Directory is an absolute pathname */
 
-int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task)
+int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task, char *bename)
 {
     dblayer_private *priv = NULL;
     int return_value  = 0;
@@ -4913,6 +5166,8 @@ int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task)
     int dbmode;
     int action = 0;
     char *home_dir = NULL;
+	char *real_src_dir = NULL;
+	int frirestore = 0; /* Is a an FRI/single instance restore. 0 for no, 1 for yes */
 
     PR_ASSERT(NULL != li);
     priv = (dblayer_private*)li->li_dblayer_private;
@@ -4927,6 +5182,7 @@ int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task)
     PR_Unlock(li->li_config_mutex);
 
     home_dir = dblayer_get_home_dir(li, NULL);
+	
     if (NULL == home_dir)
     {
         LDAPDebug(LDAP_DEBUG_ANY, 
@@ -4949,6 +5205,10 @@ int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task)
         }
     }
 
+	/* If this is a FRI restore, the bename will be non-NULL */
+	if (bename != NULL)
+		frirestore = 1;
+
 	/*
 	 * Check if the target is a superset of the backup.
 	 * If not don't restore any db at all, otherwise
@@ -4961,19 +5221,22 @@ int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task)
 			&& direntry->name)
 		{
             sprintf(filename1, "%s/%s", src_dir, direntry->name);
-            tmp_rval = PR_GetFileInfo(filename1, &info);
-            if (tmp_rval == PR_SUCCESS && PR_FILE_DIRECTORY == info.type) {
-				inst = ldbm_instance_find_by_name(li, (char *)direntry->name);
-				if ( inst == NULL)
-				{
-					LDAPDebug(LDAP_DEBUG_ANY,
-						"ERROR: target server has no %s configured\n", direntry->name, 0, 0);
-        			if (task) {
-			            slapi_task_log_notice(task,
-						"ERROR: target server has no %s configured\n", direntry->name);
-        			}
-    				PR_CloseDir(dirhandle);
-					return LDAP_UNWILLING_TO_PERFORM;
+			if(!frirestore || strcmp(direntry->name,bename)==0)
+			{
+                tmp_rval = PR_GetFileInfo(filename1, &info);
+                if (tmp_rval == PR_SUCCESS && PR_FILE_DIRECTORY == info.type) {
+					inst = ldbm_instance_find_by_name(li, (char *)direntry->name);
+					if ( inst == NULL)
+					{
+						LDAPDebug(LDAP_DEBUG_ANY,
+						 "ERROR: target server has no %s configured\n", direntry->name, 0, 0);
+        				if (task) {
+							slapi_task_log_notice(task,
+							"ERROR: target server has no %s configured\n", direntry->name);
+        				}
+    					PR_CloseDir(dirhandle);
+						return LDAP_UNWILLING_TO_PERFORM;
+					}
 				}
 			}
 		}
@@ -4981,17 +5244,33 @@ int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task)
 	}
 
     /* We delete the existing database */
-    return_value = dblayer_delete_database(li);  
+
+    return_value = dblayer_delete_database_ex(li, bename);  
     if (return_value) {
         return return_value;
     }
 
+	if (frirestore) /*if we are restoring a single backend*/
+	{
+		char *new_src_dir = NULL;
+		return_value = dblayer_fri_restore(home_dir,src_dir,priv,task,&new_src_dir,bename);
+		if (return_value) {
+			return return_value;
+		}
+		/* Now modify the src_dir to point to our recovery area and carry on as if nothing had happened... */
+		real_src_dir = new_src_dir;
+	} else 
+	{
+		/* Otherwise use the src_dir from the caller */
+		real_src_dir = src_dir;
+	}
+
     /* We copy the files over from the staging area */
     /* We want to treat the logfiles specially: if there's
      * a log file directory configured, copy the logfiles there
      * rather than to the db dirctory */
     if (0 == return_value) {
-        dirhandle = PR_OpenDir(src_dir);
+        dirhandle = PR_OpenDir(real_src_dir);
         if (NULL != dirhandle) {
             char *restore_dir;
             char *prefix = NULL;
@@ -5004,8 +5283,9 @@ int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task)
                     break;
                 }
 
+
                 /* Is this entry a directory? */
-                sprintf(filename1, "%s/%s", src_dir, direntry->name);
+                sprintf(filename1, "%s/%s", real_src_dir, direntry->name);
                 tmp_rval = PR_GetFileInfo(filename1, &info);
                 if (tmp_rval == PR_SUCCESS && PR_FILE_DIRECTORY == info.type) {
                     /* This is an instance directory. It contains the *.db#
@@ -5019,9 +5299,9 @@ int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task)
 						continue;
 
                     restore_dir = inst->inst_parent_dir_name;
-
+					/* If we're doing a partial restore, we need to reset the LSNs on the data files */
                     if (dblayer_copy_directory(li, task, filename1,
-                            restore_dir, 1 /* restore */, &cnt, 0, 0) == 0)
+						restore_dir, 1 /* restore */, &cnt, 0, 0, (bename) ? 1 : 0) == 0)
                         continue;
                     else
                     {
@@ -5054,7 +5334,7 @@ int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task)
                     prefix = home_dir;
                 }
                 mkdir_p(prefix, 0700);
-                sprintf(filename1, "%s/%s", src_dir, direntry->name);
+                sprintf(filename1, "%s/%s", real_src_dir, direntry->name);
                 sprintf(filename2, "%s/%s", prefix, direntry->name);
                 LDAPDebug(LDAP_DEBUG_ANY, "Restoring file %d (%s)\n",
                           cnt, filename2, 0);
@@ -5130,12 +5410,13 @@ int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task)
         if (task) {
             slapi_task_log_notice(task, "Failed to init database");
         }
-        return tmp_rval;
+        return_value = tmp_rval;
+		goto error_out;
     }
 
     if (0 == return_value) { /* only when the copyfile succeeded */
         /* check the DSE_* files, if any */
-        tmp_rval = dse_conf_verify(li, src_dir);
+        tmp_rval = dse_conf_verify(li, real_src_dir, bename);
         if (0 != tmp_rval)
             LDAPDebug(LDAP_DEBUG_ANY,
                 "Warning: Unable to verify the index configuration\n", 0, 0, 0);
@@ -5154,6 +5435,22 @@ int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task)
 
     return_value = tmp_rval?tmp_rval:return_value;
 
+error_out:
+	/* Free the restore src dir, but only if we allocated it above */
+	if (real_src_dir != src_dir) {
+		/* If this was an FRI restore and the staging area exists, go ahead and remove it */
+		if (frirestore && PR_Access(real_src_dir, PR_ACCESS_EXISTS) == PR_SUCCESS)
+		{
+			int ret1 = 0;
+			LDAPDebug(LDAP_DEBUG_ANY, "dblayer_restore: Removing staging area %s.\n",real_src_dir, 0, 0);
+			ret1 = ldbm_delete_dirs(real_src_dir);
+			if (ret1)
+			{
+				LDAPDebug(LDAP_DEBUG_ANY, "dblayer_restore: Removal of staging area %s failed!\n", real_src_dir, 0, 0);
+			}
+		}
+		slapi_ch_free((void**)&real_src_dir);
+	}
     return return_value;
 }
 
@@ -5393,3 +5690,4 @@ void dblayer_set_recovery_required(struct ldbminfo *li)
     }
     li->li_dblayer_private->dblayer_recovery_required = 1;
 }
+
diff --git a/ldap/servers/slapd/back-ldbm/dblayer.h b/ldap/servers/slapd/back-ldbm/dblayer.h
index 78274ec6..7c096617 100644
--- a/ldap/servers/slapd/back-ldbm/dblayer.h
+++ b/ldap/servers/slapd/back-ldbm/dblayer.h
@@ -133,8 +133,26 @@ struct dblayer_private
     int dblayer_lock_config;
 };
 
+void dblayer_log_print(const char* prefix, char *buffer);
+
 int dblayer_db_remove(dblayer_private_env * env, char const path[], char const dbName[]);
 
 int dblayer_delete_indices(ldbm_instance *inst);
 
+/* Helper functions in dbhelp.c */
+
+/* Make an environment to be used for isolated recovery (e.g. during a partial restore operation) */
+int dblayer_make_private_recovery_env(char *db_home_dir, dblayer_private *priv, DB_ENV **env);
+/* Make an environment to be used for simple non-transacted database operations, e.g. fixup during upgrade */
+int dblayer_make_private_simple_env(char *db_home_dir, DB_ENV **env);
+/* Copy a database file, preserving all its contents (used to reset the LSNs in the file in order to move 
+ * it from one transacted environment to another.
+ */
+int dblayer_copy_file_resetlsns(char *home_dir, char *source_file_name, char *destination_file_name, int overwrite, dblayer_private *priv);
+/* Turn on the various logging and debug options for DB */
+void dblayer_set_env_debugging(DB_ENV *pEnv, dblayer_private *priv);
+
+/* Return the last four characters of a string; used for comparing extensions. */
+char* last_four_chars(const char* s);
+
 #endif /* _DBLAYER_H_ */
diff --git a/ldap/servers/slapd/back-ldbm/dbversion.c b/ldap/servers/slapd/back-ldbm/dbversion.c
index 4c1a56da..843c5609 100644
--- a/ldap/servers/slapd/back-ldbm/dbversion.c
+++ b/ldap/servers/slapd/back-ldbm/dbversion.c
@@ -43,7 +43,11 @@ dbversion_write(struct ldbminfo *li, const char *directory,
     PRFileDesc *prfd;
     int rc = 0;
 
-    PR_ASSERT(is_fullpath((char *)directory));
+    if (!is_fullpath((char *)directory)) {
+        rc = -1;
+        return rc;
+    }
+        
     mk_dbversion_fullpath(li, directory, filename);
   
     /* Open the file */
@@ -115,7 +119,11 @@ dbversion_read(struct ldbminfo *li, const char *directory,
     int rc = -1;
     char * iter = NULL;
 
-    PR_ASSERT(is_fullpath((char *)directory));
+    if (!is_fullpath((char *)directory)) {
+        rc = -1;
+        return rc;
+    }
+
     mk_dbversion_fullpath(li, directory, filename);
     
     ldbmversion[0]= '\0';
@@ -167,7 +175,6 @@ dbversion_exists(struct ldbminfo *li, const char *directory)
     char filename[ MAXPATHLEN*2 ];
     PRFileDesc *prfd;
 
-    PR_ASSERT(is_fullpath((char *)directory));
     mk_dbversion_fullpath(li, directory, filename);
 
     if (( prfd = PR_Open( filename, PR_RDONLY, SLAPD_DEFAULT_FILE_MODE )) ==
diff --git a/ldap/servers/slapd/back-ldbm/import-threads.c b/ldap/servers/slapd/back-ldbm/import-threads.c
index 413eaca6..653daf44 100644
--- a/ldap/servers/slapd/back-ldbm/import-threads.c
+++ b/ldap/servers/slapd/back-ldbm/import-threads.c
@@ -1881,7 +1881,7 @@ dse_conf_backup(struct ldbminfo *li, char *dest_dir)
  * [547427] index config must not change between backup and restore
  */
 int
-dse_conf_verify_core(struct ldbminfo *li, char *src_dir, char *file_name, char *filter, char *log_str)
+dse_conf_verify_core(struct ldbminfo *li, char *src_dir, char *file_name, char *filter, char *log_str, char *entry_filter)
 {
     char *filename = NULL;
     int rval = 0;
@@ -1890,6 +1890,7 @@ dse_conf_verify_core(struct ldbminfo *li, char *src_dir, char *file_name, char *
     int curr_lineno = 0;
     int finished = 0;
     int backup_entry_len = 256;
+	char *search_scope = NULL;
     Slapi_Entry **backup_entries = NULL;
     Slapi_Entry **bep = NULL;
     Slapi_Entry **curr_entries = NULL;
@@ -1928,6 +1929,12 @@ dse_conf_verify_core(struct ldbminfo *li, char *src_dir, char *file_name, char *
 
         if (!estr)
             break;
+		
+		if (entry_filter != NULL) /* Single instance restoration */
+		{
+			if (!(int)strstr(estr, entry_filter))
+				continue;
+		}
 
         e = slapi_str2entry(estr, 0);
         slapi_ch_free_string(&estr);
@@ -1951,11 +1958,23 @@ dse_conf_verify_core(struct ldbminfo *li, char *src_dir, char *file_name, char *
        *bep = NULL;
 
     pblock_init(&srch_pb);
-    slapi_search_internal_set_pb(&srch_pb, li->li_plugin->plg_dn,
+
+	if (entry_filter != NULL)
+	{ /* Single instance restoration */
+		int mylen = 0;
+		mylen = strlen(entry_filter) + strlen(li->li_plugin->plg_dn) + 2;
+        search_scope = slapi_ch_malloc(mylen);
+		sprintf(search_scope, "%s,%s", entry_filter, li->li_plugin->plg_dn);
+	} else { /* Normal restoration */
+        search_scope = slapi_ch_strdup(li->li_plugin->plg_dn);
+	}
+
+    slapi_search_internal_set_pb(&srch_pb, search_scope,
         LDAP_SCOPE_SUBTREE, filter, NULL, 0, NULL, NULL, li->li_identity, 0);
     slapi_search_internal_pb(&srch_pb);
     slapi_pblock_get(&srch_pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &curr_entries);
 
+
     if (0 != slapi_entries_diff(backup_entries, curr_entries, 1 /* test_all */,
                                 log_str, 1 /* force_update */, li->li_identity))
     {
@@ -1974,6 +1993,10 @@ out:
 
     slapi_ch_free_string(&filename);
 
+	if (search_scope)
+		slapi_ch_free(&search_scope);
+
+
     if (fd > 0)
         close(fd);
 
@@ -1981,12 +2004,39 @@ out:
 }
 
 int
-dse_conf_verify(struct ldbminfo *li, char *src_dir)
+dse_conf_verify(struct ldbminfo *li, char *src_dir, char *bename)
 {
     int rval;
-    rval  = dse_conf_verify_core(li, src_dir, DSE_INSTANCE, DSE_INSTANCE_FILTER,
-                "Instance Config");
+	char *entry_filter = NULL;
+	char *instance_entry_filter = NULL;
+	
+	if (bename != NULL) /* This was a restore of a single backend */
+	{
+		int mylen = 0;
+		/* Entry filter string */
+		mylen = strlen(bename) + strlen("cn=") + 2;
+        entry_filter = slapi_ch_malloc(mylen);
+		sprintf(entry_filter, "cn=%s", bename);
+
+		mylen = 0;
+		/* Instance search filter */
+		mylen = strlen(DSE_INSTANCE_FILTER) + strlen(bename) + strlen("(&(cn=))") + 2;
+        instance_entry_filter = slapi_ch_malloc(mylen);
+		sprintf(instance_entry_filter, "(&%s(cn=%s))", DSE_INSTANCE_FILTER, bename);
+	} else {
+	    instance_entry_filter = slapi_ch_strdup(DSE_INSTANCE_FILTER);
+	}
+
+	rval  = dse_conf_verify_core(li, src_dir, DSE_INSTANCE, instance_entry_filter,
+                "Instance Config", entry_filter);
     rval += dse_conf_verify_core(li, src_dir, DSE_INDEX, DSE_INDEX_FILTER,
-                "Index Config");
+                "Index Config", entry_filter);
+
+	if (entry_filter)
+		slapi_ch_free(&entry_filter);
+	if (instance_entry_filter)
+		slapi_ch_free(&instance_entry_filter);
+
     return rval;
 }
+
diff --git a/ldap/servers/slapd/back-ldbm/ldif2ldbm.c b/ldap/servers/slapd/back-ldbm/ldif2ldbm.c
index 1930cb51..65ef0ddb 100644
--- a/ldap/servers/slapd/back-ldbm/ldif2ldbm.c
+++ b/ldap/servers/slapd/back-ldbm/ldif2ldbm.c
@@ -2066,7 +2066,7 @@ int ldbm_back_upgradedb(Slapi_PBlock *pb)
                                                   inst_dir, MAXPATHLEN);
             backup_rval = dblayer_copy_directory(li, NULL /* task */,
                                               inst_dirp, dest_dir, 0/*backup*/,
-                                              &cnt, 0, 1);
+                                              &cnt, 0, 1, 0);
             if (inst_dirp != inst_dir)
                 slapi_ch_free_string(&inst_dirp);
             if (backup_rval < 0)
@@ -2210,7 +2210,7 @@ fail1:
                 backup_rval = dblayer_copy_directory(li, NULL /* task */,
                                                      inst->inst_dir_name,
                                                      dest_dir, 1/*restore*/,
-                                                     &cnt, 0, 1);
+                                                     &cnt, 0, 1, 0);
                 if (inst_dirp != inst_dir)
                     slapi_ch_free_string(&inst_dirp);
                 if (backup_rval < 0)
diff --git a/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h b/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h
index 4e8ed4df..0f42a28f 100644
--- a/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h
+++ b/ldap/servers/slapd/back-ldbm/proto-back-ldbm.h
@@ -93,11 +93,11 @@ int dblayer_memp_stat(struct ldbminfo *li, DB_MPOOL_STAT **gsp,DB_MPOOL_FSTAT **
 int dblayer_memp_stat_instance(ldbm_instance *inst, DB_MPOOL_STAT **gsp, DB_MPOOL_FSTAT ***fsp);
 int dblayer_backup(struct ldbminfo *li, char *destination_directory,
                    Slapi_Task *task);
-int dblayer_restore(struct ldbminfo *li, char* source_directory, Slapi_Task *task);
+int dblayer_restore(struct ldbminfo *li, char* source_directory, Slapi_Task *task, char *bename);
 int dblayer_copy_directory(struct ldbminfo *li, Slapi_Task *task,
                            char *instance_dir, char *destination_dir,
                            int restore, int *cnt, int instance_dir_flag,
-                           int indexonly);
+                           int indexonly, int resetlsns);
 int dblayer_copyfile(char* source, char * destination, int overwrite, int mode);
 int dblayer_delete_instance_dir(backend *be);
 int dblayer_delete_database(struct ldbminfo *li);
@@ -570,7 +570,7 @@ int ldbm_ancestorid_move_subtree(
  * import-threads.c
  */
 int dse_conf_backup(struct ldbminfo *li, char *destination_directory);
-int dse_conf_verify(struct ldbminfo *li, char *src_dir);
+int dse_conf_verify(struct ldbminfo *li, char *src_dir, char *bename);
 
 /*
  * ldbm_attrcrypt.c
diff --git a/ldap/servers/slapd/task.c b/ldap/servers/slapd/task.c
index 7e4bd423..dd85e41d 100644
--- a/ldap/servers/slapd/task.c
+++ b/ldap/servers/slapd/task.c
@@ -1070,7 +1070,8 @@ static int task_restore_add(Slapi_PBlock *pb, Slapi_Entry *e,
 							Slapi_Entry *eAfter, int *returncode, char *returntext, void *arg)
 {
     Slapi_Backend *be = NULL;
-    const char *cn;
+    const char *cn = NULL;
+    const char *instance_name = NULL;
     const char *archive_dir = NULL;
     const char *my_database_type = NULL;
     const char *database_type = "ldbm database";
@@ -1099,6 +1100,8 @@ static int task_restore_add(Slapi_PBlock *pb, Slapi_Entry *e,
     if (NULL != my_database_type)
         database_type = my_database_type;
 
+    instance_name = fetch_attr(e, "nsInstance", NULL);
+
     /* get backend that has archive2db and the database type matches.  */
     cookie = NULL;
     be = slapi_get_first_backend (&cookie);
@@ -1148,6 +1151,8 @@ static int task_restore_add(Slapi_PBlock *pb, Slapi_Entry *e,
     }
     mypb->pb_seq_val = slapi_ch_strdup(archive_dir);
     mypb->pb_plugin = be->be_database;
+    if (NULL != instance_name)
+        mypb->pb_instance_name = slapi_ch_strdup(instance_name);
     mypb->pb_task = task;
     mypb->pb_task_flags = TASK_RUNNING_AS_TASK;