storage/bdb untabify, code alignment to limit to 80 characters per line.

Signed-off-by: Anand V. Avati <avati@amp.gluster.com>

1 files changed, 1111 insertions, 1128 deletions

diff --git a/xlators/storage/bdb/src/bdb-ll.c b/xlators/storage/bdb/src/bdb-ll.c
index 5a79987ae..cd2d1ac49 100644
--- a/xlators/storage/bdb/src/bdb-ll.c
+++ b/xlators/storage/bdb/src/bdb-ll.c
@@ -20,7 +20,7 @@
 #include <libgen.h>
 #include "bdb.h"
 #include <list.h>
-/* 
+/*
  * implement the procedures to interact with bdb */
 
 /****************************************************************
@@ -28,26 +28,23 @@
  * General wrappers and utility procedures for bdb xlator
  *
  ****************************************************************/
-#define BDB_LL_PAGE_SIZE_DEFAULT    4096
-#define BDB_LL_PAGE_SIZE_MIN    4096
-#define BDB_LL_PAGE_SIZE_MAX    65536
 
 ino_t
 bdb_inode_transform (ino_t parent,
                      bctx_t *bctx)
 {
-	struct bdb_private *private = NULL;
-	ino_t               ino = -1;
-	
-	GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
+        struct bdb_private *private = NULL;
+        ino_t               ino = -1;
+
+        GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
 
-	private = bctx->table->this->private;
+        private = bctx->table->this->private;
 
-	LOCK (&private->ino_lock);
-	ino = ++private->next_ino;
-	UNLOCK (&private->ino_lock);
+        LOCK (&private->ino_lock);
+        ino = ++private->next_ino;
+        UNLOCK (&private->ino_lock);
 out:
-	return ino;
+        return ino;
 }
 
 
@@ -71,132 +68,132 @@ out:
 static DB *
 bdb_db_open (bctx_t *bctx)
 {
-	DB *storage_dbp = NULL;
-	int32_t op_ret = -1;
-	bctx_table_t *table = NULL;
-	
-	GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
-
-	table = bctx->table;
-	GF_VALIDATE_OR_GOTO ("bdb-ll", table, out);
-
-	/* we have to do the following, we can't deny someone of db_open ;) */
-	op_ret = db_create (&storage_dbp, table->dbenv, 0);
-	if (op_ret != 0) {
-		gf_log ("bdb-ll", GF_LOG_ERROR,
-			"failed to do db_create for directory %s (%s)",
-			bctx->directory, db_strerror (op_ret));
-		storage_dbp = NULL;
-		goto out;
-	} 
-
-	if (table->page_size) {
-		op_ret = storage_dbp->set_pagesize (storage_dbp, 
-						    table->page_size);
-		if (op_ret != 0) {
-			gf_log ("bdb-ll", GF_LOG_ERROR, 
-				"failed to set the page_size (%"PRIu64") for directory %s (%s)", 
-				table->page_size, bctx->directory, db_strerror (op_ret));
-		} else {
-			gf_log ("bdb-ll", GF_LOG_DEBUG,
-				"page-size (%"PRIu64") set on DB", 
-				table->page_size);
-		}
-	}
-     
-	op_ret = storage_dbp->open (storage_dbp,
-				    NULL,
-				    bctx->db_path,
-				    NULL,
-				    table->access_mode,
-				    table->dbflags,
-				    0);
-	if (op_ret != 0 ) {
-		gf_log ("bdb-ll",
-			GF_LOG_ERROR,
-			"failed to open storage-db for directory %s (%s)", 
-			bctx->db_path, db_strerror (op_ret));
-		storage_dbp = NULL;
-	} 
+        DB *storage_dbp = NULL;
+        int32_t op_ret = -1;
+        bctx_table_t *table = NULL;
+
+        GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
+
+        table = bctx->table;
+        GF_VALIDATE_OR_GOTO ("bdb-ll", table, out);
+
+        /* we have to do the following, we can't deny someone of db_open ;) */
+        op_ret = db_create (&storage_dbp, table->dbenv, 0);
+        if (op_ret != 0) {
+                gf_log ("bdb-ll", GF_LOG_ERROR,
+                        "failed to do db_create for directory %s (%s)",
+                        bctx->directory, db_strerror (op_ret));
+                storage_dbp = NULL;
+                goto out;
+        }
+
+        if (table->page_size) {
+                op_ret = storage_dbp->set_pagesize (storage_dbp,
+                                                    table->page_size);
+                if (op_ret != 0) {
+                        gf_log ("bdb-ll", GF_LOG_ERROR,
+                                "failed to set the page_size (%"PRIu64") for "
+                                "directory %s (%s)",
+                                table->page_size, bctx->directory,
+                                db_strerror (op_ret));
+                } else {
+                        gf_log ("bdb-ll", GF_LOG_DEBUG,
+                                "page-size (%"PRIu64") set on DB",
+                                table->page_size);
+                }
+        }
+
+        op_ret = storage_dbp->open (storage_dbp,
+                                    NULL,
+                                    bctx->db_path,
+                                    NULL,
+                                    table->access_mode,
+                                    table->dbflags,
+                                    0);
+        if (op_ret != 0 ) {
+                gf_log ("bdb-ll",
+                        GF_LOG_ERROR,
+                        "failed to open storage-db for directory %s (%s)",
+                        bctx->db_path, db_strerror (op_ret));
+                storage_dbp = NULL;
+        }
 
 out:
-	return storage_dbp;
+        return storage_dbp;
 }
 
 
 
 int32_t
 bdb_cursor_close (bctx_t *bctx,
-		  DBC *cursorp)
+                  DBC *cursorp)
 {
-	int32_t ret = -1;
-	
-	GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
-	GF_VALIDATE_OR_GOTO ("bdb-ll", cursorp, out);
+        int32_t ret = -1;
+
+        GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
+        GF_VALIDATE_OR_GOTO ("bdb-ll", cursorp, out);
 
-	LOCK (&bctx->lock);
-	{
+        LOCK (&bctx->lock);
+        {
 #ifdef HAVE_BDB_CURSOR_GET
-		ret = cursorp->close (cursorp);
+                ret = cursorp->close (cursorp);
 #else
-		ret = cursorp->c_close (cursorp);
+                ret = cursorp->c_close (cursorp);
 #endif
-		if ((ret != 0)) {
-			gf_log ("bdb-ll",
-				GF_LOG_ERROR,
-				"failed to close db cursor for directory %s (%s)",
-				bctx->directory, db_strerror (ret));
-		}
-	}
-	UNLOCK (&bctx->lock);
-
-out: 
-	return ret;
+                if ((ret != 0)) {
+                        gf_log ("bdb-ll", GF_LOG_ERROR,
+                                "failed to close db cursor for directory "
+                                "%s (%s)",
+                                bctx->directory, db_strerror (ret));
+                }
+        }
+        UNLOCK (&bctx->lock);
+
+out:
+        return ret;
 }
 
 
 int32_t
 bdb_cursor_open (bctx_t *bctx,
-		 DBC **cursorpp)
+                 DBC **cursorpp)
 {
-	int32_t ret = -1;
-	
-	GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
-	GF_VALIDATE_OR_GOTO ("bdb-ll", cursorpp, out);
-
-	LOCK (&bctx->lock);
-	{
-		if (bctx->dbp) {
-			/* do nothing, just continue */
-			ret = 0;
-		} else {
-			bctx->dbp = bdb_db_open (bctx);
-			if (!bctx->dbp) {
-				gf_log ("bdb-ll",
-					GF_LOG_ERROR,
-					"failed to open storage db for %s", 
-					bctx->directory);
-				ret = -1;
-			} else {
-				ret = 0;
-			}
-		}
-  
-		if (ret == 0) {
-			/* all set, lets open cursor */
-			ret = bctx->dbp->cursor (bctx->dbp, NULL, cursorpp, 0);
-			if (ret != 0) {
-				gf_log ("bdb-ll",
-					GF_LOG_ERROR,
-					"failed to create a cursor for %s (%s)", 
-					bctx->directory, db_strerror (ret));
-			}
-		}
-	}
-	UNLOCK (&bctx->lock);
+        int32_t ret = -1;
+
+        GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
+        GF_VALIDATE_OR_GOTO ("bdb-ll", cursorpp, out);
+
+        LOCK (&bctx->lock);
+        {
+                if (bctx->dbp) {
+                        /* do nothing, just continue */
+                        ret = 0;
+                } else {
+                        bctx->dbp = bdb_db_open (bctx);
+                        if (!bctx->dbp) {
+                                gf_log ("bdb-ll", GF_LOG_ERROR,
+                                        "failed to open storage db for %s",
+                                        bctx->directory);
+                                ret = -1;
+                        } else {
+                                ret = 0;
+                        }
+                }
+
+                if (ret == 0) {
+                        /* all set, lets open cursor */
+                        ret = bctx->dbp->cursor (bctx->dbp, NULL, cursorpp, 0);
+                        if (ret != 0) {
+                                gf_log ("bdb-ll", GF_LOG_ERROR,
+                                        "failed to create a cursor for %s (%s)",
+                                        bctx->directory, db_strerror (ret));
+                        }
+                }
+        }
+        UNLOCK (&bctx->lock);
 
 out:
-	return ret;
+        return ret;
 }
 
 
@@ -205,167 +202,163 @@ static bdb_cache_t *
 bdb_cache_lookup (bctx_t *bctx,
                   char *path)
 {
-	bdb_cache_t *bcache = NULL; 
-	bdb_cache_t *trav   = NULL;
-	char        *key    = NULL;
-	
-	GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
-	GF_VALIDATE_OR_GOTO ("bdb-ll", path, out);
-
-	MAKE_KEY_FROM_PATH (key, path);
-
-	LOCK (&bctx->lock);
-	{
-		list_for_each_entry (trav, &bctx->c_list, c_list) {
-			if (!strcmp (trav->key, key)){
-				bcache = trav;
-				break;
-			}
-		}
-	}
-	UNLOCK (&bctx->lock);
+        bdb_cache_t *bcache = NULL;
+        bdb_cache_t *trav   = NULL;
+        char        *key    = NULL;
+
+        GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
+        GF_VALIDATE_OR_GOTO ("bdb-ll", path, out);
+
+        MAKE_KEY_FROM_PATH (key, path);
+
+        LOCK (&bctx->lock);
+        {
+                list_for_each_entry (trav, &bctx->c_list, c_list) {
+                        if (!strcmp (trav->key, key)){
+                                bcache = trav;
+                                break;
+                        }
+                }
+        }
+        UNLOCK (&bctx->lock);
 
 out:
-	return bcache;
+        return bcache;
 }
 
 static int32_t
