Resolves: #466702

Summary: Memory usage research: checking in the experimental code
See also: http://directory.fedoraproject.org/wiki/Memory_Usage_Research

19 files changed, 134 insertions, 155 deletions

diff --git a/ldap/servers/slapd/back-ldbm/ancestorid.c b/ldap/servers/slapd/back-ldbm/ancestorid.c
index 0ac082b9..fb830770 100644
--- a/ldap/servers/slapd/back-ldbm/ancestorid.c
+++ b/ldap/servers/slapd/back-ldbm/ancestorid.c
@@ -373,7 +373,7 @@ static int ldbm_parentid(backend *be, DB_TXN *txn, ID id, ID *ppid)
 
  out:
     /* Free the entry value */
-    if (data.data != NULL) free(data.data);
+    slapi_ch_free(&(data.data));
 
     /* Release the id2entry file */
     if (db != NULL) {
diff --git a/ldap/servers/slapd/back-ldbm/cache.c b/ldap/servers/slapd/back-ldbm/cache.c
index 45c252b3..90fc8149 100644
--- a/ldap/servers/slapd/back-ldbm/cache.c
+++ b/ldap/servers/slapd/back-ldbm/cache.c
@@ -423,7 +423,7 @@ int cache_init(struct cache *cache, size_t maxsize, long maxentries)
 #define  CACHE_FULL(cache) \
        (((cache)->c_cursize > (cache)->c_maxsize) || \
         (((cache)->c_maxentries > 0) && \
-         ((cache)->c_curentries > cache->c_maxentries)))
+         ((cache)->c_curentries > (cache)->c_maxentries)))
 
 
 /* clear out the cache to make room for new entries
diff --git a/ldap/servers/slapd/back-ldbm/dblayer.c b/ldap/servers/slapd/back-ldbm/dblayer.c
index 18c504d2..a51abf40 100644
--- a/ldap/servers/slapd/back-ldbm/dblayer.c
+++ b/ldap/servers/slapd/back-ldbm/dblayer.c
@@ -772,6 +772,11 @@ cleanup:
 }
 #endif
 
+void dblayer_free(void *ptr)
+{
+    slapi_ch_free(&ptr);
+}
+
 static void dblayer_init_dbenv(DB_ENV *pEnv, dblayer_private *priv)
 {
     size_t  mysize;
@@ -797,7 +802,7 @@ static void dblayer_init_dbenv(DB_ENV *pEnv, dblayer_private *priv)
     pEnv->set_tx_max(pEnv, priv->dblayer_tx_max);
 
 #if 1000*DB_VERSION_MAJOR + 100*DB_VERSION_MINOR >= 3300
-    pEnv->set_alloc(pEnv, malloc, realloc, free);
+    pEnv->set_alloc(pEnv, (void *)slapi_ch_malloc, (void *)slapi_ch_realloc, dblayer_free);
 
     /* 
      * The log region is used to store filenames and so needs to be
@@ -2063,7 +2068,7 @@ int dblayer_instance_start(backend *be, int mode)
         }
 
 #if 1000*DB_VERSION_MAJOR + 100*DB_VERSION_MINOR < 3300
-        return_value = dbp->set_malloc(dbp, malloc);
+        return_value = dbp->set_malloc(dbp, (void *)slapi_ch_malloc);
         if (0 != return_value) {
             LDAPDebug(LDAP_DEBUG_ANY,
                       "dbp->set_malloc failed %d\n",
@@ -2762,7 +2767,7 @@ int dblayer_open_file(backend *be, char* indexname, int open_flag, struct attrin
         goto out;
 
 #if 1000*DB_VERSION_MAJOR + 100*DB_VERSION_MINOR < 3300
-    return_value = dbp->set_malloc(dbp, malloc);
+    return_value = dbp->set_malloc(dbp, (void *)slapi_ch_malloc);
     if (0 != return_value) {
         goto out;
     }
@@ -3727,7 +3732,7 @@ static int checkpoint_threadmain(void *param)
             /* find out which log files don't contain active txns */
             DB_CHECKPOINT_LOCK(PR_TRUE, penv->dblayer_env_lock);
             return_value = LOG_ARCHIVE(penv->dblayer_DB_ENV, &list,
-                                       0, malloc);
+                                       0, (void *)slapi_ch_malloc);
             DB_CHECKPOINT_UNLOCK(PR_TRUE, penv->dblayer_env_lock);
             checkpoint_debug_message(debug_checkpointing,
                 "Got list of logfiles not needed %d %p\n",
@@ -3990,7 +3995,7 @@ int dblayer_memp_stat(struct ldbminfo *li, DB_MPOOL_STAT **gsp,
     env = priv->dblayer_env->dblayer_DB_ENV;
     PR_ASSERT(NULL != env);
     
-    return MEMP_STAT(env, gsp, fsp, 0, malloc);
+    return MEMP_STAT(env, gsp, fsp, 0, (void *)slapi_ch_malloc);
 }
 
 /* import wants this one */
@@ -4011,7 +4016,7 @@ int dblayer_memp_stat_instance(ldbm_instance *inst, DB_MPOOL_STAT **gsp,
     }
     PR_ASSERT(NULL != env);
 
-    return MEMP_STAT(env, gsp, fsp, 0, malloc);
+    return MEMP_STAT(env, gsp, fsp, 0, (void *)slapi_ch_malloc);
 }
 
 /* Helper functions for recovery */
@@ -4954,7 +4959,7 @@ int dblayer_backup(struct ldbminfo *li, char *dest_dir, Slapi_Task *task)
         /* get the list of logfiles currently existing */
         if (priv->dblayer_enable_transactions) {
             return_value = LOG_ARCHIVE(priv->dblayer_env->dblayer_DB_ENV,
-                &listA, DB_ARCH_LOG, malloc);
+                &listA, DB_ARCH_LOG, (void *)slapi_ch_malloc);
             if ((return_value != 0) || (listA == NULL)) {
                 LDAPDebug(LDAP_DEBUG_ANY, "BAD: can't get list of logs\n",
                     0, 0, 0);
@@ -4990,9 +4995,7 @@ int dblayer_backup(struct ldbminfo *li, char *dest_dir, Slapi_Task *task)
                     slapi_task_log_notice(task,
                           "ERROR: Instance dir is empty\n");
                 }
-                if (listA) {
-                    free(listA);
-                }
+                slapi_ch_free((void **)&listA);
                 dblayer_txn_abort(li,&txn);
                 return -1;
             }
@@ -5005,9 +5008,7 @@ int dblayer_backup(struct ldbminfo *li, char *dest_dir, Slapi_Task *task)
                         "ERROR: error copying directory (%s -> %s): err=%d",
                         inst_dirp, dest_dir, return_value);
                 }
-                if (listA) {
-                    free(listA);
-                }
+                slapi_ch_free((void **)&listA);
                 dblayer_txn_abort(li,&txn);
                 if (inst_dirp != inst_dir)
                     slapi_ch_free_string(&inst_dirp);
@@ -5019,11 +5020,11 @@ int dblayer_backup(struct ldbminfo *li, char *dest_dir, Slapi_Task *task)
         if (priv->dblayer_enable_transactions) {
             /* now, get the list of logfiles that still exist */
             return_value = LOG_ARCHIVE(priv->dblayer_env->dblayer_DB_ENV,
-                &listB, DB_ARCH_LOG, malloc);
+                &listB, DB_ARCH_LOG, (void *)slapi_ch_malloc);
             if ((return_value != 0) || (listB == NULL)) {
                 LDAPDebug(LDAP_DEBUG_ANY, "ERROR: can't get list of logs\n",
                     0, 0, 0);
-                free(listA);
+                slapi_ch_free((void **)&listA);
                 dblayer_txn_abort(li,&txn);
                 return return_value;
             }
@@ -5107,14 +5108,8 @@ int dblayer_backup(struct ldbminfo *li, char *dest_dir, Slapi_Task *task)
                 slapi_ch_free((void **)&pathname2);
             }
             
-            if (listA) {
-                free(listA);
-                listA = NULL;
-            }
-            if (listB) {
-                free(listB);
-                listB = NULL;
-            }
+            slapi_ch_free((void **)&listA);
+            slapi_ch_free((void **)&listB);
         }
     } while (!ok);
 
diff --git a/ldap/servers/slapd/back-ldbm/dbtest.c b/ldap/servers/slapd/back-ldbm/dbtest.c
index 222d0ff6..703c3611 100644
--- a/ldap/servers/slapd/back-ldbm/dbtest.c
+++ b/ldap/servers/slapd/back-ldbm/dbtest.c
@@ -260,8 +260,8 @@ dbtest_traverse( DB *db, char *filename, unsigned int options, FILE *outfp )
 				fprintf( outfp, "\tdata: %s\n", (char *)data.data );
 			}
 		}
-		free( key.data );
-		free( data.data );
+		slapi_ch_free( &(key.data) );
+		slapi_ch_free( &(data.data) );
 	}
 	dbc->c_close(dbc);
 }
diff --git a/ldap/servers/slapd/back-ldbm/id2entry.c b/ldap/servers/slapd/back-ldbm/id2entry.c
index 3fa60282..e951e5e9 100644
--- a/ldap/servers/slapd/back-ldbm/id2entry.c
+++ b/ldap/servers/slapd/back-ldbm/id2entry.c
@@ -103,7 +103,7 @@ id2entry_add_ext( backend *be, struct backentry *e, back_txn *txn, int encrypt
     /* store it  */
     rc = db->put( db, db_txn, &key, &data, 0);
     /* DBDB looks like we're freeing memory allocated by another DLL, which is bad */
-    free( data.dptr );
+    slapi_ch_free( &(data.dptr) );
 
     dblayer_release_id2entry( be, db );
 
@@ -210,19 +210,30 @@ id2entry( backend *be, ID id, back_txn *txn, int *err  )
     }
     do {
         *err = db->get( db, db_txn, &key, &data, 0 );
-        if ( 0 != *err && 
-             DB_NOTFOUND != *err && DB_LOCK_DEADLOCK != *err )
+        if ( (0 != *err) && 
+             (DB_NOTFOUND != *err) && (DB_LOCK_DEADLOCK != *err) )
         {
-            LDAPDebug( LDAP_DEBUG_ANY, "id2entry error %d\n",
-                *err, 0, 0 );
+            LDAPDebug( LDAP_DEBUG_ANY, 
+                "id2entry: libdb returned error %d (%s)\n",
+                *err, dblayer_strerror( *err ), 0 );
         }
     }
-    while ( DB_LOCK_DEADLOCK == *err && txn == NULL );
+    while ( (DB_LOCK_DEADLOCK == *err) && (txn == NULL) );
 
-    if ( 0 != *err && DB_NOTFOUND != *err && DB_LOCK_DEADLOCK != *err )
+    if ( (0 != *err) && (DB_NOTFOUND != *err) && (DB_LOCK_DEADLOCK != *err) )
     {
-        LDAPDebug( LDAP_DEBUG_ANY, "id2entry get error %d\n",
-            *err, 0, 0 );
+        if ( (ENOMEM == *err) && (data.dptr == NULL) )
+        {
+            /* 
+             * Now we are setting slapi_ch_malloc and its friends to libdb
+             * by ENV->set_alloc in dblayer.c.  As long as the functions are 
+             * used by libdb, it won't reach here.
+             */
+            LDAPDebug( LDAP_DEBUG_ANY,
+                "malloc failed in libdb; terminating the server; OS error %d (%s)\n",
+                *err, slapd_system_strerror( *err ), 0 );
+            exit (1);
+        }
         dblayer_release_id2entry( be, db );
         return( NULL );
     }