-bdb_cache_insert (bctx_t *bctx, 
-		  DBT *key, 
-		  DBT *data)
+bdb_cache_insert (bctx_t *bctx,
+                  DBT *key,
+                  DBT *data)
 {
-	bdb_cache_t *bcache = NULL;
-	int32_t ret = -1;
-
-	GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
-	GF_VALIDATE_OR_GOTO ("bdb-ll", key, out);
-	GF_VALIDATE_OR_GOTO ("bdb-ll", data, out);
-
-	LOCK (&bctx->lock);
-	{
-		if (bctx->c_count > 5) {
-			/* most of the times, we enter here */
-			/* FIXME: ugly, not supposed to disect any of the
-			 * 'struct list_head' directly */
-			if (!list_empty (&bctx->c_list)) {
-				bcache = list_entry (bctx->c_list.prev, bdb_cache_t, c_list);
-				list_del_init (&bcache->c_list);
-			}
-			if (bcache->key) {
-				free (bcache->key);
-				bcache->key = strdup ((char *)key->data);
-				GF_VALIDATE_OR_GOTO ("bdb-ll", bcache->key, unlock);
-			} else {
-				/* should never come here */
-				gf_log ("bdb-ll",
-					GF_LOG_CRITICAL,
-					"bcache->key (null)");
-			} /* if(bcache->key)...else */
-			if (bcache->data) {
-				free (bcache->data);
-				bcache->data = memdup (data->data, data->size);
-				GF_VALIDATE_OR_GOTO ("bdb-ll", bcache->data, unlock);
-				bcache->size = data->size;
-			} else {
-				/* should never come here */
-				gf_log ("bdb-ll",
-					GF_LOG_CRITICAL,
-					"bcache->data (null)");
-			} /* if(bcache->data)...else */
-			list_add (&bcache->c_list, &bctx->c_list);
-			ret = 0;
-		} else {
-			/* we will be entering here very rarely */
-			bcache = CALLOC (1, sizeof (*bcache));    
-			GF_VALIDATE_OR_GOTO ("bdb-ll", bcache, unlock);
-			bcache->key = strdup ((char *)(key->data));
-			GF_VALIDATE_OR_GOTO ("bdb-ll", bcache->key, unlock);
-			bcache->data = memdup (data->data, data->size);
-			GF_VALIDATE_OR_GOTO ("bdb-ll", bcache->data, unlock);
-			bcache->size = data->size;
-			list_add (&bcache->c_list, &bctx->c_list);
-			bctx->c_count++;
-			ret = 0;
-		} /* if(private->c_count < 5)...else */
-	}
+        bdb_cache_t *bcache = NULL;
+        int32_t ret = -1;
+
+        GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
+        GF_VALIDATE_OR_GOTO ("bdb-ll", key, out);
+        GF_VALIDATE_OR_GOTO ("bdb-ll", data, out);
+
+        LOCK (&bctx->lock);
+        {
+                if (bctx->c_count > 5) {
+                        /* most of the times, we enter here */
+                        /* FIXME: ugly, not supposed to disect any of the
+                         * 'struct list_head' directly */
+                        if (!list_empty (&bctx->c_list)) {
+                                bcache = list_entry (bctx->c_list.prev, bdb_cache_t, c_list);
+                                list_del_init (&bcache->c_list);
+                        }
+                        if (bcache->key) {
+                                free (bcache->key);
+                                bcache->key = strdup ((char *)key->data);
+                                GF_VALIDATE_OR_GOTO ("bdb-ll", bcache->key, unlock);
+                        } else {
+                                /* should never come here */
+                                gf_log ("bdb-ll", GF_LOG_CRITICAL,
+                                        "bcache->key (null)");
+                        } /* if(bcache->key)...else */
+                        if (bcache->data) {
+                                free (bcache->data);
+                                bcache->data = memdup (data->data, data->size);
+                                GF_VALIDATE_OR_GOTO ("bdb-ll", bcache->data, unlock);
+                                bcache->size = data->size;
+                        } else {
+                                /* should never come here */
+                                gf_log ("bdb-ll", GF_LOG_CRITICAL,
+                                        "bcache->data (null)");
+                        } /* if(bcache->data)...else */
+                        list_add (&bcache->c_list, &bctx->c_list);
+                        ret = 0;
+                } else {
+                        /* we will be entering here very rarely */
+                        bcache = CALLOC (1, sizeof (*bcache));
+                        GF_VALIDATE_OR_GOTO ("bdb-ll", bcache, unlock);
+                        bcache->key = strdup ((char *)(key->data));
+                        GF_VALIDATE_OR_GOTO ("bdb-ll", bcache->key, unlock);
+                        bcache->data = memdup (data->data, data->size);
+                        GF_VALIDATE_OR_GOTO ("bdb-ll", bcache->data, unlock);
+                        bcache->size = data->size;
+                        list_add (&bcache->c_list, &bctx->c_list);
+                        bctx->c_count++;
+                        ret = 0;
+                } /* if(private->c_count < 5)...else */
+        }
 unlock:
-	UNLOCK (&bctx->lock);
+        UNLOCK (&bctx->lock);
 out:
-	return ret;
+        return ret;
 }
 
 static int32_t
 bdb_cache_delete (bctx_t *bctx,
-		  char *key)
+                  char *key)
 {
-	bdb_cache_t *bcache = NULL; 
-	bdb_cache_t *trav   = NULL;
-	
-	GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
-	GF_VALIDATE_OR_GOTO ("bdb-ll", key, out);
-
-	LOCK (&bctx->lock);
-	{
-		list_for_each_entry (trav, &bctx->c_list, c_list) {
-			if (!strcmp (trav->key, key)){
-				bctx->c_count--;
-				bcache = trav;
-				break;
-			}
-		}
-  
-		if (bcache) {
-			list_del_init (&bcache->c_list);
-			free (bcache->key);
-			free (bcache->data);
-			free (bcache);
-		}
-	}
-	UNLOCK (&bctx->lock);
+        bdb_cache_t *bcache = NULL;
+        bdb_cache_t *trav   = NULL;
+
+        GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
+        GF_VALIDATE_OR_GOTO ("bdb-ll", key, out);
+
+        LOCK (&bctx->lock);
+        {
+                list_for_each_entry (trav, &bctx->c_list, c_list) {
+                        if (!strcmp (trav->key, key)){
+                                bctx->c_count--;
+                                bcache = trav;
+                                break;
+                        }
+                }
+
+                if (bcache) {
+                        list_del_init (&bcache->c_list);
+                        free (bcache->key);
+                        free (bcache->data);
+                        free (bcache);
+                }
+        }
+        UNLOCK (&bctx->lock);
 
 out:
-	return 0;
+        return 0;
 }
 
 void *