@@ -274,7 +285,7 @@ id2entry( backend *be, ID id, back_txn *txn, int *err  )
         e = NULL;
     }
 
-    free( data.data );
+    slapi_ch_free( &(data.data) );
 
     dblayer_release_id2entry( be, db );
 
diff --git a/ldap/servers/slapd/back-ldbm/idl.c b/ldap/servers/slapd/back-ldbm/idl.c
index abdfe5ea..be564467 100644
--- a/ldap/servers/slapd/back-ldbm/idl.c
+++ b/ldap/servers/slapd/back-ldbm/idl.c
@@ -141,7 +141,7 @@ int idl_old_release_private(struct attrinfo *a)
 		PR_ASSERT(NULL != priv->idl_rwlock);
 		PR_DestroyRWLock(priv->idl_rwlock);
 #endif
-		free( a->ai_idl );
+		slapi_ch_free( (void **)&(a->ai_idl) );
 	}
 	return 0;
 }
@@ -909,12 +909,8 @@ idl_old_insert_key(
 				idl_check_indirect (idl, i, tmp, tmp2,
 						    "idl_insert_key", "overflow", key, id);
 
-				if ( k2.dptr != NULL ) {
-					free( k2.dptr );
-				}
-				if ( k3.dptr != NULL ) {
-					free( k3.dptr );
-				}
+				slapi_ch_free( (void **)&(k2.dptr) );
+				slapi_ch_free( (void **)&(k3.dptr) );
 				idl_free( tmp );
 				idl_free( tmp2 );
 				idl_free( idl );
@@ -998,12 +994,8 @@ idl_old_insert_key(
 				}
 			}
 
-			if ( k2.dptr != NULL ) {
-				free( k2.dptr );
-			}
-			if ( k3.dptr != NULL ) {
-				free( k3.dptr );
-			}	
+			slapi_ch_free( (void **)&(k2.dptr) );
+			slapi_ch_free( (void **)&(k3.dptr) );
 			idl_free( idl );
 			idl_free( tmp );
 			idl_unlock_list(a->ai_idl,key);
@@ -1065,12 +1057,8 @@ idl_old_insert_key(
 		break;
 	}
 
-	if ( k2.dptr != NULL ) {
-		free( k2.dptr );
-	}
-	if ( k3.dptr != NULL ) {
-		free( k3.dptr );
-	}
+	slapi_ch_free( (void **)&(k2.dptr) );
+	slapi_ch_free( (void **)&(k3.dptr) );
 	idl_free( tmp );
 	idl_free( idl );
 	idl_unlock_list(a->ai_idl,key);