-bdb_db_stat (bctx_t *bctx, 
-	     DB_TXN *txnid,
-	     uint32_t flags)
+bdb_db_stat (bctx_t *bctx,
+             DB_TXN *txnid,
+             uint32_t flags)
 {
-	DB     *storage = NULL;
-	void   *stat    = NULL;
-	int32_t ret     = -1;
-
-	LOCK (&bctx->lock);
-	{
-		if (bctx->dbp == NULL) {
-			bctx->dbp = bdb_db_open (bctx);
-			storage = bctx->dbp;
-		} else {
-			/* we are just fine, lets continue */
-			storage = bctx->dbp;
-		} /* if(bctx->dbp==NULL)...else */
-	}
-	UNLOCK (&bctx->lock);
-
-	GF_VALIDATE_OR_GOTO ("bdb-ll", storage, out);
-
-	ret = storage->stat (storage, txnid, &stat, flags);
-    
-	if (ret != 0) {
-		gf_log ("bdb-ll",
-			GF_LOG_ERROR,
-			"failed to do DB->stat() on db file %s: %s", 
-			bctx->db_path, db_strerror (ret));
-	} else {
-		gf_log ("bdb-ll",
-			GF_LOG_DEBUG,
-			"successfully called DB->stat() on db file %s", 
-			bctx->db_path);
-	}
+        DB     *storage = NULL;
+        void   *stat    = NULL;
+        int32_t ret     = -1;
+
+        LOCK (&bctx->lock);
+        {
+                if (bctx->dbp == NULL) {
+                        bctx->dbp = bdb_db_open (bctx);
+                        storage = bctx->dbp;
+                } else {
+                        /* we are just fine, lets continue */
+                        storage = bctx->dbp;
+                } /* if(bctx->dbp==NULL)...else */
+        }
+        UNLOCK (&bctx->lock);
+
+        GF_VALIDATE_OR_GOTO ("bdb-ll", storage, out);
+
+        ret = storage->stat (storage, txnid, &stat, flags);
+
+        if (ret != 0) {
+                gf_log ("bdb-ll", GF_LOG_ERROR,
+                        "failed to do DB->stat() on db file %s: %s",
+                        bctx->db_path, db_strerror (ret));
+        } else {
+                gf_log ("bdb-ll", GF_LOG_DEBUG,
+                        "successfully called DB->stat() on db file %s",
+                        bctx->db_path);
+        }
 out:
-	return stat;
-  
+        return stat;
+
 }
 
 /* bdb_storage_get - retrieve a key/value pair corresponding to @path from the corresponding
@@ -374,18 +367,18 @@ out:
  * @bctx: bctx_t * corresponding to the parent directory of @path. (should always be a valid
  *        bctx).  bdb_storage_get should never be called if @bctx = NULL.
  * @txnid: NULL if bdb_storage_get is not embedded in an explicit transaction or a valid
- *         DB_TXN *, when embedded in an explicit transaction.        
+ *         DB_TXN *, when embedded in an explicit transaction.
  * @path: path of the file to read from (translated to a database key using MAKE_KEY_FROM_PATH)
  * @buf: char ** - pointer to a pointer to char. a read buffer is created in this procedure
  *       and pointer to the buffer is passed through @buf to the caller.
  * @size: size of the file content to be read.
  * @offset: offset from which the file content to be read.
  *
- * NOTE: bdb_storage_get tries to open DB, if @bctx->dbp == NULL (@bctx->dbp == NULL, 
+ * NOTE: bdb_storage_get tries to open DB, if @bctx->dbp == NULL (@bctx->dbp == NULL,
  *      nobody has opened DB till now or DB was closed by bdb_table_prune()).
  *
  * NOTE: if private->cache is set (bdb xlator's internal caching enabled), then bdb_storage_get
- *      first looks up the cache for key/value pair. if bdb_lookup_cache fails, then only 
+ *      first looks up the cache for key/value pair. if bdb_lookup_cache fails, then only
  *      DB->get() is called. also,  inserts a newly read key/value pair to cache through
  *      bdb_insert_to_cache.
  *
@@ -395,300 +388,302 @@ out:
  */
 int32_t
 bdb_db_get (bctx_t *bctx,
-	    DB_TXN *txnid,
-	    const char *path,
-	    char **buf,
-	    size_t size,
-	    off_t offset)
+            DB_TXN *txnid,
+            const char *path,
+            char **buf,
+            size_t size,
+            off_t offset)
 {
-	DB          *storage    = NULL;
-	DBT          key        = {0,};
-	DBT          value      = {0,};
-	int32_t      ret        = -1;
-	char        *key_string = NULL;
-	bdb_cache_t *bcache     = NULL;
-	int32_t      db_flags   = 0;
-	uint8_t      need_break = 0;
-	int32_t      retries    = 1;
-	
-	GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
-	GF_VALIDATE_OR_GOTO ("bdb-ll", path, out);
-
-	MAKE_KEY_FROM_PATH (key_string, path);
-	
-	if (bctx->cache && 
-	    ((bcache = bdb_cache_lookup (bctx, key_string)) != NULL)) {
-		if (buf) {
-			*buf = CALLOC (1, bcache->size);
-			GF_VALIDATE_OR_GOTO ("bdb-ll", buf, out);
-			memcpy (*buf, (bcache->data + offset), bcache->size);
-		}
-		ret = bcache->size;
-	} else {
-		LOCK (&bctx->lock);
-		{
-			if (bctx->dbp == NULL) {
-				bctx->dbp = bdb_db_open (bctx);
-				storage = bctx->dbp;
-			} else {
-				/* we are just fine, lets continue */
-				storage = bctx->dbp;
-			} /* if(bctx->dbp==NULL)...else */
-		}
-		UNLOCK (&bctx->lock);
-		
-		GF_VALIDATE_OR_GOTO ("bdb-ll", storage, out);
-
-		key.data = (char *)key_string;
-		key.size = strlen (key_string);
-		key.flags = DB_DBT_USERMEM;
-      
-		if (bctx->cache){
-			/* we are called to return the size of the file */
-			value.flags = DB_DBT_MALLOC;
-		} else {
-			if (size) {
-				value.flags = DB_DBT_MALLOC | DB_DBT_PARTIAL;
-			} else {
-				value.flags = DB_DBT_MALLOC;
-			}
-			value.dlen = size;
-			value.doff = offset;
-		}
-      
-		do {
-			/* TODO: we prefer to give our own buffer to value.data
-			 * and ask bdb to fill in it */
-			ret = storage->get (storage, txnid, &key, &value, db_flags);
-        
-			if (ret == DB_NOTFOUND) {
-				gf_log ("bdb-ll",
-					GF_LOG_DEBUG,
-					"failed to do DB->get() for key: %s."
-					" key not found in storage DB", key_string);
-				ret = -1;
-				need_break = 1;
-			} else if (ret == DB_LOCK_DEADLOCK) {
-				retries++;
-				gf_log ("bdb-ll",
-					GF_LOG_ERROR,
-					"deadlock detected in DB->put. retrying DB->put (%d)", 
-					retries);
-			}else if (ret == 0) {
-				/* successfully read data, lets set everything in place
-				 * and return */
-				if (buf) {
-					*buf = CALLOC (1, value.size);
-					ERR_ABORT (*buf);
-					memcpy (*buf, value.data, value.size);
-				}
-				ret = value.size;
-				if (bctx->cache)
-					bdb_cache_insert (bctx, &key, &value);
-				free (value.data);
-				need_break = 1;
-			} else {
-				gf_log ("bdb-ll",
-					GF_LOG_ERROR,
-					"failed to do DB->get() for key %s: %s", 
-					key_string, db_strerror (ret));
-				ret = -1;
-				need_break = 1;
-			}
-		} while (!need_break);
-	}
-out:  
-	return ret;
+        DB          *storage    = NULL;
+        DBT          key        = {0,};
+        DBT          value      = {0,};
+        int32_t      ret        = -1;
+        char        *key_string = NULL;
+        bdb_cache_t *bcache     = NULL;
+        int32_t      db_flags   = 0;
+        uint8_t      need_break = 0;
+        int32_t      retries    = 1;
+
+        GF_VALIDATE_OR_GOTO ("bdb-ll", bctx, out);
+        GF_VALIDATE_OR_GOTO ("bdb-ll", path, out);
+
+        MAKE_KEY_FROM_PATH (key_string, path);
+
+        if (bctx->cache &&
+            ((bcache = bdb_cache_lookup (bctx, key_string)) != NULL)) {
+                if (buf) {
+                        *buf = CALLOC (1, bcache->size);
+                        GF_VALIDATE_OR_GOTO ("bdb-ll", buf, out);
+                        memcpy (*buf, (bcache->data + offset), bcache->size);
+                }
+                ret = bcache->size;
+        } else {
+                LOCK (&bctx->lock);
+                {
+                        if (bctx->dbp == NULL) {
+                                bctx->dbp = bdb_db_open (bctx);
+                                storage = bctx->dbp;
+                        } else {
+                                /* we are just fine, lets continue */
+                                storage = bctx->dbp;
+                        } /* if(bctx->dbp==NULL)...else */
+                }
+                UNLOCK (&bctx->lock);
+
+                GF_VALIDATE_OR_GOTO ("bdb-ll", storage, out);
+
+                key.data = (char *)key_string;
+                key.size = strlen (key_string);
+                key.flags = DB_DBT_USERMEM;
+
+                if (bctx->cache){
+                        /* we are called to return the size of the file */
+                        value.flags = DB_DBT_MALLOC;
+                } else {
+                        if (size) {
+                                value.flags = DB_DBT_MALLOC | DB_DBT_PARTIAL;
+                        } else {
+                                value.flags = DB_DBT_MALLOC;
+                        }
+                        value.dlen = size;
+                        value.doff = offset;
+                }
+
+                do {
+                        /* TODO: we prefer to give our own buffer to value.data
+                         * and ask bdb to fill in it */
+                        ret = storage->get (storage, txnid, &key, &value,
+                                            db_flags);
+
+                        if (ret == DB_NOTFOUND) {
+                                gf_log ("bdb-ll", GF_LOG_DEBUG,
+                                        "failed to do DB->get() for key: %s."
+                                        " key not found in storage DB",
+                                        key_string);
+                                ret = -1;
+                                need_break = 1;
+                        } else if (ret == DB_LOCK_DEADLOCK) {
+                                retries++;
+                                gf_log ("bdb-ll", GF_LOG_ERROR,
+                                        "deadlock detected in DB->put. retrying"
+                                        " DB->put (%d)", retries);
+                        }else if (ret == 0) {
+                                /* successfully read data, lets set everything
+                                 * in place and return */
+                                if (buf) {
+                                        *buf = CALLOC (1, value.size);
+                                        ERR_ABORT (*buf);
+                                        memcpy (*buf, value.data, value.size);
+                                }
+                                ret = value.size;
+                                if (bctx->cache)
+                                        bdb_cache_insert (bctx, &key, &value);
+                                free (value.data);
+                                need_break = 1;
+                        } else {
+                                gf_log ("bdb-ll",
+                                        GF_LOG_ERROR,
+                                        "failed to do DB->get() for key %s: %s",
+                                        key_string, db_strerror (ret));
+                                ret = -1;
+                                need_break = 1;
+                        }
+                } while (!need_break);
+        }
+out:
+        return ret;
 }/* bdb_db_get */
 
 /* bdb_storage_put - insert a key/value specified to the corresponding DB.
  *
- * @bctx: bctx_t * corresponding to the parent directory of @path. 
- *        (should always be a valid bctx). bdb_storage_put should never be called if @bctx = NULL.
- * @txnid: NULL if bdb_storage_put is not embedded in an explicit transaction or a valid
- *         DB_TXN *, when embedded in an explicit transaction. 
+ * @bctx: bctx_t * corresponding to the parent directory of @path.
+ *        (should always be a valid bctx). bdb_storage_put should never be
+ *         called if @bctx = NULL.
+ * @txnid: NULL if bdb_storage_put is not embedded in an explicit transaction
+ *         or a valid DB_TXN *, when embedded in an explicit transaction.
  * @key_string: key of the database entry.
  * @buf: pointer to the buffer data to be written as data for @key_string.
  * @size: size of @buf.
  * @offset: offset in the key's data to be modified with provided data.
- * @flags: valid flags are BDB_TRUNCATE_RECORD (to reduce the data of @key_string to 0 size).
+ * @flags: valid flags are BDB_TRUNCATE_RECORD (to reduce the data of
+ *         @key_string to 0 size).
  *
- * NOTE: bdb_storage_put tries to open DB, if @bctx->dbp == NULL (@bctx->dbp == NULL, 
- *      nobody has opened DB till now or DB was closed by bdb_table_prune()).
+ * NOTE: bdb_storage_put tries to open DB, if @bctx->dbp == NULL
+ *      (@bctx->dbp == NULL, nobody has opened DB till now or DB was closed by
+ *       bdb_table_prune()).
  *
  * NOTE: bdb_storage_put deletes the key/value from bdb xlator's internal cache.
  *
  * return: 0 on success or -1 on error.
  *
- * also see: bdb_cache_delete for details on how a cached key/value pair is removed.
+ * also see: bdb_cache_delete for details on how a cached key/value pair is
+ * removed.
  */
 int32_t
 bdb_db_put (bctx_t *bctx,
-	    DB_TXN *txnid,
-	    const char *key_string,
-	    const char *buf,
-	    size_t size,
-	    off_t offset,
-	    int32_t flags)
+            DB_TXN *txnid,
+            const char *key_string,
+            const char *buf,
+            size_t size,
+            off_t offset,
+            int32_t flags)
 {
-	DB     *storage = NULL;
-	DBT     key = {0,}, value = {0,};
-	int32_t ret = -1;
-	int32_t db_flags = DB_AUTO_COMMIT;
-	uint8_t need_break = 0;
-	int32_t retries = 1;
-
-	LOCK (&bctx->lock);
-	{
-		if (bctx->dbp == NULL) {
-			bctx->dbp = bdb_db_open (bctx);
-			storage = bctx->dbp;
-		} else {
-			/* we are just fine, lets continue */
-			storage = bctx->dbp;
-		}
-	}
-	UNLOCK (&bctx->lock);
-	
-	GF_VALIDATE_OR_GOTO ("bdb-ll", storage, out);
-
-	if (bctx->cache) {
-		ret = bdb_cache_delete (bctx, (char *)key_string);
-		GF_VALIDATE_OR_GOTO ("bdb-ll", (ret == 0), out);
-	}
-
-	key.data = (void *)key_string;
-	key.size = strlen (key_string);
-    
-	/* NOTE: bdb lets us expand the file, suppose value.size > value.len, then value.len bytes
-	 *      from value.doff offset and value.size bytes will be written from value.doff and 
-	 *      data from value.doff + value.dlen will be pushed value.doff + value.size
-	 */
-	value.data = (void *)buf;
-
-	if (flags & BDB_TRUNCATE_RECORD) {
-		value.size = size;
-		value.doff = 0;
-		value.dlen = offset;
-	} else {
-		value.size = size;
-		value.dlen = size;
-		value.doff = offset;
-	}
-	value.flags = DB_DBT_PARTIAL;
-	if (buf == NULL && size == 0) 
-		/* truncate called us */
-		value.flags = 0;
-    
-	do {
-		ret = storage->put (storage, txnid, &key, &value, db_flags);
-		if (ret == DB_LOCK_DEADLOCK) {
-			retries++;
-			gf_log ("bdb-ll",
-				GF_LOG_ERROR,
-				"deadlock detected in DB->put. retrying DB->put (%d)", 
-				retries);
-		} else if (ret) {
-			/* write failed */
-			gf_log ("bdb-ll",
-				GF_LOG_ERROR,
-				"failed to do DB->put() for key %s: %s", 
-				key_string, db_strerror (ret));
-			need_break = 1;
-		} else {
-			/* successfully wrote */
-			ret = 0;
-			need_break = 1;
-		}
-	} while (!need_break);
+        DB     *storage = NULL;
+        DBT     key = {0,}, value = {0,};
+        int32_t ret = -1;
+        int32_t db_flags = DB_AUTO_COMMIT;
+        uint8_t need_break = 0;
+        int32_t retries = 1;
+
+        LOCK (&bctx->lock);
+        {
+                if (bctx->dbp == NULL) {
+                        bctx->dbp = bdb_db_open (bctx);
+                        storage = bctx->dbp;
+                } else {
+                        /* we are just fine, lets continue */
+                        storage = bctx->dbp;
+                }
+        }
+        UNLOCK (&bctx->lock);
+
+        GF_VALIDATE_OR_GOTO ("bdb-ll", storage, out);
+
+        if (bctx->cache) {
+                ret = bdb_cache_delete (bctx, (char *)key_string);
+                GF_VALIDATE_OR_GOTO ("bdb-ll", (ret == 0), out);
+        }
+
+        key.data = (void *)key_string;
+        key.size = strlen (key_string);
+
+        /* NOTE: bdb lets us expand the file, suppose value.size > value.len,
+         * then value.len bytes from value.doff offset and value.size bytes
+         * will be written from value.doff and data from
+         * value.doff + value.dlen will be pushed value.doff + value.size
+         */
+        value.data = (void *)buf;
+
+        if (flags & BDB_TRUNCATE_RECORD) {
+                value.size = size;
+                value.doff = 0;
+                value.dlen = offset;
+        } else {
+                value.size = size;
+                value.dlen = size;
+                value.doff = offset;
+        }
+        value.flags = DB_DBT_PARTIAL;
+        if (buf == NULL && size == 0)
+                /* truncate called us */
+                value.flags = 0;
+
+        do {
+                ret = storage->put (storage, txnid, &key, &value, db_flags);
+                if (ret == DB_LOCK_DEADLOCK) {
+                        retries++;
+                        gf_log ("bdb-ll", GF_LOG_ERROR,
+                                "deadlock detected in DB->put. "
+                                "retrying DB->put (%d)",
+                                retries);
+                } else if (ret) {
+                        /* write failed */
+                        gf_log ("bdb-ll", GF_LOG_ERROR,
+                                "failed to do DB->put() for key %s: %s",
+                                key_string, db_strerror (ret));
+                        need_break = 1;
+                } else {
+                        /* successfully wrote */
+                        ret = 0;
+                        need_break = 1;
+                }
+        } while (!need_break);
 out:
-	return ret;
+        return ret;
 }/* bdb_db_put */
 
 
 /* bdb_storage_del - delete a key/value pair corresponding to @path from corresponding db file.
  *
- * @bctx: bctx_t * corresponding to the parent directory of @path. 
+ * @bctx: bctx_t * corresponding to the parent directory of @path.
  *       (should always be a valid bctx). bdb_storage_del should never be called
  *       if @bctx = NULL.
  * @txnid: NULL if bdb_storage_del is not embedded in an explicit transaction or a
- *         valid DB_TXN *, when embedded in an explicit transaction. 
+ *         valid DB_TXN *, when embedded in an explicit transaction.
  * @path: path to the file, whose key/value pair has to be deleted.
  *
- * NOTE: bdb_storage_del tries to open DB, if @bctx->dbp == NULL (@bctx->dbp == NULL, 
+ * NOTE: bdb_storage_del tries to open DB, if @bctx->dbp == NULL (@bctx->dbp == NULL,
  *      nobody has opened DB till now or DB was closed by bdb_table_prune()).
  *
  * return: 0 on success or -1 on error.
  */
 int32_t
 bdb_db_del (bctx_t *bctx,
-	    DB_TXN *txnid,
-	    const char *path)
+            DB_TXN *txnid,
+            const char *path)
 {
-	DB     *storage    = NULL;
-	DBT     key        = {0,};
-	char   *key_string = NULL;
-	int32_t ret        = -1;
-	int32_t db_flags   = 0;
-	uint8_t need_break = 0;
-	int32_t retries    = 1;
-
-	MAKE_KEY_FROM_PATH (key_string, path);
-
-	LOCK (&bctx->lock);
-	{
-		if (bctx->dbp == NULL) {
-			bctx->dbp = bdb_db_open (bctx);
-			storage = bctx->dbp;
-		} else {
-			/* we are just fine, lets continue */
-			storage = bctx->dbp;
-		}
-	}
-	UNLOCK (&bctx->lock);  
-	
-	GF_VALIDATE_OR_GOTO ("bdb-ll", storage, out);
-
-	ret = bdb_cache_delete (bctx, key_string);
-	GF_VALIDATE_OR_GOTO ("bdb-ll", (ret == 0), out);
-
-	key.data = key_string;
-	key.size = strlen (key_string);
-	key.flags = DB_DBT_USERMEM;
-    
-	do {
-		ret = storage->del (storage, txnid, &key, db_flags);
-      
-		if (ret == DB_NOTFOUND) {
-			gf_log ("bdb-ll",
-				GF_LOG_DEBUG,
-				"failed to delete %s from storage db, doesn't exist in storage DB", 
-				path);
-			need_break = 1;
-		} else if (ret == DB_LOCK_DEADLOCK) {
-			retries++;
-			gf_log ("bdb-ll",
-				GF_LOG_ERROR,
-				"deadlock detected in DB->put. retrying DB->put (%d)", 
-				retries);
-		}else if (ret == 0) {
-			/* successfully deleted the entry */
-			gf_log ("bdb-ll",
-				GF_LOG_DEBUG,
-				"deleted %s from storage db", path);
-			ret = 0;
-			need_break = 1;
-		} else {
-			gf_log ("bdb-ll",
-				GF_LOG_ERROR,
-				"failed to delete %s from storage db: %s", 
-				path, db_strerror (ret));
-			ret = -1;
-			need_break = 1;    
-		}
-	} while (!need_break);
+        DB     *storage    = NULL;
+        DBT     key        = {0,};
+        char   *key_string = NULL;
+        int32_t ret        = -1;
+        int32_t db_flags   = 0;
+        uint8_t need_break = 0;
+        int32_t retries    = 1;
+
+        MAKE_KEY_FROM_PATH (key_string, path);
+
+        LOCK (&bctx->lock);
+        {
+                if (bctx->dbp == NULL) {
+                        bctx->dbp = bdb_db_open (bctx);
+                        storage = bctx->dbp;
+                } else {
+                        /* we are just fine, lets continue */
+                        storage = bctx->dbp;
+                }
+        }
+        UNLOCK (&bctx->lock);
+
+        GF_VALIDATE_OR_GOTO ("bdb-ll", storage, out);
+
+        ret = bdb_cache_delete (bctx, key_string);
+        GF_VALIDATE_OR_GOTO ("bdb-ll", (ret == 0), out);
+
+        key.data = key_string;
+        key.size = strlen (key_string);
+        key.flags = DB_DBT_USERMEM;
+
+        do {
+                ret = storage->del (storage, txnid, &key, db_flags);
+
+                if (ret == DB_NOTFOUND) {
+                        gf_log ("bdb-ll", GF_LOG_DEBUG,
+                                "failed to delete %s from storage db, "
+                                "doesn't exist in storage DB",
+                                path);
+                        need_break = 1;
+                } else if (ret == DB_LOCK_DEADLOCK) {
+                        retries++;
+                        gf_log ("bdb-ll", GF_LOG_ERROR,
+                                "deadlock detected in DB->put. "
+                                "retrying DB->put (%d)",
+                                retries);
+                }else if (ret == 0) {
+                        /* successfully deleted the entry */
+                        gf_log ("bdb-ll", GF_LOG_DEBUG,
+                                "deleted %s from storage db", path);
+                        ret = 0;
+                        need_break = 1;
+                } else {
+                        gf_log ("bdb-ll", GF_LOG_ERROR,
+                                "failed to delete %s from storage db: %s",
+                                path, db_strerror (ret));
+                        ret = -1;
+                        need_break = 1;
+                }
+        } while (!need_break);
 out:
-	return ret;
+        return ret;
 }
 
 /* NOTE: bdb version compatibility wrapper */
@@ -698,31 +693,30 @@ bdb_cursor_get (DBC *cursorp,
                 DBT *value,
                 int32_t flags)
 {
-	int32_t ret = -1;
-	
-	GF_VALIDATE_OR_GOTO ("bdb-ll", cursorp, out);
+        int32_t ret = -1;
+
+        GF_VALIDATE_OR_GOTO ("bdb-ll", cursorp, out);
 
 #ifdef HAVE_BDB_CURSOR_GET
-	ret = cursorp->get (cursorp, key, value, flags);
+        ret = cursorp->get (cursorp, key, value, flags);
 #else
-	ret = cursorp->c_get (cursorp, key, value, flags);
+        ret = cursorp->c_get (cursorp, key, value, flags);
 #endif
-	if ((ret != 0)  && (ret != DB_NOTFOUND)) {
-		gf_log ("bdb-ll",
-			GF_LOG_ERROR,
-			"failed to CURSOR->get() for key %s (%s)",
-			(char *)key->data, db_strerror (ret));
-	}
+        if ((ret != 0)  && (ret != DB_NOTFOUND)) {
+                gf_log ("bdb-ll", GF_LOG_ERROR,
+                        "failed to CURSOR->get() for key %s (%s)",
+                        (char *)key->data, db_strerror (ret));
+        }
 
 out:
-	return ret;
+        return ret;
 }/* bdb_cursor_get */
 
 
 int32_t
 bdb_dirent_size (DBT *key)
 {
-	return ALIGN (24 /* FIX MEEEE!!! */ + key->size);
+        return ALIGN (24 /* FIX MEEEE!!! */ + key->size);
 }
 
 