@@ -1166,7 +1154,7 @@ int idl_old_store_block(
 					/* Now store the continuation block */
 					ret = idl_store(be,db,&cont_key,this_cont_block,txn);
 					idl_free(this_cont_block);
-					free(cont_key.data);
+					slapi_ch_free(&(cont_key.data));
 					if ( ret != 0 && ret != DB_LOCK_DEADLOCK )
 					{
 						LDAPDebug( LDAP_DEBUG_ANY, "idl_store_block(%s) 1 BAD %d %s\n",key->data, ret, dblayer_strerror( ret ));
@@ -1490,9 +1478,7 @@ idl_old_delete_key(
 		}
 		LDAPDebug( LDAP_DEBUG_TRACE, "<= idl_delete_key(%s,%lu) %d idl_fetch_one(contkey)\n",
 			   contkey.dptr, (u_long)id, rc );
-		if ( contkey.dptr != NULL ) {
-			free( contkey.dptr );
-		}
+		slapi_ch_free( (void **)&(contkey.dptr) );
 		return( rc );
 	}
 
@@ -1572,9 +1558,7 @@ idl_old_delete_key(
 	}
 	idl_free( idl );
 	idl_free( didl );
-	if ( contkey.dptr != NULL ) {
-		free( contkey.dptr );
-	}
+	slapi_ch_free( (void **)&(contkey.dptr) );
 	idl_unlock_list(a->ai_idl,key);
 	if ( rc != 0 && rc != DB_LOCK_DEADLOCK )
 	{
diff --git a/ldap/servers/slapd/back-ldbm/import-merge.c b/ldap/servers/slapd/back-ldbm/import-merge.c
index b2d2074d..38b622c7 100644
--- a/ldap/servers/slapd/back-ldbm/import-merge.c
+++ b/ldap/servers/slapd/back-ldbm/import-merge.c
@@ -100,12 +100,12 @@ static int import_merge_get_next_thang(backend *be, DBC *cursor, DB *db, import_
                 thang->payload.idl = idl_fetch(be, db, key, NULL, NULL, &ret);
                 PR_ASSERT(NULL != thang->payload.idl);
             } else {
-                free(value.data);
-                free(key->data);
+                slapi_ch_free(&(value.data));
+                slapi_ch_free(&(key->data));
                 key->flags = DB_DBT_MALLOC;
                 goto around; /* Just skip these */
             }
-            free(value.data);
+            slapi_ch_free(&(value.data));
         } else {
             if (DB_NOTFOUND == ret) {
                /* This means that we're at the end of the file */
@@ -189,7 +189,7 @@ static int import_merge_insert_input_queue(backend *be, import_merge_queue_entry
                     (current_entry->file_referenced_list)[fileno] = 1;
                     /* Because we merged the entries, we no longer need the
                      * key, so free it */
-                    free(key->data);
+                    slapi_ch_free(&(key->data));
                     goto done;
                 } else {
                     /* VLV case, we can see exact keys, this is not a bug ! */
@@ -573,7 +573,7 @@ static int import_merge_one_file(ImportWorkerInfo *worker, int passes,
 		    /* Write the vlv index */
 		    ret = output_file->put(output_file, NULL, &key,
 			&(thang.payload.vlv_data),0);
-		    free(thang.payload.vlv_data.data);
+		    slapi_ch_free(&(thang.payload.vlv_data.data));
 		    thang.payload.vlv_data.data = NULL;
 		} else {
 		    /* Write the IDL index */
@@ -583,7 +583,7 @@ static int import_merge_one_file(ImportWorkerInfo *worker, int passes,
 		    idl_free(thang.payload.idl);
 		    thang.payload.idl = NULL;
 		}
-		free(key.data);
+		slapi_ch_free(&(key.data));
 		key.data = NULL;
 		if (0 != ret) {
 		    /* Failed to write--- most obvious cause being out of 
diff --git a/ldap/servers/slapd/back-ldbm/import-threads.c b/ldap/servers/slapd/back-ldbm/import-threads.c
index c6303d33..b827deac 100644
--- a/ldap/servers/slapd/back-ldbm/import-threads.c
+++ b/ldap/servers/slapd/back-ldbm/import-threads.c
@@ -734,7 +734,7 @@ void index_producer(void *param)
         }
         curr_entry++;
         temp_id = id_stored_to_internal((char *)key.data);
-        free(key.data);
+        slapi_ch_free(&(key.data));
 
         /* call post-entry plugin */
         plugin_call_entryfetch_plugins((char **) &data.dptr, &data.dsize);
@@ -750,7 +750,7 @@ void index_producer(void *param)
                 inst->inst_name, (u_long)temp_id, 0);
             continue;
         } 
-        free(data.data);
+        slapi_ch_free(&(data.data));
 
         /* generate uniqueid if necessary */
         import_generate_uniqueid(job, e);
diff --git a/ldap/servers/slapd/back-ldbm/import.c b/ldap/servers/slapd/back-ldbm/import.c
index 2a2c6917..e7b1fdb4 100644
--- a/ldap/servers/slapd/back-ldbm/import.c
+++ b/ldap/servers/slapd/back-ldbm/import.c
@@ -135,7 +135,7 @@ static void import_fifo_destroy(ImportJob *job)
         job->fifo.item[i].entry = NULL;
         job->fifo.item[i].filename = NULL;
     }
-    free(job->fifo.item);
+    slapi_ch_free((void **)&job->fifo.item);
     job->fifo.item = NULL;
 }
 
@@ -277,7 +277,7 @@ static int import_attr_callback(void *node, void *param)
     info->ai = a;
     if (NULL == info->name) {
         /* Memory allocation error */
-        free(info);
+        FREE(info);
         return -1;
     }
     info->next = job->index_list;
@@ -505,15 +505,15 @@ static double import_grok_db_stats(ldbm_instance *inst)
     inst->inst_cache_hits = current_cache_hits;
 
     if (mpstat)
-        free(mpstat);
+        slapi_ch_free((void **)&mpstat);
     if (mpfstat) {
 #if 1000*DB_VERSION_MAJOR + 100*DB_VERSION_MINOR + DB_VERSION_PATCH <= 3204
             /* In DB 3.2.4 and earlier, we need to free each element */
         DB_MPOOL_FSTAT **tfsp;
         for (tfsp = mpfstat; *tfsp; tfsp++)
-        free(*tfsp);
+        slapi_ch_free((void **)tfsp);
 #endif
-        free(mpfstat);
+        slapi_ch_free((void **)&mpfstat);
     }
     }
     return cache_hit_ratio;
diff --git a/ldap/servers/slapd/back-ldbm/index.c b/ldap/servers/slapd/back-ldbm/index.c
index d7dc0b79..62df834e 100644
--- a/ldap/servers/slapd/back-ldbm/index.c
+++ b/ldap/servers/slapd/back-ldbm/index.c
@@ -187,7 +187,7 @@ index_put_idl(index_buffer_bin *bin,backend *be, DB_TXN *txn,struct attrinfo *a)
 		if (0 != ret) {
 			goto error;
 		}
-		slapi_ch_free((void**)&bin->key.data );
+		slapi_ch_free( &(bin->key.data) );
 		idl_free(bin->value);
 		/* If we're already at allids, store an allids block to prevent needless accumulation of blocks */
 		if (old_idl && ALLIDS(old_idl)) {
@@ -262,13 +262,11 @@ index_buffer_terminate(void *h)
 			idl_free(bin->value);
 			bin->value = NULL;
 		}
-		if (bin->key.data) {
-			free(bin->key.data);
-		}
+		slapi_ch_free(&(bin->key.data));
 	}
-	free(handle->bins);
+	slapi_ch_free((void **)&(handle->bins));
 	/* Now free the handle */
-	free(handle);
+	slapi_ch_free((void **)&handle);
 	return 0;
 }
 
@@ -334,7 +332,7 @@ index_buffer_insert(void *h, DBT *key, ID id,backend *be, DB_TXN *txn,struct att
 retry:
 	if (!(bin->key).data) {
 		(bin->key).size = key->size;
-		(bin->key).data = malloc(key->size);
+		(bin->key).data = slapi_ch_malloc(key->size);
 		if (NULL == bin->key.data) {
 			return -1;
 		}
@@ -1018,7 +1016,7 @@ error:
 			/* Means that we never allocated a new key */
 			;
 		} else {
-			free(saved_key);
+			slapi_ch_free(&saved_key);
 		}
 	}
 	return ret;