@@ -737,29 +731,29 @@ inline void *
 bdb_extract_bfd (fd_t *fd,
                  xlator_t *this)
 {
-	uint64_t tmp_bfd = 0;
-	void    *bfd     = NULL;
- 	
-	GF_VALIDATE_OR_GOTO ("bdb-ll", fd, out);
-	GF_VALIDATE_OR_GOTO ("bdb-ll", this, out);
+        uint64_t tmp_bfd = 0;
+        void    *bfd     = NULL;
 
-	fd_ctx_get (fd, this, &tmp_bfd);
-	bfd = (void *)(long)bfd;
+        GF_VALIDATE_OR_GOTO ("bdb-ll", fd, out);
+        GF_VALIDATE_OR_GOTO ("bdb-ll", this, out);
+
+        fd_ctx_get (fd, this, &tmp_bfd);
+        bfd = (void *)(long)bfd;
 
 out:
-	return bfd;
+        return bfd;
 }
 
 /* bdb_dbenv_init - initialize DB_ENV
  *
  *  initialization includes:
- *   1. opening DB_ENV (db_env_create(), DB_ENV->open()). 
+ *   1. opening DB_ENV (db_env_create(), DB_ENV->open()).
  *      NOTE: see private->envflags for flags used.
- *   2. DB_ENV->set_lg_dir - set log directory to be used for storing log files 
+ *   2. DB_ENV->set_lg_dir - set log directory to be used for storing log files
  *     (log files are the files in which transaction logs are written by db).
  *   3. DB_ENV->set_flags (DB_LOG_AUTOREMOVE) - set DB_ENV to automatically clear
  *      the unwanted log files (flushed at each checkpoint).
- *   4. DB_ENV->set_errfile - set errfile to be used by db to report detailed error logs. 
+ *   4. DB_ENV->set_errfile - set errfile to be used by db to report detailed error logs.
  *     used only for debbuging purpose.
  *
  * return: returns a valid DB_ENV * on success or NULL on error.
@@ -767,168 +761,160 @@ out:
  */
 static DB_ENV *
 bdb_dbenv_init (xlator_t *this,
-		char *directory)
+                char *directory)
 {
-	/* Create a DB environment */
-	DB_ENV        *dbenv       = NULL;
-	int32_t        ret         = 0;
-	bdb_private_t *private     = NULL;
-	int32_t        fatal_flags = 0;
-	
-	VALIDATE_OR_GOTO (this, out);
-	VALIDATE_OR_GOTO (directory, out);
-
-	private = this->private;
-	VALIDATE_OR_GOTO (private, out);
-
-	ret = db_env_create (&dbenv, 0);
-	VALIDATE_OR_GOTO ((ret == 0), out);
-	
-	/* NOTE: set_errpfx returns 'void' */
-	dbenv->set_errpfx(dbenv, this->name);
-	
-	ret = dbenv->set_lk_detect (dbenv, DB_LOCK_DEFAULT);
-	VALIDATE_OR_GOTO ((ret == 0), out);
-
-	ret = dbenv->open(dbenv, directory, 
-			  private->envflags, 
-			  S_IRUSR | S_IWUSR);
-	if ((ret != 0) && (ret != DB_RUNRECOVERY)) {
-		gf_log (this->name, 
-			GF_LOG_CRITICAL, 
-			"failed to open DB environment (%s)", 
-			db_strerror (ret));
-		dbenv = NULL;
-		goto out;
-	} else if (ret == DB_RUNRECOVERY) {
-		fatal_flags = ((private->envflags & (~DB_RECOVER)) | DB_RECOVER_FATAL);
-		ret = dbenv->open(dbenv, directory, 
-				  fatal_flags, 
-				  S_IRUSR | S_IWUSR);
-		if (ret != 0) {
-			gf_log (this->name, 
-				GF_LOG_ERROR,
-				"failed to open DB environment (%s) with DB_REOVER_FATAL",
-				db_strerror (ret));
-			dbenv = NULL;
-			goto out;
-		} else {
-			gf_log (this->name, 
-				GF_LOG_WARNING,
-				"opened DB environment after DB_RECOVER_FATAL: %s", 
-				db_strerror (ret));
-		}
-	} else {
-		gf_log (this->name, 
-			GF_LOG_DEBUG,
-			"DB environment successfull opened: %s", 
-			db_strerror (ret));
-	}
-
-        
-
-#if (DB_VERSION_MAJOR == 4 &&			\
+        /* Create a DB environment */
+        DB_ENV        *dbenv       = NULL;
+        int32_t        ret         = 0;
+        bdb_private_t *private     = NULL;
+        int32_t        fatal_flags = 0;
+
+        VALIDATE_OR_GOTO (this, out);
+        VALIDATE_OR_GOTO (directory, out);
+
+        private = this->private;
+        VALIDATE_OR_GOTO (private, out);
+
+        ret = db_env_create (&dbenv, 0);
+        VALIDATE_OR_GOTO ((ret == 0), out);
+
+        /* NOTE: set_errpfx returns 'void' */
+        dbenv->set_errpfx(dbenv, this->name);
+
+        ret = dbenv->set_lk_detect (dbenv, DB_LOCK_DEFAULT);
+        VALIDATE_OR_GOTO ((ret == 0), out);
+
+        ret = dbenv->open(dbenv, directory,
+                          private->envflags,
+                          S_IRUSR | S_IWUSR);
+        if ((ret != 0) && (ret != DB_RUNRECOVERY)) {
+                gf_log (this->name, GF_LOG_CRITICAL,
+                        "failed to open DB environment (%s)",
+                        db_strerror (ret));
+                dbenv = NULL;
+                goto out;
+        } else if (ret == DB_RUNRECOVERY) {
+                fatal_flags = ((private->envflags & (~DB_RECOVER))
+                               | DB_RECOVER_FATAL);
+                ret = dbenv->open(dbenv, directory, fatal_flags,
+                                  S_IRUSR | S_IWUSR);
+                if (ret != 0) {
+                        gf_log (this->name, GF_LOG_ERROR,
+                                "failed to open DB environment (%s) with "
+                                "DB_REOVER_FATAL",
+                                db_strerror (ret));
+                        dbenv = NULL;
+                        goto out;
+                } else {
+                        gf_log (this->name, GF_LOG_WARNING,
+                                "opened DB environment after DB_RECOVER_FATAL:"
+                                " %s", db_strerror (ret));
+                }
+        } else {
+                gf_log (this->name, GF_LOG_DEBUG,
+                        "DB environment successfull opened: %s",
+                        db_strerror (ret));
+        }
+
+
+
+#if (DB_VERSION_MAJOR == 4 &&                   \
      DB_VERSION_MINOR == 7)
-	if (private->log_auto_remove) {
-		ret = dbenv->log_set_config (dbenv, DB_LOG_AUTO_REMOVE, 1);
-	} else {
-		ret = dbenv->log_set_config (dbenv, DB_LOG_AUTO_REMOVE, 0);
-	}
+        if (private->log_auto_remove) {
+                ret = dbenv->log_set_config (dbenv, DB_LOG_AUTO_REMOVE, 1);
+        } else {
+                ret = dbenv->log_set_config (dbenv, DB_LOG_AUTO_REMOVE, 0);
+        }
 #else
-	if (private->log_auto_remove) {
-		ret = dbenv->set_flags (dbenv, DB_LOG_AUTOREMOVE, 1);
-	} else {
-		ret = dbenv->set_flags (dbenv, DB_LOG_AUTOREMOVE, 0);
-	}         
+        if (private->log_auto_remove) {
+                ret = dbenv->set_flags (dbenv, DB_LOG_AUTOREMOVE, 1);
+        } else {
+                ret = dbenv->set_flags (dbenv, DB_LOG_AUTOREMOVE, 0);
+        }
 #endif
-	if (ret != 0) {
-		gf_log ("bctx",
-			GF_LOG_ERROR,
-			"failed to set DB_LOG_AUTOREMOVE on dbenv: %s", db_strerror (ret));
-	} else {
-		gf_log ("bctx",
-			GF_LOG_DEBUG,
-			"DB_LOG_AUTOREMOVE set on dbenv");
-	}
-
-	if (private->transaction) {
-		ret = dbenv->set_flags(dbenv, DB_AUTO_COMMIT, 1);
-          
-		if (ret != 0) {
-			gf_log ("bctx",
-				GF_LOG_ERROR,
-				"failed to set DB_AUTO_COMMIT on dbenv: %s", 
-				db_strerror (ret));
-		} else {
-			gf_log ("bctx",
-				GF_LOG_DEBUG,
-				"DB_AUTO_COMMIT set on dbenv");
-		}
-          
-		if (private->txn_timeout) {
-			ret = dbenv->set_timeout (dbenv, 
-						  private->txn_timeout, 
-						  DB_SET_TXN_TIMEOUT);
-			if (ret != 0) {
-				gf_log ("bctx",
-					GF_LOG_ERROR,
-					"failed to set TXN_TIMEOUT to %d milliseconds "
-					"on dbenv: %s", 					
-					private->txn_timeout, db_strerror (ret));
-			} else {
-				gf_log ("bctx",
-					GF_LOG_DEBUG,
-					"TXN_TIMEOUT set to %d milliseconds", 
-					private->txn_timeout);
-			}
-		}
-
-		if (private->lock_timeout) {
-			ret = dbenv->set_timeout(dbenv, 
-						 private->txn_timeout, 
-						 DB_SET_LOCK_TIMEOUT);
-            
-			if (ret != 0) {
-				gf_log ("bctx",
-					GF_LOG_ERROR,
-					"failed to set LOCK_TIMEOUT to %d milliseconds "
-					"on dbenv: %s", 
-					private->lock_timeout, db_strerror (ret));
-			} else {
-				gf_log ("bctx",
-					GF_LOG_DEBUG,
-					"LOCK_TIMEOUT set to %d milliseconds", 
-					private->lock_timeout);
-			}
-		}
-
-		ret = dbenv->set_lg_dir (dbenv, private->logdir);
-		
-		if (ret != 0) {
-			gf_log ("bctx",
-				GF_LOG_ERROR,
-				"failed to set log directory for dbenv: %s", db_strerror (ret));
-		} else {
-			gf_log ("bctx",
-				GF_LOG_DEBUG,
-				"set dbenv log dir to %s", private->logdir);
-		}
-		
-	}
-        
-	if (private->errfile) {
-		private->errfp = fopen (private->errfile, "a+");
-		if (private->errfp) {
-			dbenv->set_errfile (dbenv, private->errfp);
-		} else {
-			gf_log ("bctx",
-				GF_LOG_ERROR,
-				"failed to open errfile: %s", strerror (errno));
-		}
-	}
+        if (ret != 0) {
+                gf_log ("bctx", GF_LOG_ERROR,
+                        "failed to set DB_LOG_AUTOREMOVE on dbenv: %s",
+                        db_strerror (ret));
+        } else {
+                gf_log ("bctx", GF_LOG_DEBUG,
+                        "DB_LOG_AUTOREMOVE set on dbenv");
+        }
+
+        if (private->transaction) {
+                ret = dbenv->set_flags(dbenv, DB_AUTO_COMMIT, 1);
+
+                if (ret != 0) {
+                        gf_log ("bctx", GF_LOG_ERROR,
+                                "failed to set DB_AUTO_COMMIT on dbenv: %s",
+                                db_strerror (ret));
+                } else {
+                        gf_log ("bctx", GF_LOG_DEBUG,
+                                "DB_AUTO_COMMIT set on dbenv");
+                }
+
+                if (private->txn_timeout) {
+                        ret = dbenv->set_timeout (dbenv,
+                                                  private->txn_timeout,
+                                                  DB_SET_TXN_TIMEOUT);
+                        if (ret != 0) {
+                                gf_log ("bctx", GF_LOG_ERROR,
+                                        "failed to set TXN_TIMEOUT to %d "
+                                        "milliseconds on dbenv: %s",
+                                        private->txn_timeout,
+                                        db_strerror (ret));
+                        } else {
+                                gf_log ("bctx", GF_LOG_DEBUG,
+                                        "TXN_TIMEOUT set to %d milliseconds",
+                                        private->txn_timeout);
+                        }
+                }
+
+                if (private->lock_timeout) {
+                        ret = dbenv->set_timeout(dbenv,
+                                                 private->txn_timeout,
+                                                 DB_SET_LOCK_TIMEOUT);
+
+                        if (ret != 0) {
+                                gf_log ("bctx", GF_LOG_ERROR,
+                                        "failed to set LOCK_TIMEOUT to %d "
+                                        "milliseconds on dbenv: %s",
+                                        private->lock_timeout,
+                                        db_strerror (ret));
+                        } else {
+                                gf_log ("bctx", GF_LOG_DEBUG,
+                                        "LOCK_TIMEOUT set to %d milliseconds",
+                                        private->lock_timeout);
+                        }
+                }
+
+                ret = dbenv->set_lg_dir (dbenv, private->logdir);
+
+                if (ret != 0) {
+                        gf_log ("bctx", GF_LOG_ERROR,
+                                "failed to set log directory for dbenv: %s",
+                                db_strerror (ret));
+                } else {
+                        gf_log ("bctx", GF_LOG_DEBUG,
+                                "set dbenv log dir to %s",
+                                private->logdir);
+                }
+
+        }
+
+        if (private->errfile) {
+                private->errfp = fopen (private->errfile, "a+");
+                if (private->errfp) {
+                        dbenv->set_errfile (dbenv, private->errfp);
+                } else {
+                        gf_log ("bctx", GF_LOG_ERROR,
+                                "failed to open errfile: %s",
+                                strerror (errno));
+                }
+        }
 
 out:
-	return dbenv;
+        return dbenv;
 }
 
 #define BDB_ENV(this) ((((struct bdb_private *)this->private)->b_table)->dbenv)
@@ -937,21 +923,21 @@ out:
  *                  files, instead db writes a 'log' (similar to a journal entry) into a
  *                  log file. db normally clears the log files during opening of an
  *                  environment. since we expect a filesystem server to run for a pretty
- *                  long duration and flushing 'log's during dbenv->open would prove very 
- *                  costly, if we accumulate the log entries for one complete run of 
+ *                  long duration and flushing 'log's during dbenv->open would prove very
+ *                  costly, if we accumulate the log entries for one complete run of
  *                  glusterfs server. to flush the logs frequently, db provides a mechanism
  *                  called 'checkpointing'. when we do a checkpoint, db flushes the logs to
- *                  disk (writes changes to db files) and we can also clear the accumulated 
+ *                  disk (writes changes to db files) and we can also clear the accumulated
  *                  log files after checkpointing. NOTE: removing unwanted log files is not
- *                  part of dbenv->txn_checkpoint() call. 
+ *                  part of dbenv->txn_checkpoint() call.
  *
  * @data: xlator_t of the current instance of bdb xlator.
  *
- *  bdb_checkpoint is called in a different thread from the main glusterfs thread. bdb 
- *  xlator creates the checkpoint thread after successfully opening the db environment. 
+ *  bdb_checkpoint is called in a different thread from the main glusterfs thread. bdb
+ *  xlator creates the checkpoint thread after successfully opening the db environment.
  *  NOTE: bdb_checkpoint thread shares the DB_ENV handle with the filesystem thread.
  *
- *  db environment checkpointing frequency is controlled by 
+ *  db environment checkpointing frequency is controlled by
  *  'option checkpoint-timeout <time-in-seconds>' in volfile.
  *
  * NOTE: checkpointing thread is started only if 'option transaction on' specified in
@@ -961,495 +947,492 @@ out:
 static void *
 bdb_checkpoint (void *data)
 {
-	xlator_t *this = NULL;
-	struct bdb_private *private = NULL;
-	DB_ENV *dbenv = NULL;
-	int32_t ret = 0;
-	uint32_t active = 0;
-
-	this = (xlator_t *) data;
-	dbenv = BDB_ENV(this);
-	private = this->private;
-
-	for (;;sleep (private->checkpoint_timeout)) {
-		LOCK (&private->active_lock);
-		active = private->active;
-		UNLOCK (&private->active_lock);
- 
-		if (active) {
-			ret = dbenv->txn_checkpoint (dbenv, 1024, 0, 0);
-			if (ret) {
-				gf_log ("bctx",
-					GF_LOG_ERROR,
-					"failed to checkpoint environment: %s", db_strerror (ret));
-			} else {
-				gf_log ("bctx",
-					GF_LOG_DEBUG,
-					"checkpointing successful");
-			} 
-		} else {
-			ret = dbenv->txn_checkpoint (dbenv, 1024, 0, 0);
-			if (ret) {
-				gf_log ("bctx",
-					GF_LOG_ERROR,
-					"failed to do final checkpoint environment: %s", 
-					db_strerror (ret));
-			} else {
-				gf_log ("bctx",
-					GF_LOG_DEBUG,
-					"final checkpointing successful");
-			}
-			break;
-		}
-	}
-
-	return NULL;
+        xlator_t *this = NULL;
+        struct bdb_private *private = NULL;
+        DB_ENV *dbenv = NULL;
+        int32_t ret = 0;
+        uint32_t active = 0;
+
+        this = (xlator_t *) data;
+        dbenv = BDB_ENV(this);
+        private = this->private;
+
+        for (;;sleep (private->checkpoint_interval)) {
+                LOCK (&private->active_lock);
+                active = private->active;
+                UNLOCK (&private->active_lock);
+
+                if (active) {
+                        ret = dbenv->txn_checkpoint (dbenv, 1024, 0, 0);
+                        if (ret) {
+                                gf_log ("bctx", GF_LOG_ERROR,
+                                        "failed to checkpoint environment: %s",
+                                        db_strerror (ret));
+                        } else {
+                                gf_log ("bctx", GF_LOG_DEBUG,
+                                        "checkpointing successful");
+                        }
+                } else {
+                        ret = dbenv->txn_checkpoint (dbenv, 1024, 0, 0);
+                        if (ret) {
+                                gf_log ("bctx", GF_LOG_ERROR,
+                                        "failed to do final checkpoint "
+                                        "environment: %s",
+                                        db_strerror (ret));
+                        } else {
+                                gf_log ("bctx", GF_LOG_DEBUG,
+                                        "final checkpointing successful");
+                        }
+                        break;
+                }
+        }
+
+        return NULL;
 }
 
 static inline void
-BDB_CACHE_INIT (xlator_t *this,
-		dict_t *options, 
-		struct bdb_private *private)
+bdb_cache_init (xlator_t *this,
+                dict_t *options,
+                struct bdb_private *private)
 {
-	/* cache is always on */
-	private->cache = ON;
+        /* cache is always on */
+        private->cache = ON;
 }
 
 static inline void
-BDB_LOG_REMOVE_INIT(xlator_t *this,
-		    dict_t *options,
-		    struct bdb_private *private)
+bdb_log_remove_init (xlator_t *this,
+                     dict_t *options,
+                     struct bdb_private *private)
 {
-	private->log_auto_remove = 1;
-	gf_log (this->name,
-		GF_LOG_DEBUG,
-		"DB_ENV will use DB_LOG_AUTO_REMOVE");
+        private->log_auto_remove = 1;
+        gf_log (this->name, GF_LOG_DEBUG,
+                "DB_ENV will use DB_LOG_AUTO_REMOVE");
 }
 
 static inline void
-BDB_ERRFILE_INIT (xlator_t *this,
-		  dict_t *options,
-		  struct bdb_private *private)
+bdb_errfile_init (xlator_t *this,
+                  dict_t *options,
+                  struct bdb_private *private)
 {
-	data_t *errfile = NULL;
-
-	errfile = dict_get (options, "errfile");
-	if (errfile) {
-		private->errfile = strdup (errfile->data);
-		gf_log (this->name,
-			GF_LOG_DEBUG,
-			"using errfile: %s", private->errfile);
-	} 
+        int ret = -1;
+        char *errfile = NULL;
+
+        ret = dict_get_str (options, "errfile", &errfile);
+        if (ret == 0) {
+                private->errfile = strdup (errfile);
+                gf_log (this->name, GF_LOG_DEBUG,
+                        "using errfile: %s", private->errfile);
+        }
 }
 
 static inline void
-BDB_TABLE_INIT (xlator_t *this,
-		dict_t *options,
-		struct bdb_private *private)
+bdb_table_init (xlator_t *this,
+                dict_t *options,
+                struct bdb_private *private)
 {
-	bctx_table_t *table = NULL;
-	int32_t        idx                = 0;
-  
-	data_t        *lru_limit          = NULL;
-	data_t        *page_size          = NULL;
-	
-	table = CALLOC (1, sizeof (*table));
-	if (table) {
-		INIT_LIST_HEAD(&(table->b_lru));
-		INIT_LIST_HEAD(&(table->active));
-		INIT_LIST_HEAD(&(table->purge));
-
-		LOCK_INIT (&table->lock);
-		LOCK_INIT (&table->checkpoint_lock);
-      
-		table->transaction = private->transaction;
-		table->access_mode = private->access_mode;
-		table->dbflags = private->dbflags;
-		table->this    = this;
-
-		{
-			lru_limit = dict_get (options, "lru-limit");
-        
-			/* TODO: set max lockers and max txns to accomodate 
-			 * for more than lru_limit */
-			if (lru_limit) {
-				table->lru_limit = strtol (lru_limit->data, NULL, 0);
-				gf_log ("bdb-ll",
-					GF_LOG_DEBUG,
-					"setting bctx lru limit to %d", table->lru_limit);
-			} else {
-				table->lru_limit = BDB_DEFAULT_LRU_LIMIT;
-			}
-		}
-
-		{
-			page_size = dict_get (options, "page-size");
-        
-			if (page_size)
-			{
-				if (gf_string2bytesize (page_size->data, 
-							&table->page_size) != 0) {
-					gf_log ("bdb-ll", 
-						GF_LOG_ERROR, 
-						"invalid number format \"%s\""
-						" of \"option page-size\"", 
-						page_size->data);
-				}
-            
-				if (!(table->page_size >= BDB_LL_PAGE_SIZE_MIN && 
-				      table->page_size <= BDB_LL_PAGE_SIZE_MAX)) {
-					gf_log ("bdb-ll", 
-						GF_LOG_ERROR, 
-						"pagesize %s is out of range."
-						"Allowed pagesize is between %d and %d", 
-						page_size->data, 
-						BDB_LL_PAGE_SIZE_MIN, 
-						BDB_LL_PAGE_SIZE_MAX);
-				}
-			}
-			else {
-				table->page_size = BDB_LL_PAGE_SIZE_DEFAULT;
-			}
-			gf_log ("bdb-ll", 
-				GF_LOG_DEBUG, "using page-size %"PRIu64, 
-				table->page_size);
-		}
-      
-		table->hash_size = BDB_DEFAULT_HASH_SIZE;
-		table->b_hash = CALLOC (BDB_DEFAULT_HASH_SIZE, sizeof (struct list_head));
-
-		for (idx = 0; idx < table->hash_size; idx++)
-			INIT_LIST_HEAD(&(table->b_hash[idx]));
-
-		private->b_table = table;
-	} else {
-		gf_log ("bdb-ll",
-			GF_LOG_CRITICAL,
-			"failed to allocate bctx table: out of memory");
-	}
+        bctx_table_t *table = NULL;
+        int32_t       idx   = 0;
+
+        int ret = -1;
+        char *lru_limit_str = NULL;
+        char *page_size_str = NULL;
+
+        table = CALLOC (1, sizeof (*table));
+        if (table) {
+                INIT_LIST_HEAD(&(table->b_lru));
+                INIT_LIST_HEAD(&(table->active));
+                INIT_LIST_HEAD(&(table->purge));
+
+                LOCK_INIT (&table->lock);
+                LOCK_INIT (&table->checkpoint_lock);
+
+                table->transaction = private->transaction;
+                table->access_mode = private->access_mode;
+                table->dbflags = private->dbflags;
+                table->this    = this;
+
+                {
+                        ret = dict_get_str (options, "lru-limit",
+                                            &lru_limit_str);
+
+                        /* TODO: set max lockers and max txns to accomodate
+                         * for more than lru_limit */
+                        if (ret == 0) {
+                                ret = gf_string2uint32 (lru_limit_str,
+                                                        &table->lru_limit);
+                                gf_log ("bdb-ll", GF_LOG_DEBUG,
+                                        "setting bctx lru limit to %d",
+                                        table->lru_limit);
+                        } else {
+                                table->lru_limit = BDB_DEFAULT_LRU_LIMIT;
+                        }
+                }
+
+                {
+                        ret = dict_get_str (options, "page-size",
+                                            &page_size_str);
+
+                        if (ret == 0) {
+                                ret = gf_string2bytesize (page_size_str,
+                                                          &table->page_size);
+                                if (ret != 0) {
+                                        gf_log ("bdb-ll", GF_LOG_ERROR,
+                                                "invalid number format \"%s\""
+                                                " of \"option page-size\"",
+                                                page_size_str);
+                                }
+
+                                if (!PAGE_SIZE_IN_RANGE(table->page_size)) {
+                                        gf_log ("bdb-ll", GF_LOG_ERROR,
+                                                "pagesize %s is out of range."
+                                                "Allowed pagesize is between "
+                                                "%d and %d",
+                                                page_size_str,
+                                                BDB_LL_PAGE_SIZE_MIN,
+                                                BDB_LL_PAGE_SIZE_MAX);
+                                }
+                        }
+                        else {
+                                table->page_size = BDB_LL_PAGE_SIZE_DEFAULT;
+                        }
+                        gf_log ("bdb-ll",
+                                GF_LOG_DEBUG, "using page-size %"PRIu64,
+                                table->page_size);
+                }
+
+                table->hash_size = BDB_DEFAULT_HASH_SIZE;
+                table->b_hash = CALLOC (BDB_DEFAULT_HASH_SIZE,
+                                        sizeof (struct list_head));
+
+                for (idx = 0; idx < table->hash_size; idx++)
+                        INIT_LIST_HEAD(&(table->b_hash[idx]));
+
+                private->b_table = table;
+        } else {
+                gf_log ("bdb-ll", GF_LOG_CRITICAL,
+                        "failed to allocate bctx table: out of memory");
+        }
 }
 