@@ -1248,7 +1246,7 @@ index_range_read(
         *err = dbc->c_get(dbc,&lowerkey,&data,DB_SET_RANGE); /* lowerkey, if allocated and needs freed */
         DBT_FREE_PAYLOAD(data);
         if (old_lower_key_data != lowerkey.data) {
-            free(old_lower_key_data);
+            slapi_ch_free(&old_lower_key_data);
         }
     }
     /* If the seek above fails due to DB_NOTFOUND, this means that there are no keys 
@@ -2044,7 +2042,7 @@ valuearray_minus_valuearray(
     for (bcnt = 0; b[bcnt] != NULL; bcnt++);
 
     /* allocate return array as big as a */
-    c = (Slapi_Value**)calloc(acnt+1, sizeof(Slapi_Value*));
+    c = (Slapi_Value**)slapi_ch_calloc(acnt+1, sizeof(Slapi_Value*));
     if (acnt == 0) return c;
 
     /* sort a */
diff --git a/ldap/servers/slapd/back-ldbm/instance.c b/ldap/servers/slapd/back-ldbm/instance.c
index 1e02ac4d..ef19d89f 100644
--- a/ldap/servers/slapd/back-ldbm/instance.c
+++ b/ldap/servers/slapd/back-ldbm/instance.c
@@ -60,7 +60,7 @@ int ldbm_instance_create(backend *be, char *name)
     inst = (ldbm_instance *) slapi_ch_calloc(1, sizeof(ldbm_instance));
 		
     /* Record the name of this instance. */
-    inst->inst_name = strdup(name);
+    inst->inst_name = slapi_ch_strdup(name);
 
     /* initialize the entry cache */
     if (! cache_init(&(inst->inst_cache), DEFAULT_CACHE_SIZE,
diff --git a/ldap/servers/slapd/back-ldbm/ldif2ldbm.c b/ldap/servers/slapd/back-ldbm/ldif2ldbm.c
index 31c76224..626bddee 100644
--- a/ldap/servers/slapd/back-ldbm/ldif2ldbm.c
+++ b/ldap/servers/slapd/back-ldbm/ldif2ldbm.c
@@ -463,7 +463,7 @@ int update_subordinatecounts(backend *be, import_subcount_stuff *mothers,
         key.flags = DB_DBT_MALLOC;
         ret = dbc->c_get(dbc,&key,&data,DB_NEXT_NODUP);
         if (NULL != data.data) {
-            free(data.data);
+            slapi_ch_free(&(data.data));
             data.data = NULL;
         }
         if (0 != ret) {
@@ -471,7 +471,7 @@ int update_subordinatecounts(backend *be, import_subcount_stuff *mothers,
                 ldbm_nasty(sourcefile,62,ret);
             }
             if (NULL != key.data) {
-                free(key.data);
+                slapi_ch_free(&(key.data));
                 key.data = NULL;
             }
             break;
@@ -521,7 +521,7 @@ int update_subordinatecounts(backend *be, import_subcount_stuff *mothers,
             }
         }
         if (NULL != key.data) {
-            free(key.data);
+            slapi_ch_free(&(key.data));
             key.data = NULL;
         }
     }
@@ -985,8 +985,8 @@ ldbm_back_ldbm2ldif( Slapi_PBlock *pb )
             keepgoing = 0;
         } else {
             lastid = id_stored_to_internal((char *)key.data);
-            free( key.data );
-            free( data.data );
+            slapi_ch_free( &(key.data) );
+            slapi_ch_free( &(data.data) );
             isfirst = 1;
         }
     }
@@ -1089,7 +1089,7 @@ ldbm_back_ldbm2ldif( Slapi_PBlock *pb )
 
             /* back to internal format */
             temp_id = id_stored_to_internal((char *)key.data);
-            free(key.data);
+            slapi_ch_free(&(key.data));
         }
 
         /* call post-entry plugin */
@@ -1097,7 +1097,7 @@ ldbm_back_ldbm2ldif( Slapi_PBlock *pb )
 
         ep = backentry_alloc();
         ep->ep_entry = slapi_str2entry( data.data, str2entry_options );
-        free(data.data);
+        slapi_ch_free(&(data.data));
 
         if ( (ep->ep_entry) != NULL ) {
             ep->ep_id = temp_id;
@@ -1176,7 +1176,7 @@ ldbm_back_ldbm2ldif( Slapi_PBlock *pb )
         }
 
         backentry_free( &ep );
-        free( data.data );
+        slapi_ch_free( &(data.data) );
     }
     /* DB_NOTFOUND -> successful end */
     if (return_value == DB_NOTFOUND)
@@ -1383,8 +1383,8 @@ ldbm_back_ldbm2index(Slapi_PBlock *pb)
         isfirst = 0;  /* neither a first nor a last */
     } else if (rc == 0) {
         lastid = id_stored_to_internal((char *)key.data);
-        free(key.data);
-        free(data.data);
+        slapi_ch_free(&(key.data));
+        slapi_ch_free(&(data.data));
         isfirst = 1;
     } else {
         LDAPDebug(LDAP_DEBUG_ANY,
@@ -1560,7 +1560,7 @@ ldbm_back_ldbm2index(Slapi_PBlock *pb)
                 break;
             }
             temp_id = id_stored_to_internal((char *)key.data);
-            free(key.data);
+            slapi_ch_free(&(key.data));
         }
 
         /* call post-entry plugin */
@@ -1568,7 +1568,7 @@ ldbm_back_ldbm2index(Slapi_PBlock *pb)
 
         ep = backentry_alloc();
         ep->ep_entry = slapi_str2entry( data.data, 0 );