-static inline void 
-BDB_DIRECTORY_INIT (xlator_t *this, 
-		    dict_t *options, 
-		    struct bdb_private *private)
+static inline void
+bdb_directory_init (xlator_t *this,
+                    dict_t *options,
+                    struct bdb_private *private)
 {
-	data_t *directory = NULL;
-	data_t *logdir = NULL;
-	int32_t op_ret = -1;
-	struct stat stbuf = {0};
-
-	directory = dict_get (options, "directory");
-    
-	if (directory) {
-		logdir = dict_get (options, "logdir");
-        
-		if (logdir == NULL) {
-			gf_log ("bdb-ll",
-				GF_LOG_DEBUG,
-				"using default logdir as database home");
-			private->logdir = strdup (directory->data);
-					
-		} else {
-			private->logdir = strdup (logdir->data);
-			gf_log ("bdb-ll",
-				GF_LOG_DEBUG,
-				"using logdir: %s", private->logdir);
-			umask (000);
-			if (mkdir (private->logdir, 0777) == 0) {
-				gf_log ("bdb-ll", GF_LOG_WARNING,
-					"logdir specified (%s) not exists, created", 
-					private->logdir);
-			}
-            
-			op_ret = stat (private->logdir, &stbuf);
-			if ((op_ret != 0) || !S_ISDIR (stbuf.st_mode)) {
-				gf_log ("bdb-ll", 
-					GF_LOG_ERROR, 
-					"specified logdir doesn't exist, "
-					"using default (environment home directory: %s)", 
-					directory->data);
-				private->logdir = strdup (directory->data);
-			}
-		}
-
-		private->b_table->dbenv = bdb_dbenv_init (this, directory->data);
-      
-		if (!private->b_table->dbenv) {
-			gf_log ("bdb-ll", GF_LOG_ERROR,
-				"failed to initialize db environment");
-			FREE (private);
-			op_ret = -1;
-		} else {
-			if (private->transaction) {
-				/* all well, start the checkpointing thread */
-				LOCK_INIT (&private->active_lock);
-				
-				LOCK (&private->active_lock);
-				private->active = 1;
-				UNLOCK (&private->active_lock);
-				pthread_create (&private->checkpoint_thread, NULL,
-						bdb_checkpoint, this);
-			}
-		}
-	}
+        int ret = -1;
+        char *directory = NULL;
+        char *logdir = NULL;
+        int32_t op_ret = -1;
+        struct stat stbuf = {0};
+
+        ret = dict_get_str (options, "directory", &directory);
+
+        if (ret == 0) {
+                ret = dict_get_str (options, "logdir", &logdir);
+
+                if (ret != 0) {
+                        gf_log ("bdb-ll", GF_LOG_DEBUG,
+                                "using default logdir as database home");
+                        private->logdir = strdup (directory);
+
+                } else {
+                        private->logdir = strdup (logdir);
+                        gf_log ("bdb-ll", GF_LOG_DEBUG,
+                                "using logdir: %s",
+                                private->logdir);
+                        umask (000);
+                        if (mkdir (private->logdir, 0777) == 0) {
+                                gf_log ("bdb-ll", GF_LOG_WARNING,
+                                        "logdir specified (%s) not exists, "
+                                        "created",
+                                        private->logdir);
+                        }
+
+                        op_ret = stat (private->logdir, &stbuf);
+                        if ((op_ret != 0)
+                            || (!S_ISDIR (stbuf.st_mode))) {
+                                gf_log ("bdb-ll", GF_LOG_ERROR,
+                                        "specified logdir doesn't exist, "
+                                        "using default "
+                                        "(environment home directory: %s)",
+                                        directory);
+                                private->logdir = strdup (directory);
+                        }
+                }
+
+                private->b_table->dbenv = bdb_dbenv_init (this, directory);
+
+                if (!private->b_table->dbenv) {
+                        gf_log ("bdb-ll", GF_LOG_ERROR,
+                                "failed to initialize db environment");
+                        FREE (private);
+                        op_ret = -1;
+                } else {
+                        if (private->transaction) {
+                                /* all well, start the checkpointing thread */
+                                LOCK_INIT (&private->active_lock);
+
+                                LOCK (&private->active_lock);
+                                {
+                                        private->active = 1;
+                                }
+                                UNLOCK (&private->active_lock);
+                                pthread_create (&private->checkpoint_thread,
+                                                NULL, bdb_checkpoint, this);
+                        }
+                }
+        }
 }
 
 static inline void
-BDB_DIR_MODE_INIT (xlator_t *this,
-		   dict_t *options, 
-		   struct bdb_private *private)
+bdb_dir_mode_init (xlator_t *this,
+                   dict_t *options,
+                   struct bdb_private *private)
 {
-	data_t *dir_mode = NULL;
-	char *endptr = NULL;
-
-	dir_mode = dict_get (options, "dir-mode");
-
-	if (dir_mode) {
-		private->dir_mode = strtol (dir_mode->data, &endptr, 8);
-		if ((*endptr) || 
-		    (!IS_VALID_FILE_MODE(private->dir_mode))) {
-			gf_log (this->name,
-				GF_LOG_DEBUG,
-				"invalid dir-mode %o. setting to default %o", 
-				private->dir_mode, 
-				DEFAULT_DIR_MODE);
-			private->dir_mode = DEFAULT_DIR_MODE;
-		} else {
-			gf_log (this->name,
-				GF_LOG_DEBUG,
-				"setting dir-mode to %o", private->dir_mode);
-			private->dir_mode = private->dir_mode;
-		}
-	} else {
-		private->dir_mode = DEFAULT_DIR_MODE;
-	}
-    
-	private->dir_mode = private->dir_mode | S_IFDIR;
+        int ret = -1;
+        char *mode_str = NULL;
+        char *endptr = NULL;
+
+        ret = dict_get_str (options, "dir-mode", &mode_str);
+
+        if (ret == 0) {
+                private->dir_mode = strtol (mode_str, &endptr, 8);
+                if ((*endptr) ||
+                    (!IS_VALID_FILE_MODE(private->dir_mode))) {
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "invalid dir-mode %o. setting to default %o",
+                                private->dir_mode,
+                                DEFAULT_DIR_MODE);
+                        private->dir_mode = DEFAULT_DIR_MODE;
+                } else {
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "setting dir-mode to %o",
+                                private->dir_mode);
+                }
+        } else {
+                private->dir_mode = DEFAULT_DIR_MODE;
+        }
+
+        private->dir_mode = private->dir_mode | S_IFDIR;
 }
 
 static inline void
-BDB_FILE_MODE_INIT (xlator_t *this,
-		    dict_t *options, 
-		    struct bdb_private *private)
+bdb_file_mode_init (xlator_t *this,
+                    dict_t *options,
+                    struct bdb_private *private)
 {
-	data_t *file_mode = NULL;
-	char *endptr = NULL;
-
-	file_mode = dict_get (options, "file-mode");
-
-	if (file_mode) {
-		private->file_mode = strtol (file_mode->data, &endptr, 8);
-
-		if ((*endptr) || 
-		    (!IS_VALID_FILE_MODE(private->file_mode))) {
-			gf_log (this->name,
-				GF_LOG_DEBUG,
-				"invalid file-mode %o. setting to default %o", 
-				private->file_mode, 
-				DEFAULT_FILE_MODE);
-			private->file_mode = DEFAULT_FILE_MODE;
-		} else {
-			gf_log (this->name,
-				GF_LOG_DEBUG,
-				"setting file-mode to %o", private->file_mode);
-			private->file_mode = private->file_mode;
-		}
-	} else {
-		private->file_mode = DEFAULT_FILE_MODE;
-	}
-    
-	private->symlink_mode = private->file_mode | S_IFLNK;
-	private->file_mode = private->file_mode | S_IFREG;
+        int ret = -1;
+        char *mode_str = NULL;
+        char *endptr = NULL;
+
+        ret = dict_get_str (options, "file-mode", &mode_str);
+
+        if (ret == 0) {
+                private->file_mode = strtol (mode_str, &endptr, 8);
+
+                if ((*endptr) ||
+                    (!IS_VALID_FILE_MODE(private->file_mode))) {
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "invalid file-mode %o. setting to default %o",
+                                private->file_mode, DEFAULT_FILE_MODE);
+                        private->file_mode = DEFAULT_FILE_MODE;
+                } else {
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "setting file-mode to %o",
+                                private->file_mode);
+                        private->file_mode = private->file_mode;
+                }
+        } else {
+                private->file_mode = DEFAULT_FILE_MODE;
+        }
+
+        private->symlink_mode = private->file_mode | S_IFLNK;
+        private->file_mode = private->file_mode | S_IFREG;
 }
 
 static inline void
-BDB_CHECKPOINT_TIMEOUT_INIT (xlator_t *this,
-			     dict_t *options, 
-			     struct bdb_private *private)
+bdb_checkpoint_interval_init (xlator_t *this,
+                              dict_t *options,
+                              struct bdb_private *private)
 {
-	data_t        *checkpoint_timeout = NULL;
-
-	checkpoint_timeout = dict_get (options, "checkpoint-timeout");
-    
-	private->checkpoint_timeout = BDB_DEFAULT_CHECKPOINT_TIMEOUT;
-
-	if (checkpoint_timeout) {
-		private->checkpoint_timeout = strtol (checkpoint_timeout->data, NULL, 0);
-      
-		if (private->checkpoint_timeout < 5 || private->checkpoint_timeout > 60) {
-			gf_log (this->name,
-				GF_LOG_WARNING,
-				"checkpoint-timeout %d seconds too %s", 
-				private->checkpoint_timeout, 
-				(private->checkpoint_timeout < 5)?"low":"high");
-		} else {
-			gf_log (this->name,
-				GF_LOG_DEBUG,
-				"setting checkpoint-timeout to %d seconds", 
-				private->checkpoint_timeout);
-		}
-	} else {
-		gf_log (this->name,
-			GF_LOG_DEBUG,
-			"setting checkpoint-timeout to default: %d seconds", 
-			private->checkpoint_timeout);
-	}
+        int   ret = -1;
+        char *checkpoint_interval_str = NULL;
+
+        private->checkpoint_interval = BDB_DEFAULT_CHECKPOINT_INTERVAL;
+
+        ret = dict_get_str (options, "checkpoint-interval",
+                            &checkpoint_interval_str);
+
+        if (ret == 0) {
+                ret = gf_string2time (checkpoint_interval_str,
+                                      &private->checkpoint_interval);
+
+                if (ret == 0) {
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "setting checkpoint-interval to %"PRIu32" seconds",
+                                private->checkpoint_interval);
+                }
+        } else {
+                gf_log (this->name, GF_LOG_DEBUG,
+                        "setting checkpoint-interval to default: %"PRIu32" seconds",
+                        private->checkpoint_interval);
+        }
 }
 
 static inline void
-BDB_LOCK_TIMEOUT_INIT (xlator_t *this,
-		       dict_t *options, 
-		       struct bdb_private *private)
+bdb_lock_timeout_init (xlator_t *this,
+                       dict_t *options,
+                       struct bdb_private *private)
 {
-	data_t        *lock_timeout       = NULL;
-
-	lock_timeout = dict_get (options, "lock-timeout");
-    
-	if (lock_timeout) {
-		private->lock_timeout = strtol (lock_timeout->data, NULL, 0);
-      
-		if (private->lock_timeout > 4260000) {
-			/* db allows us to DB_SET_LOCK_TIMEOUT to be set to a
-			 * maximum of 71 mins (4260000 milliseconds) */
-			gf_log (this->name,
-				GF_LOG_DEBUG,
-				"lock-timeout %d, out of range",
-				private->lock_timeout);
-			private->lock_timeout = 0;
-		} else {
-			gf_log (this->name,
-				GF_LOG_DEBUG,
-				"setting lock-timeout to %d milliseconds", 
-				private->lock_timeout);
-		}
-	}
+        int   ret = -1;
+        char *timeout_str = NULL;
+
+        ret = dict_get_str (options, "lock-timeout", &timeout_str);
+
+        if (ret == 0) {
+                ret = gf_string2time (timeout_str, &private->lock_timeout);
+
+                if (private->lock_timeout > 4260000) {
+                        /* db allows us to DB_SET_LOCK_TIMEOUT to be set to a
+                         * maximum of 71 mins (4260000 milliseconds) */
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "lock-timeout %d, out of range",
+                                private->lock_timeout);
+                        private->lock_timeout = 0;
+                } else {
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "setting lock-timeout to %d milliseconds",
+                                private->lock_timeout);
+                }
+        }
 }
 
 static inline void
-BDB_TRANSACTION_TIMEOUT_INIT (xlator_t *this,
-			      dict_t *options, 
-			      struct bdb_private *private)
+bdb_transaction_timeout_init (xlator_t *this,
+                              dict_t *options,
+                              struct bdb_private *private)
 {
-	data_t *txn_timeout = NULL;
-	txn_timeout = dict_get (options, "transaction-timeout");
-    
-	if (txn_timeout) {
-		private->txn_timeout = strtol (txn_timeout->data, NULL, 0);
-      
-		if (private->txn_timeout > 4260000) {
-			/* db allows us to DB_SET_TXN_TIMEOUT to be set to a maximum
-			 * of 71 mins (4260000 milliseconds) */
-			gf_log (this->name,
-				GF_LOG_DEBUG,
-				"transaction-timeout %d, out of range",
-				private->txn_timeout);
-			private->txn_timeout = 0;
-		} else {
-			gf_log (this->name,
-				GF_LOG_DEBUG,
-				"setting transaction-timeout to %d milliseconds", 
-				private->txn_timeout);
-		}
-	}
+        int   ret = -1;
+        char *timeout_str = NULL;
+
+        ret = dict_get_str (options, "transaction-timeout", &timeout_str);
+
+        if (ret == 0) {
+                ret = gf_string2time (timeout_str, &private->txn_timeout);
+
+                if (private->txn_timeout > 4260000) {
+                        /* db allows us to DB_SET_TXN_TIMEOUT to be set to
+                         * a maximum of 71 mins (4260000 milliseconds) */
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "transaction-timeout %d, out of range",
+                                private->txn_timeout);
+                        private->txn_timeout = 0;
+                } else {
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "setting transaction-timeout to %d "
+                                "milliseconds",
+                                private->txn_timeout);
+                }
+        }
 }
 
 static inline void
-BDB_TRANSACTION_INIT (xlator_t *this,
-		      dict_t *options, 
-		      struct bdb_private *private)
+bdb_transaction_init (xlator_t *this,
+                      dict_t *options,
+                      struct bdb_private *private)
 {
-	data_t *mode = NULL;
-
-	mode = dict_get (options, "mode");
-    
-	if (mode && !strcmp (mode->data, "off")) {
-		gf_log (this->name,
-			GF_LOG_DEBUG,
-			"cache mode selected");
-		private->envflags = DB_CREATE | DB_INIT_LOG | 
-			DB_INIT_MPOOL | DB_THREAD;
-		private->dbflags = DB_CREATE | DB_THREAD;
-		private->transaction = OFF;
-	} else {
-		gf_log (this->name,
-			GF_LOG_DEBUG,
-			"persistant mode selected");
-		private->transaction = ON;
-		private->envflags = DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG | 
-			DB_INIT_MPOOL | DB_INIT_TXN | DB_RECOVER | DB_THREAD;
-		private->dbflags = DB_CREATE | DB_THREAD;
-	}
+        int   ret = -1;
+        char *mode = NULL;
+
+        ret = dict_get_str (options, "mode", &mode);
+
+        if ((ret == 0)
+            && (!strcmp (mode, "cache"))) {
+                gf_log (this->name, GF_LOG_DEBUG,
+                        "cache mode selected");
+                private->envflags = DB_CREATE | DB_INIT_LOG |
+                        DB_INIT_MPOOL | DB_THREAD;
+                private->dbflags = DB_CREATE | DB_THREAD;
+                private->transaction = OFF;
+        } else {
+                gf_log (this->name, GF_LOG_DEBUG,
+                        "persistant mode selected");
+                private->transaction = ON;
+                private->envflags = DB_CREATE | DB_INIT_LOCK | DB_INIT_LOG |
+                        DB_INIT_MPOOL | DB_INIT_TXN | DB_RECOVER | DB_THREAD;
+                private->dbflags = DB_CREATE | DB_THREAD;
+
+                bdb_lock_timeout_init (this, options, private);
+
+                bdb_transaction_timeout_init (this, options, private);
+
+                bdb_log_remove_init (this, options, private);
+
+                bdb_checkpoint_interval_init (this, options, private);
+        }
 }
 
 static inline void
-BDB_ACCESS_MODE_INIT (xlator_t *this,
-		      dict_t *options, 
-		      struct bdb_private *private)
+bdb_access_mode_init (xlator_t *this,
+                      dict_t *options,
+                      struct bdb_private *private)
 {
-	data_t *access_mode = NULL;
-	
-	access_mode = dict_get (options, "access-mode");
-    
-	if (access_mode && !strcmp (access_mode->data, "btree")) {
-		gf_log (this->name,
-			GF_LOG_DEBUG,
-			"using access mode BTREE");
-		private->access_mode = DB_BTREE;
-	} else {
-		gf_log (this->name,
-			GF_LOG_DEBUG,
-			"using access mode HASH");
-		private->access_mode = DB_HASH;
-	}
+        int   ret = -1;
+        char *access_mode = NULL;
+
+        ret = dict_get_str (options, "access-mode", &access_mode);
+
+        if ((ret == 0)
+            && (!strcmp (access_mode, "btree"))) {
+                gf_log (this->name, GF_LOG_DEBUG,
+                        "using access mode BTREE");
+                private->access_mode = DB_BTREE;
+        } else {
+                gf_log (this->name, GF_LOG_DEBUG,
+                        "using access mode HASH");
+                private->access_mode = DB_HASH;
+        }
 }
 
 
 /* bdb_db_init - initialize bdb xlator
- * 
- * reads the options from @options dictionary and sets appropriate values in @this->private.
- * also initializes DB_ENV.
  *
- * return: 0 on success or -1 on error (with logging the error through gf_log()).
+ * reads the options from @options dictionary and sets appropriate values in
+ * @this->private. also initializes DB_ENV.
+ *
+ * return: 0 on success or -1 on error
+ * (with logging the error through gf_log()).
  */
 int
 bdb_db_init (xlator_t *this,
              dict_t *options)
 {
-	/* create a db entry for root */
-	int32_t        op_ret             = 0;
-	bdb_private_t *private            = NULL;
-  
-	private = this->private;
+        /* create a db entry for root */
+        int32_t        op_ret             = 0;
+        bdb_private_t *private            = NULL;
 
-	BDB_CACHE_INIT (this, options, private);
-	
-	BDB_ACCESS_MODE_INIT (this, options, private);
+        private = this->private;
 
-	BDB_TRANSACTION_INIT (this, options, private);
+        bdb_cache_init (this, options, private);
 
-	BDB_TRANSACTION_TIMEOUT_INIT (this, options, private);
+        bdb_access_mode_init (this, options, private);
 
-	BDB_LOCK_TIMEOUT_INIT (this, options, private);
+        bdb_transaction_init (this, options, private);
 
-	{
-		LOCK_INIT (&private->ino_lock);
-		private->next_ino = 2;
-	}
-	
-	BDB_CHECKPOINT_TIMEOUT_INIT (this, options, private);
-	
-	BDB_FILE_MODE_INIT (this, options, private);
+        {
+                LOCK_INIT (&private->ino_lock);
+                private->next_ino = 2;
+        }
 
-	BDB_DIR_MODE_INIT (this, options, private);
+        bdb_file_mode_init (this, options, private);
 
-	BDB_TABLE_INIT (this, options, private);
+        bdb_dir_mode_init (this, options, private);
 
-	BDB_ERRFILE_INIT (this, options, private);
+        bdb_table_init (this, options, private);
 
-	BDB_LOG_REMOVE_INIT (this, options, private);
+        bdb_errfile_init (this, options, private);
 
-	BDB_DIRECTORY_INIT (this, options, private);
+        bdb_directory_init (this, options, private);
 
-	return op_ret;
+        return op_ret;
 }