-        free(data.data);
+        slapi_ch_free(&(data.data));
 
         if ( ep->ep_entry != NULL ) {
             ep->ep_id = temp_id;
diff --git a/ldap/servers/slapd/back-ldbm/monitor.c b/ldap/servers/slapd/back-ldbm/monitor.c
index 8282d0d3..f13b7c38 100644
--- a/ldap/servers/slapd/back-ldbm/monitor.c
+++ b/ldap/servers/slapd/back-ldbm/monitor.c
@@ -218,9 +218,9 @@ int ldbm_back_monitor_instance_search(Slapi_PBlock *pb, Slapi_Entry *e,
 #if 1000*DB_VERSION_MAJOR + 100*DB_VERSION_MINOR + DB_VERSION_PATCH <= 3204
     /* In DB 3.2.4 and earlier, we need to free each element */
     for (i = 0; mpfstat[i]; i++)
-        free(mpfstat[i]);
+        slapi_ch_free((void **)&mpfstat[i]);
 #endif
-    free(mpfstat);
+    slapi_ch_free((void **)&mpfstat);
 
     *returncode = LDAP_SUCCESS;
     return SLAPI_DSE_CALLBACK_OK;
@@ -275,16 +275,16 @@ int ldbm_back_monitor_search(Slapi_PBlock *pb, Slapi_Entry *e,
     sprintf(buf, "%u", mpstat->st_rw_evict);
     MSET("dbCacheRWEvict");
 
-    free(mpstat);
+    slapi_ch_free((void **)&mpstat);
 
     if (mpfstat) {
 #if 1000*DB_VERSION_MAJOR + 100*DB_VERSION_MINOR + DB_VERSION_PATCH <= 3204
         /* In DB 3.2.4 and earlier, we need to free each element */
         int i;
         for (i = 0; mpfstat[i]; i++)
-            free(mpfstat[i]);
+            slapi_ch_free((void **)&mpfstat[i]);
 #endif
-        free(mpfstat);
+        slapi_ch_free((void **)&mpfstat);
     }
 
     *returncode = LDAP_SUCCESS;
diff --git a/ldap/servers/slapd/back-ldbm/nextid.c b/ldap/servers/slapd/back-ldbm/nextid.c
index a1cff1a8..6e8f6316 100644
--- a/ldap/servers/slapd/back-ldbm/nextid.c
+++ b/ldap/servers/slapd/back-ldbm/nextid.c
@@ -177,35 +177,26 @@ get_ids_from_disk(backend *be)
     
     /*Get the last key*/
 	DBC *dbc = NULL;
-	DBT key = {0};                  /*For the nextid*/
+	DBT key = {0};              /*For the nextid*/
 	DBT Value = {0};
+
 	Value.flags = DB_DBT_MALLOC;
 	key.flags = DB_DBT_MALLOC;
 	return_value = id2entrydb->cursor(id2entrydb,NULL,&dbc,0);
 	if (0 == return_value) {
 		return_value = dbc->c_get(dbc,&key,&Value,DB_LAST);
-		if (0 == return_value) {
+		if ( (0 == return_value) && (NULL != key.dptr) ) {
 			inst->inst_nextid = id_stored_to_internal(key.dptr) + 1;
+		} else {
+			inst->inst_nextid = 1;	/* error case: set 1 */
 		}
-		if (NULL != key.data) {
-			free(key.data);
-		}
-		if (NULL != Value.data) {
-			free(Value.data);
-		}
+		slapi_ch_free(&(key.data));
+		slapi_ch_free(&(Value.data));
 		dbc->c_close(dbc);
+	} else {
+      inst->inst_nextid = 1;	/* when there is no id2entry, start from id 1 */
 	}
-	if ( (key.dptr == NULL) || (0 != return_value) ) {
-      inst->inst_nextid = 1;
 
-      /*close the cache*/
-      dblayer_release_id2entry( be, id2entrydb );
-
-      /* unlock */
-      PR_Unlock( inst->inst_nextid_mutex );
-      return;
-	}
-	    
   }
   
   /*close the cache*/
@@ -213,6 +204,8 @@ get_ids_from_disk(backend *be)
 
   /* unlock */
   PR_Unlock( inst->inst_nextid_mutex );
+
+  return;
 }
 
 
diff --git a/ldap/servers/slapd/back-ldbm/perfctrs.c b/ldap/servers/slapd/back-ldbm/perfctrs.c
index 578c7528..5b7c68f0 100644
--- a/ldap/servers/slapd/back-ldbm/perfctrs.c
+++ b/ldap/servers/slapd/back-ldbm/perfctrs.c
@@ -91,7 +91,7 @@ char * string_concatenate(char *a, char* b)
 	char *string = NULL;
 
 	string_length = strlen(a) + strlen(b) + 1;
-	string = malloc(string_length);
+	string = slapi_ch_malloc(string_length);
 	if (NULL == string) {
 		return string;
 	}
@@ -188,7 +188,7 @@ void perfctrs_init(struct ldbminfo *li, perfctrs_private **ret_priv)
 	/*
 	 * We need the perfctrs_private area on all platforms.
 	 */
-	priv = calloc(1,sizeof(perfctrs_private));
+	priv = (perfctrs_private *)slapi_ch_calloc(1,sizeof(perfctrs_private));
 	if (NULL == priv) {
 		return;
 	}
@@ -210,7 +210,7 @@ void perfctrs_init(struct ldbminfo *li, perfctrs_private **ret_priv)
 	/*
 	 * On other platforms, the performance counters reside in regular memory.
 	 */
-	if ( NULL == ( priv->memory = calloc( 1, sizeof( performance_counters )))) {
+	if ( NULL == ( priv->memory = slapi_ch_calloc( 1, sizeof( performance_counters )))) {
 		return;
 	}
 #endif
@@ -226,13 +226,13 @@ void perfctrs_terminate(perfctrs_private **priv, DB_ENV *db_env)
 	DB_LOG_STAT   *logstat = NULL;
 	DB_LOCK_STAT  *lockstat = NULL;
 
-	MEMP_STAT(db_env, &mpstat, NULL, DB_STAT_CLEAR, malloc);
+	MEMP_STAT(db_env, &mpstat, NULL, DB_STAT_CLEAR, (void *)slapi_ch_malloc);
 	slapi_ch_free((void**)&mpstat);
-	TXN_STAT(db_env, &txnstat, DB_STAT_CLEAR, malloc);
+	TXN_STAT(db_env, &txnstat, DB_STAT_CLEAR, (void *)slapi_ch_malloc);
 	slapi_ch_free((void**)&txnstat);
-	LOG_STAT(db_env, &logstat, DB_STAT_CLEAR, malloc);
+	LOG_STAT(db_env, &logstat, DB_STAT_CLEAR, (void *)slapi_ch_malloc);
 	slapi_ch_free((void**)&logstat);
-	LOCK_STAT(db_env, &lockstat, DB_STAT_CLEAR, malloc);
+	LOCK_STAT(db_env, &lockstat, DB_STAT_CLEAR, (void *)slapi_ch_malloc);
 	slapi_ch_free((void**)&lockstat);
 #if defined(_WIN32)
 	if (NULL != (*priv)->memory) {
@@ -246,12 +246,11 @@ void perfctrs_terminate(perfctrs_private **priv, DB_ENV *db_env)
 	}
 #else
 	if (NULL != (*priv)->memory) {
-		free((*priv)->memory);
+		slapi_ch_free(&(*priv)->memory);
 	}
 #endif
 
-	free( (*priv) );
-        (*priv) = NULL;
+	slapi_ch_free( (void **)priv );
 }
 
 /* Wait while checking for perfctr update requests */
@@ -299,31 +298,30 @@ void perfctrs_update(perfctrs_private *priv, DB_ENV *db_env)
 	if (dblayer_db_uses_logging(db_env))
 	{
 		DB_LOG_STAT *logstat = NULL;
-		ret = LOG_STAT(db_env,&logstat,0,malloc);
+		ret = LOG_STAT(db_env,&logstat,0,(void *)slapi_ch_malloc);
 		if (0 == ret) {
 			perf->log_region_wait_rate = logstat->st_region_wait;
 			perf->log_write_rate = 1024*1024*logstat->st_w_mbytes + logstat->st_w_bytes;
 			perf->log_bytes_since_checkpoint = 1024*1024*logstat->st_wc_mbytes + logstat->st_wc_bytes;
 		}
-		free(logstat);
+		slapi_ch_free((void **)&logstat);
 	}
 	if (dblayer_db_uses_transactions(db_env))
 	{
 		DB_TXN_STAT *txnstat = NULL;
-		ret = TXN_STAT(db_env, &txnstat, 0, malloc);
+		ret = TXN_STAT(db_env, &txnstat, 0, (void *)slapi_ch_malloc);
 		if (0 == ret) {
 			perf->active_txns = txnstat->st_nactive;
 			perf->commit_rate = txnstat->st_ncommits;
 			perf->abort_rate = txnstat->st_naborts;
 			perf->txn_region_wait_rate = txnstat->st_region_wait;
 		}
-		if (txnstat)
-			free(txnstat);
+		slapi_ch_free((void **)&txnstat);
 	}
 	if (dblayer_db_uses_locking(db_env))
 	{
 		DB_LOCK_STAT *lockstat = NULL;
-		ret = LOCK_STAT(db_env,&lockstat,0,malloc);
+		ret = LOCK_STAT(db_env,&lockstat,0,(void *)slapi_ch_malloc);
 		if (0 == ret) {
 			perf->lock_region_wait_rate = lockstat->st_region_wait;	
 			perf->deadlock_rate = lockstat->st_ndeadlocks;
@@ -336,12 +334,12 @@ void perfctrs_update(perfctrs_private *priv, DB_ENV *db_env)
 			perf->current_lock_objects = lockstat->st_nobjects;
 			perf->max_lock_objects = lockstat->st_maxnobjects;
 		}
-		free(lockstat);
+		slapi_ch_free((void **)&lockstat);
 	}
 	if (dblayer_db_uses_mpool(db_env))
 	{
 		DB_MPOOL_STAT	*mpstat = NULL;
-		ret = MEMP_STAT(db_env,&mpstat,NULL,0,malloc);
+		ret = MEMP_STAT(db_env,&mpstat,NULL,0,(void *)slapi_ch_malloc);
 		if (0 == ret) {
 #define ONEG  1073741824
 			perf->cache_size_bytes = mpstat->st_gbytes * ONEG + mpstat->st_bytes;
@@ -362,7 +360,7 @@ void perfctrs_update(perfctrs_private *priv, DB_ENV *db_env)
 			perf->clean_pages = mpstat->st_page_clean;			
 			perf->page_trickle_rate = mpstat->st_page_trickle;			
 			perf->cache_region_wait_rate = mpstat->st_region_wait;			
-			free(mpstat);
+			slapi_ch_free((void **)&mpstat);
 		}
 	}
 	/* Place the stats in the shared memory region */
diff --git a/ldap/servers/slapd/back-ldbm/seq.c b/ldap/servers/slapd/back-ldbm/seq.c
index 449bcf83..6e2fdfd8 100644
--- a/ldap/servers/slapd/back-ldbm/seq.c
+++ b/ldap/servers/slapd/back-ldbm/seq.c
@@ -184,7 +184,7 @@ ldbm_back_seq( Slapi_PBlock *pb )
 			return_value = dbc->c_get(dbc,&key,&data,DB_SET);
 			if (0 == return_value)
 			{
-				free(data.data);
+				slapi_ch_free(&(data.data));
 				return_value = dbc->c_get(dbc,&key,&data,DB_NEXT);
 			}
 			else
@@ -198,7 +198,7 @@ ldbm_back_seq( Slapi_PBlock *pb )
 			return_value = dbc->c_get(dbc,&key,&data,DB_SET);
 			if (0 == return_value )
 			{
-				free(data.data);
+				slapi_ch_free(&(data.data));
 				return_value = dbc->c_get(dbc,&key,&data,DB_PREV);
 			}
 			else
@@ -216,7 +216,7 @@ ldbm_back_seq( Slapi_PBlock *pb )
 				return_value = dbc->c_get(dbc,&key,&data,DB_SET_RANGE);
 				if (0 == return_value || DB_NOTFOUND == return_value)
 				{
-					free(data.data);
+					slapi_ch_free(&(data.data));
 					return_value = dbc->c_get(dbc,&key,&data,DB_PREV); 
 				}
 			}
@@ -252,11 +252,11 @@ ldbm_back_seq( Slapi_PBlock *pb )
 		} else if ( err != 0 && err != DB_NOTFOUND ) {
 		  ldbm_nasty("ldbm_back_seq database error", 1650, err);
 		}
-		free( data.data );
+		slapi_ch_free( &(data.data) );
 		if ( key.data != little_buffer && key.data != &keystring ) {
-		    free( key.data );
+		    slapi_ch_free( &(key.data) );
 		}
-		free( big_buffer );
+		slapi_ch_free_string( &big_buffer );
 	}
 
 	/* null idlist means there were no matching keys */
diff --git a/ldap/servers/slapd/back-ldbm/sort.c b/ldap/servers/slapd/back-ldbm/sort.c
index b9f3e211..e9397a88 100644
--- a/ldap/servers/slapd/back-ldbm/sort.c
+++ b/ldap/servers/slapd/back-ldbm/sort.c
@@ -395,7 +395,7 @@ int parse_sort_spec(struct berval *sort_spec_ber, sort_spec **ps)
 		}
 		/* normalize */
 		type = slapi_attr_syntax_normalize(rtype);
-		free(rtype);
+		slapi_ch_free_string(&rtype);
 
 		/* Now look for the next tag. */
 
diff --git a/ldap/servers/slapd/back-ldbm/vlv.c b/ldap/servers/slapd/back-ldbm/vlv.c
index b8ba3f1a..3bb39aff 100644
--- a/ldap/servers/slapd/back-ldbm/vlv.c
+++ b/ldap/servers/slapd/back-ldbm/vlv.c
@@ -959,14 +959,14 @@ vlv_build_candidate_list_byvalue( struct vlvIndex* p, DBC *dbc, PRUint32 length,
     err= dbc->c_get(dbc,&key,&data,DB_SET_RANGE);
     if(err==0)
     {
-        free(data.data);
+        slapi_ch_free(&(data.data));
         err= dbc->c_get(dbc,&key,&data,DB_GET_RECNO);
         if(err==0)
         {
             si= *((db_recno_t*)data.data);
             /* Records are numbered from one. */
             si--;
-            free(data.data);
+            slapi_ch_free(&(data.data));
         	LDAPDebug( LDAP_DEBUG_TRACE, "<= vlv_build_candidate_list_byvalue: Found. Index=%lu\n",si,0,0);
         }
         else
@@ -1029,7 +1029,7 @@ int vlv_build_idl(PRUint32 start, PRUint32 stop, DB *db, DBC *dbc,
     err = dbc->c_get(dbc, &key, &data, DB_SET_RECNO);
     while ((err == 0) && (recno <= stop+1)) {
         if (key.data != &recno)
-            free(key.data);
+            slapi_ch_free(&(key.data));
         idl_append(idl, *(ID *)data.data);
         if (++recno <= stop+1) {
             err = dbc->c_get(dbc, &key, &data, DB_NEXT);
@@ -1955,7 +1955,7 @@ static void replace_char(char *name, char c, char c2)
 /* similar to what the console GUI does */
 
 char *create_vlv_search_tag(const char* dn) {
-	char  *tmp2=strdup(dn);
+	char  *tmp2=slapi_ch_strdup(dn);
 
 	replace_char(tmp2,',',' ');
 	replace_char(tmp2,'"','-');
diff --git a/ldap/servers/slapd/back-ldbm/vlv_srch.c b/ldap/servers/slapd/back-ldbm/vlv_srch.c
index ace763d4..63c63485 100644
--- a/ldap/servers/slapd/back-ldbm/vlv_srch.c
+++ b/ldap/servers/slapd/back-ldbm/vlv_srch.c
@@ -673,8 +673,8 @@ vlvIndex_get_indexlength(struct vlvIndex* p, DB *db, back_txn *txn)
             err= dbc->c_get(dbc,&key,&data,DB_LAST);
             if(err==0)
             {
-                free(key.data); key.data= NULL;
-                free(data.data); data.data= NULL;
+                slapi_ch_free(&(key.data));
+                slapi_ch_free(&(data.data));
                 err= dbc->c_get(dbc,&key,&data,DB_GET_RECNO);
                 if(err==0)
                 {
@@ -682,7 +682,7 @@ vlvIndex_get_indexlength(struct vlvIndex* p, DB *db, back_txn *txn)
                     p->vlv_indexlength_cached= 1;
                     p->vlv_indexlength= *((db_recno_t*)data.data);
                     PR_Unlock(p->vlv_indexlength_lock);
-                    free(data.data);
+                    slapi_ch_free(&(data.data));
                 }
             }
             dbc->c_close(dbc);