performance/io-cache: hold lock on ioc_inode whereever a page is being accessed/modified

Change-Id: Idbec92e3ffb838a0ac866fb42ceb6ee26a0b8a87
BUG: 2939
Reviewed-on: http://review.gluster.com/25
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Anand Avati <avati@gluster.com>

5 files changed, 1697 insertions, 1592 deletions

diff --git a/xlators/performance/io-cache/src/io-cache.c b/xlators/performance/io-cache/src/io-cache.c
index 553aecef4..ac4be6149 100644
--- a/xlators/performance/io-cache/src/io-cache.c
+++ b/xlators/performance/io-cache/src/io-cache.c
@@ -46,7 +46,7 @@ struct volume_options options[];
 inline uint32_t
 ioc_hashfn (void *data, int len)
 {
-        off_t offset;
+        off_t offset = 0;
 
         offset = *(off_t *) data;
 
@@ -56,50 +56,56 @@ ioc_hashfn (void *data, int len)
 inline ioc_inode_t *
 ioc_inode_reupdate (ioc_inode_t *ioc_inode)
 {
-	ioc_table_t *table = ioc_inode->table;
+        ioc_table_t *table = NULL;
+
+        table = ioc_inode->table;
 
-	list_add_tail (&ioc_inode->inode_lru,
-		       &table->inode_lru[ioc_inode->weight]);
+        list_add_tail (&ioc_inode->inode_lru,
+                       &table->inode_lru[ioc_inode->weight]);
 
-	return ioc_inode;
+        return ioc_inode;
 }
 
 inline ioc_inode_t *
 ioc_get_inode (dict_t *dict, char *name)
 {
-	ioc_inode_t *ioc_inode = NULL;
-	data_t      *ioc_inode_data = dict_get (dict, name);
-	ioc_table_t *table = NULL;
-
-	if (ioc_inode_data) {
-		ioc_inode = data_to_ptr (ioc_inode_data);
-		table = ioc_inode->table;
-
-		ioc_table_lock (table);
-		{
-			if (list_empty (&ioc_inode->inode_lru)) {
-				ioc_inode = ioc_inode_reupdate (ioc_inode);
-			}
-		}
-		ioc_table_unlock (table);
-	}
-
-	return ioc_inode;
+        ioc_inode_t *ioc_inode      = NULL;
+        data_t      *ioc_inode_data = NULL;
+        ioc_table_t *table          = NULL;
+
+        ioc_inode_data = dict_get (dict, name);
+
+        if (ioc_inode_data) {
+                ioc_inode = data_to_ptr (ioc_inode_data);
+                table = ioc_inode->table;
+
+                ioc_table_lock (table);
+                {
+                        if (list_empty (&ioc_inode->inode_lru)) {
+                                ioc_inode = ioc_inode_reupdate (ioc_inode);
+                        }
+                }
+                ioc_table_unlock (table);
+        }
+
+        return ioc_inode;
 }
 
 int32_t
 ioc_inode_need_revalidate (ioc_inode_t *ioc_inode)
 {
-	int8_t         need_revalidate = 0;
-	struct timeval tv = {0,};
-	ioc_table_t    *table = ioc_inode->table;
+        int8_t          need_revalidate = 0;
+        struct timeval  tv              = {0,};
+        ioc_table_t    *table           = NULL;
+
+        table = ioc_inode->table;
 
-	gettimeofday (&tv, NULL);
+        gettimeofday (&tv, NULL);
 
-	if (time_elapsed (&tv, &ioc_inode->cache.tv) >= table->cache_timeout)
-		need_revalidate = 1;
+        if (time_elapsed (&tv, &ioc_inode->cache.tv) >= table->cache_timeout)
+                need_revalidate = 1;
 
-	return need_revalidate;
+        return need_revalidate;
 }
 
 /*
@@ -112,41 +118,41 @@ ioc_inode_need_revalidate (ioc_inode_t *ioc_inode)
 int64_t
 __ioc_inode_flush (ioc_inode_t *ioc_inode)
 {
-	ioc_page_t *curr = NULL, *next = NULL;
-	int64_t    destroy_size = 0;
-	int64_t    ret = 0;
+        ioc_page_t *curr         = NULL, *next = NULL;
+        int64_t     destroy_size = 0;
+        int64_t     ret          = 0;
 
-	list_for_each_entry_safe (curr, next, &ioc_inode->cache.page_lru,
+        list_for_each_entry_safe (curr, next, &ioc_inode->cache.page_lru,
                                   page_lru) {
-		ret = ioc_page_destroy (curr);
+                ret = __ioc_page_destroy (curr);
 
-		if (ret != -1)
-			destroy_size += ret;
-	}
+                if (ret != -1)
+                        destroy_size += ret;
+        }
 
-	return destroy_size;
+        return destroy_size;
 }
 
 void
 ioc_inode_flush (ioc_inode_t *ioc_inode)
 {
-	int64_t destroy_size = 0;
-
-	ioc_inode_lock (ioc_inode);
-	{
-		destroy_size = __ioc_inode_flush (ioc_inode);
-	}
-	ioc_inode_unlock (ioc_inode);
-
-	if (destroy_size) {
-		ioc_table_lock (ioc_inode->table);
-		{
-			ioc_inode->table->cache_used -= destroy_size;
-		}
-		ioc_table_unlock (ioc_inode->table);
-	}
-
-	return;
+        int64_t destroy_size = 0;
+
+        ioc_inode_lock (ioc_inode);
+        {
+                destroy_size = __ioc_inode_flush (ioc_inode);
+        }
+        ioc_inode_unlock (ioc_inode);
+
+        if (destroy_size) {
+                ioc_table_lock (ioc_inode->table);
+                {
+                        ioc_inode->table->cache_used -= destroy_size;
+                }
+                ioc_table_unlock (ioc_inode->table);
+        }
+
+        return;
 }
 
 int32_t
@@ -154,44 +160,44 @@ ioc_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                  int32_t op_ret, int32_t op_errno,
                  struct iatt *preop, struct iatt *postop)
 {
- 	STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, preop, postop);
- 	return 0;
+        STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, preop, postop);
+        return 0;
 }
 
 int32_t
 ioc_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc,
              struct iatt *stbuf, int32_t valid)
 {
- 	uint64_t ioc_inode = 0;
+        uint64_t ioc_inode = 0;
 
- 	inode_ctx_get (loc->inode, this, &ioc_inode);
+        inode_ctx_get (loc->inode, this, &ioc_inode);
 
- 	if (ioc_inode
+        if (ioc_inode
             && ((valid & GF_SET_ATTR_ATIME)
                 || (valid & GF_SET_ATTR_MTIME)))
- 		ioc_inode_flush ((ioc_inode_t *)(long)ioc_inode);
+                ioc_inode_flush ((ioc_inode_t *)(long)ioc_inode);
 
- 	STACK_WIND (frame, ioc_setattr_cbk, FIRST_CHILD (this),
+        STACK_WIND (frame, ioc_setattr_cbk, FIRST_CHILD (this),
                     FIRST_CHILD (this)->fops->setattr, loc, stbuf, valid);
 
- 	return 0;
+        return 0;
 }
 
 int32_t
 ioc_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		int32_t op_ret,	int32_t op_errno, inode_t *inode,
-		struct iatt *stbuf, dict_t *dict, struct iatt *postparent)
+                int32_t op_ret,	int32_t op_errno, inode_t *inode,
+                struct iatt *stbuf, dict_t *dict, struct iatt *postparent)
 {
-	ioc_inode_t   *ioc_inode = NULL;
-	ioc_table_t   *table = NULL;
-	uint8_t       cache_still_valid = 0;
-	uint64_t      tmp_ioc_inode = 0;
-	uint32_t      weight = 0xffffffff;
-	const char   *path = NULL;
-        ioc_local_t  *local = NULL;
-
-	if (op_ret != 0)
-		goto out;
+        ioc_inode_t *ioc_inode         = NULL;
+        ioc_table_t *table             = NULL;
+        uint8_t      cache_still_valid = 0;
+        uint64_t     tmp_ioc_inode     = 0;
+        uint32_t     weight            = 0xffffffff;
+        const char  *path              = NULL;
+        ioc_local_t *local             = NULL;
+
+        if (op_ret != 0)
+                goto out;
 
         local = frame->local;
         if (local == NULL) {
@@ -258,16 +264,16 @@ out:
                 loc_wipe (&local->file_loc);
         }
 
-	STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, inode, stbuf,
+        STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, inode, stbuf,
                              dict, postparent);
-	return 0;
+        return 0;
 }
 
 int32_t
 ioc_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc,
-	    dict_t *xattr_req)
+            dict_t *xattr_req)
 {
-        ioc_local_t *local = NULL;
+        ioc_local_t *local    = NULL;
         int32_t      op_errno = -1, ret = -1;
 
         local = GF_CALLOC (1, sizeof (*local),
@@ -287,16 +293,16 @@ ioc_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc,
 
         frame->local = local;
 
-	STACK_WIND (frame, ioc_lookup_cbk, FIRST_CHILD (this),
-		    FIRST_CHILD (this)->fops->lookup, loc, xattr_req);
+        STACK_WIND (frame, ioc_lookup_cbk, FIRST_CHILD (this),
+                    FIRST_CHILD (this)->fops->lookup, loc, xattr_req);
 
         return 0;
 
 unwind:
-	STACK_UNWIND_STRICT (lookup, frame, -1, op_errno, NULL, NULL,
+        STACK_UNWIND_STRICT (lookup, frame, -1, op_errno, NULL, NULL,
                              NULL, NULL);
 
-	return 0;
+        return 0;
 }
 
 /*
@@ -310,14 +316,14 @@ unwind:
 int32_t
 ioc_forget (xlator_t *this, inode_t *inode)
 {
-	uint64_t ioc_inode = 0;
+        uint64_t ioc_inode = 0;
 
-	inode_ctx_get (inode, this, &ioc_inode);
+        inode_ctx_get (inode, this, &ioc_inode);
 
-	if (ioc_inode)
-		ioc_inode_destroy ((ioc_inode_t *)(long)ioc_inode);
+        if (ioc_inode)
+                ioc_inode_destroy ((ioc_inode_t *)(long)ioc_inode);
 
-	return 0;
+        return 0;
 }
 
 
@@ -334,86 +340,87 @@ ioc_forget (xlator_t *this, inode_t *inode)
  */
 int32_t
 ioc_cache_validate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-			int32_t op_ret, int32_t op_errno, struct iatt *stbuf)
+                        int32_t op_ret, int32_t op_errno, struct iatt *stbuf)
 {
-	ioc_local_t *local = NULL;
-	ioc_inode_t *ioc_inode = NULL;
-	size_t      destroy_size = 0;
-	struct iatt *local_stbuf = NULL;
+        ioc_local_t *local        = NULL;
+        ioc_inode_t *ioc_inode    = NULL;
+        size_t       destroy_size = 0;
+        struct iatt *local_stbuf  = NULL;
 
         local = frame->local;
-	ioc_inode = local->inode;
+        ioc_inode = local->inode;
         local_stbuf = stbuf;
 
-	if ((op_ret == -1) ||
-	    ((op_ret >= 0) && !ioc_cache_still_valid(ioc_inode, stbuf))) {
-		gf_log (ioc_inode->table->xl->name, GF_LOG_DEBUG,
-			"cache for inode(%p) is invalid. flushing all pages",
-			ioc_inode);
-		/* NOTE: only pages with no waiting frames are flushed by
-		 * ioc_inode_flush. page_fault will be generated for all
-		 * the pages which have waiting frames by ioc_inode_wakeup()
-		 */
-		ioc_inode_lock (ioc_inode);
-		{
-			destroy_size = __ioc_inode_flush (ioc_inode);
-			if (op_ret >= 0) {
-				ioc_inode->cache.mtime = stbuf->ia_mtime;
-                                ioc_inode->cache.mtime_nsec = stbuf->ia_mtime_nsec;
+        if ((op_ret == -1) ||
+            ((op_ret >= 0) && !ioc_cache_still_valid(ioc_inode, stbuf))) {
+                gf_log (ioc_inode->table->xl->name, GF_LOG_DEBUG,
+                        "cache for inode(%p) is invalid. flushing all pages",
+                        ioc_inode);
+                /* NOTE: only pages with no waiting frames are flushed by
+                 * ioc_inode_flush. page_fault will be generated for all
+                 * the pages which have waiting frames by ioc_inode_wakeup()
+                 */
+                ioc_inode_lock (ioc_inode);
+                {
+                        destroy_size = __ioc_inode_flush (ioc_inode);
+                        if (op_ret >= 0) {
+                                ioc_inode->cache.mtime = stbuf->ia_mtime;
+                                ioc_inode->cache.mtime_nsec
+                                        = stbuf->ia_mtime_nsec;
                         }
-		}
-		ioc_inode_unlock (ioc_inode);
-		local_stbuf = NULL;
-	}
-
-	if (destroy_size) {
-		ioc_table_lock (ioc_inode->table);
-		{
-			ioc_inode->table->cache_used -= destroy_size;
-		}
-		ioc_table_unlock (ioc_inode->table);
-	}
-
-	if (op_ret < 0)
-		local_stbuf = NULL;
-
-	ioc_inode_lock (ioc_inode);
-	{
-		gettimeofday (&ioc_inode->cache.tv, NULL);
-	}
-	ioc_inode_unlock (ioc_inode);
-
-	ioc_inode_wakeup (frame, ioc_inode, local_stbuf);
-
-	/* any page-fault initiated by ioc_inode_wakeup() will have its own
-	 * fd_ref on fd, safe to unref validate frame's private copy
-	 */
-	fd_unref (local->fd);
-
-	STACK_DESTROY (frame->root);
-
-	return 0;
+                }
+                ioc_inode_unlock (ioc_inode);
+                local_stbuf = NULL;
+        }
+
+        if (destroy_size) {
+                ioc_table_lock (ioc_inode->table);
+                {
+                        ioc_inode->table->cache_used -= destroy_size;
+                }
+                ioc_table_unlock (ioc_inode->table);
+        }
+
+        if (op_ret < 0)
+                local_stbuf = NULL;
+
+        ioc_inode_lock (ioc_inode);
+        {
+                gettimeofday (&ioc_inode->cache.tv, NULL);
+        }
+        ioc_inode_unlock (ioc_inode);
+
+        ioc_inode_wakeup (frame, ioc_inode, local_stbuf);
+
+        /* any page-fault initiated by ioc_inode_wakeup() will have its own
+         * fd_ref on fd, safe to unref validate frame's private copy
+         */
+        fd_unref (local->fd);
+
+        STACK_DESTROY (frame->root);
+
+        return 0;
 }
 
 int32_t
 ioc_wait_on_inode (ioc_inode_t *ioc_inode, ioc_page_t *page)
 {
-	ioc_waitq_t *waiter = NULL, *trav = NULL;
-	uint32_t    page_found = 0;
-        int32_t     ret = 0;
-
-	trav = ioc_inode->waitq;
-
-	while (trav) {
-		if (trav->data == page) {
-			page_found = 1;
-			break;
-		}
-		trav = trav->next;
-	}
-
-	if (!page_found) {
-		waiter = GF_CALLOC (1, sizeof (ioc_waitq_t),
+        ioc_waitq_t *waiter     = NULL, *trav = NULL;
+        uint32_t     page_found = 0;
+        int32_t      ret        = 0;
+
+        trav = ioc_inode->waitq;
+
+        while (trav) {
+                if (trav->data == page) {
+                        page_found = 1;
+                        break;
+                }
+                trav = trav->next;
+        }
+
+        if (!page_found) {
+                waiter = GF_CALLOC (1, sizeof (ioc_waitq_t),
                                     gf_ioc_mt_ioc_waitq_t);
                 if (waiter == NULL) {
                         gf_log (ioc_inode->table->xl->name, GF_LOG_ERROR,
@@ -422,13 +429,13 @@ ioc_wait_on_inode (ioc_inode_t *ioc_inode, ioc_page_t *page)
                         goto out;
                 }
 
-		waiter->data = page;
-		waiter->next = ioc_inode->waitq;
-		ioc_inode->waitq = waiter;
-	}
+                waiter->data = page;
+                waiter->next = ioc_inode->waitq;
+                ioc_inode->waitq = waiter;
+        }
 
 out:
-	return ret;
+        return ret;
 }
 
 /*
@@ -441,15 +448,15 @@ out:
  */
 int32_t
 ioc_cache_validate (call_frame_t *frame, ioc_inode_t *ioc_inode, fd_t *fd,
-		    ioc_page_t *page)
+                    ioc_page_t *page)
 {
-	call_frame_t *validate_frame = NULL;
-	ioc_local_t  *validate_local = NULL;
-        ioc_local_t  *local = NULL;
-        int32_t      ret = 0;
+        call_frame_t *validate_frame = NULL;
+        ioc_local_t  *validate_local = NULL;
+        ioc_local_t  *local          = NULL;
+        int32_t       ret            = 0;
 
         local = frame->local;
-	validate_local = GF_CALLOC (1, sizeof (ioc_local_t),
+        validate_local = GF_CALLOC (1, sizeof (ioc_local_t),
                                     gf_ioc_mt_ioc_local_t);
         if (validate_local == NULL) {
                 ret = -1;
@@ -460,7 +467,7 @@ ioc_cache_validate (call_frame_t *frame, ioc_inode_t *ioc_inode, fd_t *fd,
                 goto out;
         }
 
-	validate_frame = copy_frame (frame);
+        validate_frame = copy_frame (frame);
         if (validate_frame == NULL) {
                 ret = -1;
                 local->op_ret = -1;
@@ -471,44 +478,44 @@ ioc_cache_validate (call_frame_t *frame, ioc_inode_t *ioc_inode, fd_t *fd,
                 goto out;
         }
 
-	validate_local->fd = fd_ref (fd);
-	validate_local->inode = ioc_inode;
-	validate_frame->local = validate_local;
+        validate_local->fd = fd_ref (fd);
+        validate_local->inode = ioc_inode;
+        validate_frame->local = validate_local;
 
-	STACK_WIND (validate_frame, ioc_cache_validate_cbk,
+        STACK_WIND (validate_frame, ioc_cache_validate_cbk,
                     FIRST_CHILD (frame->this),
                     FIRST_CHILD (frame->this)->fops->fstat, fd);
 
 out:
-	return ret;
+        return ret;
 }
 
 inline uint32_t
 is_match (const char *path, const char *pattern)
 {
-	int32_t ret = 0;
+        int32_t ret = 0;
 
-	ret = fnmatch (pattern, path, FNM_NOESCAPE);
+        ret = fnmatch (pattern, path, FNM_NOESCAPE);
 
-	return (ret == 0);
+        return (ret == 0);
 }
 
 uint32_t
 ioc_get_priority (ioc_table_t *table, const char *path)
 {
-	uint32_t            priority = 1;
-	struct ioc_priority *curr = NULL;
+        uint32_t             priority = 1;
+        struct ioc_priority *curr     = NULL;
 
-	if (list_empty(&table->priority_list))
-            return priority;
+        if (list_empty(&table->priority_list))
+                return priority;
 
-    priority = 0;
-    list_for_each_entry (curr, &table->priority_list, list) {
-            if (is_match (path, curr->pattern))
-                    priority = curr->priority;
-    }
+        priority = 0;
+        list_for_each_entry (curr, &table->priority_list, list) {
+                if (is_match (path, curr->pattern))
+                        priority = curr->priority;
+        }
 
-	return priority;
+        return priority;
 }
 
 /*
@@ -524,13 +531,13 @@ ioc_get_priority (ioc_table_t *table, const char *path)
  */
 int32_t
 ioc_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-	          int32_t op_errno, fd_t *fd)
+              int32_t op_errno, fd_t *fd)
 {
-        uint64_t    tmp_ioc_inode = 0;
-        ioc_local_t *local = NULL;
-        ioc_table_t *table = NULL;
-        ioc_inode_t *ioc_inode = NULL;
-        uint32_t    weight = 0xffffffff;
+        uint64_t     tmp_ioc_inode = 0;
+        ioc_local_t *local         = NULL;
+        ioc_table_t *table         = NULL;
+        ioc_inode_t *ioc_inode     = NULL;
+        uint32_t     weight        = 0xffffffff;
 
         local = frame->local;
         if (!this || !this->private) {
@@ -556,7 +563,8 @@ ioc_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
                 {
                         if ((table->min_file_size > ioc_inode->ia_size)
                             || ((table->max_file_size > 0)
-                                && (table->max_file_size < ioc_inode->ia_size))) {
+                                && (table->max_file_size
+                                    < ioc_inode->ia_size))) {
                                 fd_ctx_set (fd, this, 1);
                         }
                 }
@@ -567,7 +575,7 @@ ioc_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
                         /* O_DIRECT is only for one fd, not the inode
                          * as a whole
                          */
-                    fd_ctx_set (fd, this, 1);
+                        fd_ctx_set (fd, this, 1);
                 }
                 if ((local->wbflags & GF_OPEN_NOWB) != 0) {
                         /* disable caching as asked by NFS */
@@ -577,7 +585,7 @@ ioc_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
                 /* weight = 0, we disable caching on it */
                 if (weight == 0) {
                         /* we allow a pattern-matched cache disable this way
-                        */
+                         */
                         fd_ctx_set (fd, this, 1);
                 }
         }
@@ -588,7 +596,7 @@ out:
 
         STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd);
 
-	return 0;
+        return 0;
 }
 
 /*
@@ -607,15 +615,15 @@ out:
 int32_t
 ioc_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 int32_t op_ret,	int32_t op_errno, fd_t *fd,
-		inode_t *inode,	struct iatt *buf, struct iatt *preparent,
+                inode_t *inode,	struct iatt *buf, struct iatt *preparent,
                 struct iatt *postparent)
 {
-	ioc_local_t     *local = NULL;
-	ioc_table_t     *table = NULL;
-	ioc_inode_t     *ioc_inode = NULL;
-	uint32_t        weight = 0xffffffff;
-	const char      *path = NULL;
-        int             ret = -1;
+        ioc_local_t *local     = NULL;
+        ioc_table_t *table     = NULL;
+        ioc_inode_t *ioc_inode = NULL;
+        uint32_t     weight    = 0xffffffff;
+        const char  *path      = NULL;
+        int          ret       = -1;
 
         local = frame->local;
         if (!this || !this->private) {
@@ -627,7 +635,7 @@ ioc_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         table = this->private;
         path = local->file_loc.path;
 
-	if (op_ret != -1) {
+        if (op_ret != -1) {
                 /* assign weight */
                 weight = ioc_get_priority (table, path);
 
@@ -641,7 +649,8 @@ ioc_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
                         if ((table->min_file_size > ioc_inode->ia_size)
                             || ((table->max_file_size > 0)
-                                && (table->max_file_size < ioc_inode->ia_size))) {
+                                && (table->max_file_size
+                                    < ioc_inode->ia_size))) {
                                 ret = fd_ctx_set (fd, this, 1);
                         }
                 }
@@ -650,28 +659,28 @@ ioc_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 inode_ctx_put (fd->inode, this,
                                (uint64_t)(long)ioc_inode);
 
-		/* If O_DIRECT open, we disable caching on it */
-		if (local->flags & O_DIRECT)
-			/*
+                /* If O_DIRECT open, we disable caching on it */
+                if (local->flags & O_DIRECT)
+                        /*
                          * O_DIRECT is only for one fd, not the inode
-			 * as a whole */
-			ret = fd_ctx_set (fd, this, 1);
+                         * as a whole */
+                        ret = fd_ctx_set (fd, this, 1);
 
                 /* if weight == 0, we disable caching on it */
-		if (!weight)
-			/* we allow a pattern-matched cache disable this way */
-			ret = fd_ctx_set (fd, this, 1);
+                if (!weight)
+                        /* we allow a pattern-matched cache disable this way */
+                        ret = fd_ctx_set (fd, this, 1);
 
-	}
+        }
 
 out:
-	frame->local = NULL;
-	GF_FREE (local);
+        frame->local = NULL;
+        GF_FREE (local);
 
         STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, inode, buf,
                              preparent, postparent);
 
-	return 0;
+        return 0;
 }
 
 
@@ -682,10 +691,10 @@ ioc_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                struct iatt *postparent)
 {
         ioc_local_t *local     = NULL;
-	ioc_table_t *table     = NULL;
-	ioc_inode_t *ioc_inode = NULL;
-	uint32_t     weight    = 0xffffffff;
-	const char  *path      = NULL;
+        ioc_table_t *table     = NULL;
+        ioc_inode_t *ioc_inode = NULL;
+        uint32_t     weight    = 0xffffffff;
+        const char  *path      = NULL;
 
         local = frame->local;
         if (!this || !this->private) {
@@ -697,7 +706,7 @@ ioc_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         table = this->private;
         path = local->file_loc.path;
 
-	if (op_ret != -1) {
+        if (op_ret != -1) {
                 /* assign weight */
                 weight = ioc_get_priority (table, path);
 
@@ -713,17 +722,17 @@ ioc_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
                 inode_ctx_put (inode, this,
                                (uint64_t)(long)ioc_inode);
-	}
+        }
 
 out:
-	frame->local = NULL;
+        frame->local = NULL;
 
         loc_wipe (&local->file_loc);
-	GF_FREE (local);
+        GF_FREE (local);
 
-	STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, inode, buf,
+        STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, inode, buf,
                              preparent, postparent);
-	return 0;
+        return 0;
 }
 
 
@@ -731,7 +740,7 @@ int
 ioc_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
            dev_t rdev, dict_t *params)
 {
-        ioc_local_t *local = NULL;
+        ioc_local_t *local    = NULL;
         int32_t      op_errno = -1, ret = -1;
 
         local = GF_CALLOC (1, sizeof (*local),
@@ -751,10 +760,10 @@ ioc_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode,
 
         frame->local = local;
 
-	STACK_WIND (frame, ioc_mknod_cbk,
-		    FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->mknod,
-		    loc, mode, rdev, params);
+        STACK_WIND (frame, ioc_mknod_cbk,
+                    FIRST_CHILD(this),
+                    FIRST_CHILD(this)->fops->mknod,
+                    loc, mode, rdev, params);
         return 0;
 
 unwind:
@@ -763,10 +772,10 @@ unwind:
                 GF_FREE (local);
         }
 
-	STACK_UNWIND_STRICT (mknod, frame, -1, op_errno, NULL, NULL,
+        STACK_UNWIND_STRICT (mknod, frame, -1, op_errno, NULL, NULL,
                              NULL, NULL);
 
-	return 0;
+        return 0;
 }
 
 
@@ -780,10 +789,10 @@ unwind:
  */
 int32_t
 ioc_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-	  fd_t *fd, int32_t wbflags)
+          fd_t *fd, int32_t wbflags)
 {
 
-	ioc_local_t *local = NULL;
+        ioc_local_t *local = NULL;
 
         local = GF_CALLOC (1, sizeof (ioc_local_t), gf_ioc_mt_ioc_local_t);
         if (local == NULL) {
@@ -792,17 +801,17 @@ ioc_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
                 return 0;
         }
 
-	local->flags = flags;
-	local->file_loc.path = loc->path;
-	local->file_loc.inode = loc->inode;
+        local->flags = flags;
+        local->file_loc.path = loc->path;
+        local->file_loc.inode = loc->inode;
         local->wbflags = wbflags;
 
-	frame->local = local;
+        frame->local = local;
 
-	STACK_WIND (frame, ioc_open_cbk, FIRST_CHILD(this),
+        STACK_WIND (frame, ioc_open_cbk, FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->open, loc, flags, fd, wbflags);
 
-	return 0;
+        return 0;
 }
 
 /*
@@ -817,9 +826,9 @@ ioc_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
  */
 int32_t
 ioc_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
-	    mode_t mode, fd_t *fd, dict_t *params)
+            mode_t mode, fd_t *fd, dict_t *params)
 {
-	ioc_local_t *local = NULL;
+        ioc_local_t *local = NULL;
 
         local = GF_CALLOC (1, sizeof (ioc_local_t), gf_ioc_mt_ioc_local_t);
         if (local == NULL) {
@@ -829,15 +838,15 @@ ioc_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
                 return 0;
         }
 
-	local->flags = flags;
-	local->file_loc.path = loc->path;
-	frame->local = local;
+        local->flags = flags;
+        local->file_loc.path = loc->path;
+        frame->local = local;
 
-	STACK_WIND (frame, ioc_create_cbk, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->create, loc, flags, mode,
+        STACK_WIND (frame, ioc_create_cbk, FIRST_CHILD(this),
+                    FIRST_CHILD(this)->fops->create, loc, flags, mode,
                     fd, params);
 
-	return 0;
+        return 0;
 }
 
 
@@ -854,7 +863,7 @@ ioc_create (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
 int32_t
 ioc_release (xlator_t *this, fd_t *fd)
 {
-	return 0;
+        return 0;
 }
 
 /*
@@ -871,30 +880,30 @@ ioc_release (xlator_t *this, fd_t *fd)
 int32_t
 ioc_readv_disabled_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                         int32_t op_ret,	int32_t op_errno, struct iovec *vector,
-			int32_t count, struct iatt *stbuf,
+                        int32_t count, struct iatt *stbuf,
                         struct iobref *iobref)
 {
-	STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, count,
+        STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, vector, count,
                              stbuf, iobref);
-	return 0;
+        return 0;
 }
 
 
 int32_t
 ioc_need_prune (ioc_table_t *table)
 {
-	int64_t cache_difference = 0;
-
-	ioc_table_lock (table);
-	{
-		cache_difference = table->cache_used - table->cache_size;
-	}
-	ioc_table_unlock (table);
-
-	if (cache_difference > 0)
-		return 1;
-	else
-		return 0;
+        int64_t cache_difference = 0;
+
+        ioc_table_lock (table);
+        {
+                cache_difference = table->cache_used - table->cache_size;
+        }
+        ioc_table_unlock (table);
+
+        if (cache_difference > 0)
+                return 1;
+        else
+                return 0;
 }
 
 /*
@@ -909,122 +918,129 @@ void
 ioc_dispatch_requests (call_frame_t *frame, ioc_inode_t *ioc_inode, fd_t *fd,
                        off_t offset, size_t size)
 {
-	ioc_local_t *local = NULL;
-	ioc_table_t *table = NULL;
-	ioc_page_t  *trav = NULL;
-	ioc_waitq_t *waitq = NULL;
-	off_t       rounded_offset = 0;
-	off_t       rounded_end = 0;
-	off_t       trav_offset = 0;
-	int32_t     fault = 0;
-        size_t      trav_size = 0;
-        off_t       local_offset = 0;
-        int32_t     ret = -1;
-	int8_t      need_validate = 0;
-	int8_t      might_need_validate = 0;  /*
-                                               * if a page exists, do we need
-                                               * to validate it?
-                                               */
+        ioc_local_t *local               = NULL;
+        ioc_table_t *table               = NULL;
+        ioc_page_t  *trav                = NULL;
+        ioc_waitq_t *waitq               = NULL;
+        off_t        rounded_offset      = 0;
+        off_t        rounded_end         = 0;
+        off_t        trav_offset         = 0;
+        int32_t      fault               = 0;
+        size_t       trav_size           = 0;
+        off_t        local_offset        = 0;
+        int32_t      ret                 = -1;
+        int8_t       need_validate       = 0;
+        int8_t       might_need_validate = 0;  /*
+                                                * if a page exists, do we need
+                                                * to validate it?
+                                                */
         local = frame->local;
         table = ioc_inode->table;
 
-	rounded_offset = floor (offset, table->page_size);
-	rounded_end = roof (offset + size, table->page_size);
-	trav_offset = rounded_offset;
-
-	/* once a frame does read, it should be waiting on something */
-	local->wait_count++;
-
-	/* Requested region can fall in three different pages,
-	 * 1. Ready - region is already in cache, we just have to serve it.
-	 * 2. In-transit - page fault has been generated on this page, we need
-	 *    to wait till the page is ready
-	 * 3. Fault - page is not in cache, we have to generate a page fault
-	 */
-
-	might_need_validate = ioc_inode_need_revalidate (ioc_inode);
-
-	while (trav_offset < rounded_end) {
-		ioc_inode_lock (ioc_inode);
-		//{
-
-		/* look for requested region in the cache */
-		trav = ioc_page_get (ioc_inode, trav_offset);
-
-		local_offset = max (trav_offset, offset);
-		trav_size = min (((offset+size) - local_offset),
-				 table->page_size);
-
-		if (!trav) {
-			/* page not in cache, we need to generate page fault */
-			trav = ioc_page_create (ioc_inode, trav_offset);
-			fault = 1;
-			if (!trav) {
-				gf_log (frame->this->name, GF_LOG_CRITICAL,
-					"out of memory");
-                                local->op_ret = -1;
-                                local->op_errno = ENOMEM;
-                                goto out;
-			}
-		}
-
-		ioc_wait_on_page (trav, frame, local_offset, trav_size);
-
-		if (trav->ready) {
-			/* page found in cache */
-			if (!might_need_validate && !ioc_inode->waitq) {
-				/* fresh enough */
-				gf_log (frame->this->name, GF_LOG_TRACE,
-					"cache hit for trav_offset=%"PRId64""
-					"/local_offset=%"PRId64"",
-					trav_offset, local_offset);
-				waitq = ioc_page_wakeup (trav);
-			} else {
-				/* if waitq already exists, fstat revalidate is
-				   already on the way */
-				if (!ioc_inode->waitq) {
-					need_validate = 1;
-				}
-
-				ret = ioc_wait_on_inode (ioc_inode, trav);
-                                if (ret < 0) {
-                                        local->op_ret = -1;
-                                        local->op_errno = -ret;
-                                        need_validate = 0;
+        rounded_offset = floor (offset, table->page_size);
+        rounded_end = roof (offset + size, table->page_size);
+        trav_offset = rounded_offset;
+
+        /* once a frame does read, it should be waiting on something */
+        local->wait_count++;
 
-                                        waitq = ioc_page_wakeup (trav);
-                                        ioc_inode_unlock (ioc_inode);
+        /* Requested region can fall in three different pages,
+         * 1. Ready - region is already in cache, we just have to serve it.
+         * 2. In-transit - page fault has been generated on this page, we need
+         *    to wait till the page is ready
+         * 3. Fault - page is not in cache, we have to generate a page fault
+         */
 
-                                        ioc_waitq_return (waitq);
-                                        waitq = NULL;
+        might_need_validate = ioc_inode_need_revalidate (ioc_inode);
+
+        while (trav_offset < rounded_end) {
+                ioc_inode_lock (ioc_inode);
+                {
+                        /* look for requested region in the cache */
+                        trav = __ioc_page_get (ioc_inode, trav_offset);
+
+                        local_offset = max (trav_offset, offset);
+                        trav_size = min (((offset+size) - local_offset),
+                                         table->page_size);
+
+                        if (!trav) {
+                                /* page not in cache, we need to generate page
+                                 * fault
+                                 */
+                                trav = __ioc_page_create (ioc_inode,
+                                                          trav_offset);
+                                fault = 1;
+                                if (!trav) {
+                                        gf_log (frame->this->name,
+                                                GF_LOG_CRITICAL,
+                                                "out of memory");
+                                        local->op_ret = -1;
+                                        local->op_errno = ENOMEM;
                                         goto out;
                                 }
-			}
-		}
-
-		//}
-		ioc_inode_unlock (ioc_inode);
-
-		ioc_waitq_return (waitq);
-		waitq = NULL;
-
-		if (fault) {
-			fault = 0;
-			/* new page created, increase the table->cache_used */
-			ioc_page_fault (ioc_inode, frame, fd, trav_offset);
-		}
-
-		if (need_validate) {
-			need_validate = 0;
-			gf_log (frame->this->name, GF_LOG_TRACE,
-				"sending validate request for "
-				"inode(%"PRId64") at offset=%"PRId64"",
-				fd->inode->ino, trav_offset);
-			ret = ioc_cache_validate (frame, ioc_inode, fd, trav);
+                        }
+
+                        __ioc_wait_on_page (trav, frame, local_offset,
+                                            trav_size);
+
+                        if (trav->ready) {
+                                /* page found in cache */
+                                if (!might_need_validate && !ioc_inode->waitq) {
+                                        /* fresh enough */
+                                        gf_log (frame->this->name, GF_LOG_TRACE,
+                                                "cache hit for trav_offset=%"
+                                                PRId64"/local_offset=%"PRId64"",
+                                                trav_offset, local_offset);
+                                        waitq = __ioc_page_wakeup (trav);
+                                } else {
+                                        /* if waitq already exists, fstat
+                                         * revalidate is
+                                         * already on the way
+                                         */
+                                        if (!ioc_inode->waitq) {
+                                                need_validate = 1;
+                                        }
+
+                                        ret = ioc_wait_on_inode (ioc_inode,
+                                                                 trav);
+                                        if (ret < 0) {
+                                                local->op_ret = -1;
+                                                local->op_errno = -ret;
+                                                need_validate = 0;
+
+                                                waitq = __ioc_page_wakeup (trav);
+                                                ioc_inode_unlock (ioc_inode);
+
+                                                ioc_waitq_return (waitq);
+                                                waitq = NULL;
+                                                goto out;
+                                        }
+                                }
+                        }
+
+                }
+                ioc_inode_unlock (ioc_inode);
+
+                ioc_waitq_return (waitq);
+                waitq = NULL;
+
+                if (fault) {
+                        fault = 0;
+                        /* new page created, increase the table->cache_used */
+                        ioc_page_fault (ioc_inode, frame, fd, trav_offset);
+                }
+
+                if (need_validate) {
+                        need_validate = 0;
+                        gf_log (frame->this->name, GF_LOG_TRACE,
+                                "sending validate request for "
+                                "inode(%"PRId64") at offset=%"PRId64"",
+                                fd->inode->ino, trav_offset);
+                        ret = ioc_cache_validate (frame, ioc_inode, fd, trav);
                         if (ret == -1) {
                                 ioc_inode_lock (ioc_inode);
                                 {
-                                        waitq = ioc_page_wakeup (trav);
+                                        waitq = __ioc_page_wakeup (trav);
                                 }
                                 ioc_inode_unlock (ioc_inode);
 
@@ -1032,19 +1048,19 @@ ioc_dispatch_requests (call_frame_t *frame, ioc_inode_t *ioc_inode, fd_t *fd,
                                 waitq = NULL;
                                 goto out;
                         }
-		}
+                }
 
-		trav_offset += table->page_size;
-	}
+                trav_offset += table->page_size;
+        }
 
 out:
-	ioc_frame_return (frame);
+        ioc_frame_return (frame);
 
-	if (ioc_need_prune (ioc_inode->table)) {
-		ioc_prune (ioc_inode->table);
-	}
+        if (ioc_need_prune (ioc_inode->table)) {
+                ioc_prune (ioc_inode->table);
+        }
 
-	return;
+        return;
 }
 
 
@@ -1060,30 +1076,30 @@ out:
  */
 int32_t
 ioc_readv (call_frame_t *frame, xlator_t *this, fd_t *fd,
-	   size_t size, off_t offset)
+           size_t size, off_t offset)
 {
-	uint64_t     tmp_ioc_inode = 0;
-	ioc_inode_t  *ioc_inode = NULL;
-	ioc_local_t  *local = NULL;
-	uint32_t     weight = 0;
-        ioc_table_t  *table = NULL;
-        uint32_t     num_pages = 0;
-        int32_t      op_errno = -1;
+        uint64_t     tmp_ioc_inode = 0;
+        ioc_inode_t *ioc_inode     = NULL;
+        ioc_local_t *local         = NULL;
+        uint32_t     weight        = 0;
+        ioc_table_t *table         = NULL;
+        uint32_t     num_pages     = 0;
+        int32_t      op_errno      = -1;
 
         if (!this) {
                 goto out;
         }
 
-	inode_ctx_get (fd->inode, this, &tmp_ioc_inode);
-	ioc_inode = (ioc_inode_t *)(long)tmp_ioc_inode;
-	if (!ioc_inode) {
-		/* caching disabled, go ahead with normal readv */
-		STACK_WIND (frame, ioc_readv_disabled_cbk,
+        inode_ctx_get (fd->inode, this, &tmp_ioc_inode);
+        ioc_inode = (ioc_inode_t *)(long)tmp_ioc_inode;
+        if (!ioc_inode) {
+                /* caching disabled, go ahead with normal readv */
+                STACK_WIND (frame, ioc_readv_disabled_cbk,
                             FIRST_CHILD (frame->this),
-			    FIRST_CHILD (frame->this)->fops->readv, fd, size,
+                            FIRST_CHILD (frame->this)->fops->readv, fd, size,
                             offset);
-		return 0;
-	}
+                return 0;
+        }
 
 
         table = this->private;
@@ -1101,7 +1117,7 @@ ioc_readv (call_frame_t *frame, xlator_t *this, fd_t *fd,
 
                         num_pages = (table->cache_size / table->page_size)
                                 + ((table->cache_size % table->page_size)
-                                ? 1 : 0);
+                                   ? 1 : 0);
 
                         table->mem_pool
                                 =  mem_pool_new (rbthash_entry_t, num_pages);
@@ -1122,9 +1138,9 @@ ioc_readv (call_frame_t *frame, xlator_t *this, fd_t *fd,
                 if (!ioc_inode->cache.page_table) {
                         ioc_inode->cache.page_table
                                 = rbthash_table_init
-                                                (IOC_PAGE_TABLE_BUCKET_COUNT,
-                                                 ioc_hashfn, NULL, 0,
-                                                 table->mem_pool);
+                                (IOC_PAGE_TABLE_BUCKET_COUNT,
+                                 ioc_hashfn, NULL, 0,
+                                 table->mem_pool);
 
                         if (ioc_inode->cache.page_table == NULL) {
                                 op_errno = ENOMEM;
@@ -1135,47 +1151,47 @@ ioc_readv (call_frame_t *frame, xlator_t *this, fd_t *fd,
         }
         ioc_inode_unlock (ioc_inode);
 
-	if (!fd_ctx_get (fd, this, NULL)) {
-		/* disable caching for this fd, go ahead with normal readv */
-		STACK_WIND (frame, ioc_readv_disabled_cbk,
+        if (!fd_ctx_get (fd, this, NULL)) {
+                /* disable caching for this fd, go ahead with normal readv */
+                STACK_WIND (frame, ioc_readv_disabled_cbk,
                             FIRST_CHILD (frame->this),
-			    FIRST_CHILD (frame->this)->fops->readv, fd, size,
+                            FIRST_CHILD (frame->this)->fops->readv, fd, size,
                             offset);
-		return 0;
-	}
+                return 0;
+        }
 
-	local = (ioc_local_t *) GF_CALLOC (1, sizeof (ioc_local_t),
-                                            gf_ioc_mt_ioc_local_t);
+        local = (ioc_local_t *) GF_CALLOC (1, sizeof (ioc_local_t),
+                                           gf_ioc_mt_ioc_local_t);
         if (local == NULL) {
                 gf_log (this->name, GF_LOG_ERROR, "out of memory");
                 op_errno = ENOMEM;
                 goto out;
         }
 
-	INIT_LIST_HEAD (&local->fill_list);
+        INIT_LIST_HEAD (&local->fill_list);
 
-	frame->local = local;
-	local->pending_offset = offset;
-	local->pending_size = size;
-	local->offset = offset;
-	local->size = size;
-	local->inode = ioc_inode;
+        frame->local = local;
+        local->pending_offset = offset;
+        local->pending_size = size;
+        local->offset = offset;
+        local->size = size;
+        local->inode = ioc_inode;
 
-	gf_log (this->name, GF_LOG_TRACE,
-		"NEW REQ (%p) offset = %"PRId64" && size = %"GF_PRI_SIZET"",
-		frame, offset, size);
+        gf_log (this->name, GF_LOG_TRACE,
+                "NEW REQ (%p) offset = %"PRId64" && size = %"GF_PRI_SIZET"",
+                frame, offset, size);
 
-	weight = ioc_inode->weight;
+        weight = ioc_inode->weight;
 
-	ioc_table_lock (ioc_inode->table);
-	{
-		list_move_tail (&ioc_inode->inode_lru,
-				&ioc_inode->table->inode_lru[weight]);
-	}
-	ioc_table_unlock (ioc_inode->table);
+        ioc_table_lock (ioc_inode->table);
+        {
+                list_move_tail (&ioc_inode->inode_lru,
+                                &ioc_inode->table->inode_lru[weight]);
+        }
+        ioc_table_unlock (ioc_inode->table);
 
-	ioc_dispatch_requests (frame, ioc_inode, fd, offset, size);
-	return 0;
+        ioc_dispatch_requests (frame, ioc_inode, fd, offset, size);
+        return 0;
 
 out:
         STACK_UNWIND_STRICT (readv, frame, -1, op_errno, NULL, 0, NULL, NULL);
@@ -1194,20 +1210,20 @@ out:
  */
 int32_t
 ioc_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-		int32_t op_ret,	int32_t op_errno, struct iatt *prebuf,
+                int32_t op_ret,	int32_t op_errno, struct iatt *prebuf,
                 struct iatt *postbuf)
 {
-	ioc_local_t *local     = NULL;
-	uint64_t    ioc_inode = 0;
+        ioc_local_t *local     = NULL;
+        uint64_t     ioc_inode = 0;
 
         local = frame->local;
-	inode_ctx_get (local->fd->inode, this, &ioc_inode);
+        inode_ctx_get (local->fd->inode, this, &ioc_inode);
 
-	if (ioc_inode)
-		ioc_inode_flush ((ioc_inode_t *)(long)ioc_inode);
+        if (ioc_inode)
+                ioc_inode_flush ((ioc_inode_t *)(long)ioc_inode);
 
-	STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf);
-	return 0;
+        STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, prebuf, postbuf);
+        return 0;
 }
 
 /*
@@ -1223,13 +1239,13 @@ ioc_writev_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
  */
 int32_t
 ioc_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
-	    struct iovec *vector, int32_t count, off_t offset,
+            struct iovec *vector, int32_t count, off_t offset,
             struct iobref *iobref)
 {
-	ioc_local_t *local     = NULL;
-	uint64_t    ioc_inode = 0;
+        ioc_local_t *local     = NULL;
+        uint64_t     ioc_inode = 0;
 
-	local = GF_CALLOC (1, sizeof (ioc_local_t), gf_ioc_mt_ioc_local_t);
+        local = GF_CALLOC (1, sizeof (ioc_local_t), gf_ioc_mt_ioc_local_t);
         if (local == NULL) {
                 gf_log (this->name, GF_LOG_ERROR, "out of memory");
 
@@ -1237,19 +1253,19 @@ ioc_writev (call_frame_t *frame, xlator_t *this, fd_t *fd,
                 return 0;
         }
 
-	/* TODO: why is it not fd_ref'ed */
-	local->fd = fd;
-	frame->local = local;
+        /* TODO: why is it not fd_ref'ed */
+        local->fd = fd;
+        frame->local = local;
 
-	inode_ctx_get (fd->inode, this, &ioc_inode);
-	if (ioc_inode)
-		ioc_inode_flush ((ioc_inode_t *)(long)ioc_inode);
+        inode_ctx_get (fd->inode, this, &ioc_inode);
+        if (ioc_inode)
+                ioc_inode_flush ((ioc_inode_t *)(long)ioc_inode);
 
-	STACK_WIND (frame, ioc_writev_cbk, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->writev, fd, vector, count, offset,
+        STACK_WIND (frame, ioc_writev_cbk, FIRST_CHILD(this),
+                    FIRST_CHILD(this)->fops->writev, fd, vector, count, offset,
                     iobref);
 
-	return 0;
+        return 0;
 }
 
 /*
@@ -1269,9 +1285,9 @@ ioc_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                   struct iatt *postbuf)
 {
 
-	STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, prebuf,
+        STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, prebuf,
                              postbuf);
-	return 0;
+        return 0;
 }
 
 
@@ -1288,13 +1304,13 @@ ioc_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
  */
 int32_t
 ioc_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                  int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
-                  struct iatt *postbuf)
+                   int32_t op_ret, int32_t op_errno, struct iatt *prebuf,
+                   struct iatt *postbuf)
 {
 
-	STACK_UNWIND_STRICT (ftruncate, frame, op_ret, op_errno, prebuf,
+        STACK_UNWIND_STRICT (ftruncate, frame, op_ret, op_errno, prebuf,
                              postbuf);
-	return 0;
+        return 0;
 }
 
 
@@ -1310,15 +1326,16 @@ ioc_ftruncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 int32_t
 ioc_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset)
 {
-	uint64_t ioc_inode = 0;
-	inode_ctx_get (loc->inode, this, &ioc_inode);
+        uint64_t ioc_inode = 0;
 
-	if (ioc_inode)
-		ioc_inode_flush ((ioc_inode_t *)(long)ioc_inode);
+        inode_ctx_get (loc->inode, this, &ioc_inode);
 
-	STACK_WIND (frame, ioc_truncate_cbk, FIRST_CHILD(this),
-		    FIRST_CHILD(this)->fops->truncate, loc, offset);
-	return 0;
+        if (ioc_inode)
+                ioc_inode_flush ((ioc_inode_t *)(long)ioc_inode);
+
+        STACK_WIND (frame, ioc_truncate_cbk, FIRST_CHILD(this),
+                    FIRST_CHILD(this)->fops->truncate, loc, offset);
+        return 0;
 }
 
 /*
@@ -1333,66 +1350,67 @@ ioc_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset)
 int32_t
 ioc_ftruncate (call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset)
 {
-	uint64_t ioc_inode = 0;
-	inode_ctx_get (fd->inode, this, &ioc_inode);
+        uint64_t ioc_inode = 0;
 
-	if (ioc_inode)
-		ioc_inode_flush ((ioc_inode_t *)(long)ioc_inode);
+        inode_ctx_get (fd->inode, this, &ioc_inode);
 
-	STACK_WIND (frame, ioc_ftruncate_cbk, FIRST_CHILD(this),
+        if (ioc_inode)
+                ioc_inode_flush ((ioc_inode_t *)(long)ioc_inode);
+
+        STACK_WIND (frame, ioc_ftruncate_cbk, FIRST_CHILD(this),
                     FIRST_CHILD(this)->fops->ftruncate, fd, offset);
-	return 0;
+        return 0;
 }
 
 int32_t
 ioc_lk_cbk (call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
-	    int32_t op_errno, struct gf_flock *lock)
+            int32_t op_errno, struct gf_flock *lock)
 {
-	STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, lock);
-	return 0;
+        STACK_UNWIND_STRICT (lk, frame, op_ret, op_errno, lock);
+        return 0;
 }
 
 int32_t
 ioc_lk (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
         struct gf_flock *lock)
 {
-	ioc_inode_t  *ioc_inode = NULL;
-	uint64_t     tmp_inode = 0;
-
-	inode_ctx_get (fd->inode, this, &tmp_inode);
-	ioc_inode = (ioc_inode_t *)(long)tmp_inode;
-	if (!ioc_inode) {
-		gf_log (this->name, GF_LOG_DEBUG,
-			"inode context is NULL: returning EBADFD");
-		STACK_UNWIND_STRICT (lk, frame, -1, EBADFD, NULL);
-		return 0;
-	}
-
-	ioc_inode_lock (ioc_inode);
-	{
-		gettimeofday (&ioc_inode->cache.tv, NULL);
-	}
-	ioc_inode_unlock (ioc_inode);
-
-	STACK_WIND (frame, ioc_lk_cbk, FIRST_CHILD (this),
-		    FIRST_CHILD (this)->fops->lk, fd, cmd, lock);
-
-	return 0;
+        ioc_inode_t *ioc_inode = NULL;
+        uint64_t     tmp_inode = 0;
+
+        inode_ctx_get (fd->inode, this, &tmp_inode);
+        ioc_inode = (ioc_inode_t *)(long)tmp_inode;
+        if (!ioc_inode) {
+                gf_log (this->name, GF_LOG_DEBUG,
+                        "inode context is NULL: returning EBADFD");
+                STACK_UNWIND_STRICT (lk, frame, -1, EBADFD, NULL);
+                return 0;
+        }
+
+        ioc_inode_lock (ioc_inode);
+        {
+                gettimeofday (&ioc_inode->cache.tv, NULL);
+        }
+        ioc_inode_unlock (ioc_inode);
+
+        STACK_WIND (frame, ioc_lk_cbk, FIRST_CHILD (this),
+                    FIRST_CHILD (this)->fops->lk, fd, cmd, lock);
+
+        return 0;
 }
 
 int32_t
 ioc_get_priority_list (const char *opt_str, struct list_head *first)
 {
-	int32_t              max_pri = 1;
-	char                *tmp_str = NULL;
-	char                *tmp_str1 = NULL;
-	char                *tmp_str2 = NULL;
-	char                *dup_str = NULL;
-	char                *stripe_str = NULL;
-	char                *pattern = NULL;
-	char                *priority = NULL;
-	char                *string = NULL;
-	struct ioc_priority *curr = NULL, *tmp = NULL;
+        int32_t              max_pri    = 1;
+        char                *tmp_str    = NULL;
+        char                *tmp_str1   = NULL;
+        char                *tmp_str2   = NULL;
+        char                *dup_str    = NULL;
+        char                *stripe_str = NULL;
+        char                *pattern    = NULL;
+        char                *priority   = NULL;
+        char                *string     = NULL;
+        struct ioc_priority *curr       = NULL, *tmp = NULL;
 
         string = gf_strdup (opt_str);
         if (string == NULL) {
@@ -1400,65 +1418,65 @@ ioc_get_priority_list (const char *opt_str, struct list_head *first)
                 goto out;
         }
 
-	/* Get the pattern for cache priority.
-	 * "option priority *.jpg:1,abc*:2" etc
-	 */
-	/* TODO: inode_lru in table is statically hard-coded to 5,
-	 * should be changed to run-time configuration
-	 */
-	stripe_str = strtok_r (string, ",", &tmp_str);
-	while (stripe_str) {
-		curr = GF_CALLOC (1, sizeof (struct ioc_priority),
+        /* Get the pattern for cache priority.
+         * "option priority *.jpg:1,abc*:2" etc
+         */
+        /* TODO: inode_lru in table is statically hard-coded to 5,
+         * should be changed to run-time configuration
+         */
+        stripe_str = strtok_r (string, ",", &tmp_str);
+        while (stripe_str) {
+                curr = GF_CALLOC (1, sizeof (struct ioc_priority),
                                   gf_ioc_mt_ioc_priority);
                 if (curr == NULL) {
                         max_pri = -1;
                         goto out;
                 }
 
-		list_add_tail (&curr->list, first);
+                list_add_tail (&curr->list, first);
 
-		dup_str = gf_strdup (stripe_str);
+                dup_str = gf_strdup (stripe_str);
                 if (dup_str == NULL) {
                         max_pri = -1;
                         goto out;
                 }
 
-		pattern = strtok_r (dup_str, ":", &tmp_str1);
-		if (!pattern) {
+                pattern = strtok_r (dup_str, ":", &tmp_str1);
+                if (!pattern) {
                         max_pri = -1;
                         goto out;
                 }
 
-		priority = strtok_r (NULL, ":", &tmp_str1);
-		if (!priority) {
+                priority = strtok_r (NULL, ":", &tmp_str1);
+                if (!priority) {
                         max_pri = -1;
                         goto out;
                 }
 
-		gf_log ("io-cache", GF_LOG_TRACE,
-			"ioc priority : pattern %s : priority %s",
-			pattern,
-			priority);
+                gf_log ("io-cache", GF_LOG_TRACE,
+                        "ioc priority : pattern %s : priority %s",
+                        pattern,
+                        priority);
 
-		curr->pattern = gf_strdup (pattern);
+                curr->pattern = gf_strdup (pattern);
                 if (curr->pattern == NULL) {
                         max_pri = -1;
                         goto out;
                 }
 
-		curr->priority = strtol (priority, &tmp_str2, 0);
-		if (tmp_str2 && (*tmp_str2)) {
+                curr->priority = strtol (priority, &tmp_str2, 0);
+                if (tmp_str2 && (*tmp_str2)) {
                         max_pri = -1;
                         goto out;
                 } else {
- 			max_pri = max (max_pri, curr->priority);
+                        max_pri = max (max_pri, curr->priority);
                 }
 
                 GF_FREE (dup_str);
                 dup_str = NULL;
 
-		stripe_str = strtok_r (NULL, ",", &tmp_str);
-	}
+                stripe_str = strtok_r (NULL, ",", &tmp_str);
+        }
 out:
         if (string != NULL) {
                 GF_FREE (string);
@@ -1476,7 +1494,7 @@ out:
                 }
         }
 
-	return max_pri;
+        return max_pri;
 }
 
 int32_t
@@ -1491,7 +1509,7 @@ mem_acct_init (xlator_t *this)
 
         if (ret != 0) {
                 gf_log (this->name, GF_LOG_ERROR, "Memory accounting init"
-                                "failed");
+                        "failed");
                 return ret;
         }
 
@@ -1501,27 +1519,27 @@ mem_acct_init (xlator_t *this)
 int
 validate_options (xlator_t *this, dict_t *options, char **op_errstr)
 {
-	ioc_table_t     *table = NULL;
-        int32_t          cache_timeout;
-        int64_t          min_file_size = 0;
-        int64_t          max_file_size = 0;
-        char            *tmp = NULL;
-        uint64_t         cache_size;
-        char            *cache_size_string = NULL;
-        int              ret = 0;
+        ioc_table_t *table             = NULL;
+        int32_t      cache_timeout     = 0;
+        int64_t      min_file_size     = 0;
+        int64_t      max_file_size     = 0;
+        char        *tmp               = NULL;
+        uint64_t     cache_size        = 0;
+        char        *cache_size_string = NULL;
+        int          ret               = 0;
 
         if (!this || !this->private)
                 goto out;
 
-	table = this->private;
+        table = this->private;
 
         if (dict_get (options, "cache-timeout")) {
                 cache_timeout = data_to_uint32 (dict_get (options,
-                                "cache-timeout"));
+                                                          "cache-timeout"));
                 if (cache_timeout < 0){
                         gf_log (this->name, GF_LOG_WARNING,
                                 "cache-timeout %d seconds invalid,"
-                                                " has to be  >=0", cache_timeout);
+                                " has to be  >=0", cache_timeout);
                         *op_errstr = gf_strdup ("Error, should be >= 0");
                         ret = -1;
                         goto out;
@@ -1531,7 +1549,7 @@ validate_options (xlator_t *this, dict_t *options, char **op_errstr)
                 if (cache_timeout > 60){
                         gf_log (this->name, GF_LOG_WARNING,
                                 "cache-timeout %d seconds invalid,"
-                                                " has to be  <=60", cache_timeout);
+                                " has to be  <=60", cache_timeout);
                         *op_errstr = gf_strdup ("Error, should be <= 60");
                         ret = -1;
                         goto out;
@@ -1546,65 +1564,65 @@ validate_options (xlator_t *this, dict_t *options, char **op_errstr)
 
         if (dict_get (options, "cache-size"))
                 cache_size_string = data_to_str (dict_get (options,
-                                "cache-size"));
+                                                           "cache-size"));
         if (cache_size_string) {
                 if (gf_string2bytesize (cache_size_string,
-                    &cache_size) != 0) {
-                            gf_log ("io-cache", GF_LOG_ERROR,
-                                    "invalid number format \"%s\" of "
-                                    "\"option cache-size\" Defaulting"
-                                    "to old value", cache_size_string);
-                            *op_errstr = gf_strdup ("Error, Invalid Format");
-                            ret = -1;
-                            goto out;
-                    }
-
-                    if (cache_size < ( 4 * GF_UNIT_MB)) {
-                            gf_log(this->name, GF_LOG_WARNING, "Reconfiguration"
-                                   "'option cache-size %s' failed , Max value"
-                                   "can be 4MiB, Defaulting to old value "
-                                   "(%"PRIu64")", cache_size_string,
-                                   cache_size);
-                            *op_errstr = gf_strdup ("Error, "
-                                                    "Cannot be less than 4MB");
-                            ret = -1;
-                            goto out;
-                    }
-
-                    if (cache_size > ( 6 * GF_UNIT_GB)) {
-                            gf_log(this->name, GF_LOG_WARNING, "Validation"
-                                   "'option cache-size %s' failed , Max value"
-                                   "can be 6GiB, Defaulting to old value "
-                                   "(%"PRIu64")", cache_size_string,
-                                   cache_size);
-                            *op_errstr = gf_strdup ("Error, Cannot be more "
-                                                    "than 6GB");
-                            ret = -1;
-                            goto out;
-                    }
-
-
-                    gf_log (this->name, GF_LOG_DEBUG, "Validated "
-                            " cache-size %"PRIu64"", cache_size);
+                                        &cache_size) != 0) {
+                        gf_log ("io-cache", GF_LOG_ERROR,
+                                "invalid number format \"%s\" of "
+                                "\"option cache-size\" Defaulting"
+                                "to old value", cache_size_string);
+                        *op_errstr = gf_strdup ("Error, Invalid Format");
+                        ret = -1;
+                        goto out;
+                }
+
+                if (cache_size < ( 4 * GF_UNIT_MB)) {
+                        gf_log(this->name, GF_LOG_WARNING, "Reconfiguration"
+                               "'option cache-size %s' failed , Max value"
+                               "can be 4MiB, Defaulting to old value "
+                               "(%"PRIu64")", cache_size_string,
+                               cache_size);
+                        *op_errstr = gf_strdup ("Error, "
+                                                "Cannot be less than 4MB");
+                        ret = -1;
+                        goto out;
+                }
+
+                if (cache_size > ( 6 * GF_UNIT_GB)) {
+                        gf_log(this->name, GF_LOG_WARNING, "Validation"
+                               "'option cache-size %s' failed , Max value"
+                               "can be 6GiB, Defaulting to old value "
+                               "(%"PRIu64")", cache_size_string,
+                               cache_size);
+                        *op_errstr = gf_strdup ("Error, Cannot be more "
+                                                "than 6GB");
+                        ret = -1;
+                        goto out;
+                }
+
+
+                gf_log (this->name, GF_LOG_DEBUG, "Validated "
+                        " cache-size %"PRIu64"", cache_size);
         }
 
         min_file_size = table->min_file_size;
         tmp = data_to_str (dict_get (options, "min-file-size"));
         if (tmp != NULL) {
                 if (gf_string2bytesize (tmp,
-                    (uint64_t *)&min_file_size)
+                                        (uint64_t *)&min_file_size)
                     != 0) {
                         gf_log ("io-cache", GF_LOG_WARNING,
                                 "invalid number format \"%s\" of "
-                                                "\"option min-file-size\"", tmp);
+                                "\"option min-file-size\"", tmp);
                         *op_errstr = gf_strdup ("Error, Invalid Format");
                         ret = -1;
                         goto out;
-                    }
+                }
 
-                    gf_log (this->name, GF_LOG_DEBUG,
-                            "Validated min-file-size %"PRIu64"",
-                            min_file_size);
+                gf_log (this->name, GF_LOG_DEBUG,
+                        "Validated min-file-size %"PRIu64"",
+                        min_file_size);
         }
 
 
@@ -1612,29 +1630,29 @@ validate_options (xlator_t *this, dict_t *options, char **op_errstr)
         tmp = data_to_str (dict_get (options, "max-file-size"));
         if (tmp != NULL) {
                 if (gf_string2bytesize (tmp,
-                    (uint64_t *)&max_file_size)
+                                        (uint64_t *)&max_file_size)
                     != 0) {
                         gf_log ("io-cache", GF_LOG_WARNING,
                                 "invalid number format \"%s\" of "
-                                                "\"option max-file-size\"", tmp);
+                                "\"option max-file-size\"", tmp);
                         *op_errstr = gf_strdup ("Error, Invalid Format");
                         ret = -1;
                         goto out;
-                    }
+                }
 
 
-                    gf_log (this->name, GF_LOG_WARNING,
-                            "Validated max-file-size %"PRIu64"",
-                            max_file_size);
+                gf_log (this->name, GF_LOG_WARNING,
+                        "Validated max-file-size %"PRIu64"",
+                        max_file_size);
         }
 
         if ((max_file_size >= 0) && (min_file_size > max_file_size)) {
                 gf_log ("io-cache", GF_LOG_WARNING, "minimum size (%"
-                                PRIu64") of a file that can be cached is "
-                                                "greater than maximum size (%"PRIu64"). ",
-                                                min_file_size, max_file_size);
+                        PRIu64") of a file that can be cached is "
+                        "greater than maximum size (%"PRIu64"). ",
+                        min_file_size, max_file_size);
                 *op_errstr = gf_strdup ("Error, min-file-size greater"
-                                " than max-file-size");
+                                        " than max-file-size");
                 ret = -1;
                 goto out;
         }
@@ -1646,173 +1664,175 @@ out:
 int
 reconfigure (xlator_t *this, dict_t *options)
 {
-	ioc_table_t     *table = NULL;
-	int32_t		 cache_timeout;
-	int64_t		 min_file_size = 0;
-	int64_t		 max_file_size = 0;
-	char		*tmp = NULL;
-	uint64_t         cache_size;
-	char		*cache_size_string = NULL;
-	int		 ret = 0;
+        ioc_table_t *table             = NULL;
+        int32_t      cache_timeout     = 0;
+        int64_t      min_file_size     = 0;
+        int64_t      max_file_size     = 0;
+        char	    *tmp               = NULL;
+        uint64_t     cache_size        = 0;
+        char	    *cache_size_string = NULL;
+        int          ret               = 0;
 
         if (!this || !this->private)
                 goto out;
 
-	table = this->private;
-
-	ioc_table_lock (table);
-	{
-		if (dict_get (options, "cache-timeout")) {
-			cache_timeout =
-				data_to_uint32 (dict_get (options,
-						    	  "cache-timeout"));
-			if (cache_timeout < 0){
-				gf_log (this->name, GF_LOG_WARNING,
-					"cache-timeout %d seconds invalid,"
-					" has to be  >=0", cache_timeout);
-				ret = -1;
-				goto out;
-			}
-
-
-			if (cache_timeout > 60){
-				gf_log (this->name, GF_LOG_WARNING,
-				"cache-timeout %d seconds invalid,"
-				" has to be  <=60", cache_timeout);
-				ret = -1;
-				goto out;
-			}
-
-			table->cache_timeout = cache_timeout;
-
-			gf_log (this->name, GF_LOG_DEBUG,
-				"Reconfiguring %d seconds to"
-				" revalidate cache", table->cache_timeout);
-		}
+        table = this->private;
+
+        ioc_table_lock (table);
+        {
+                if (dict_get (options, "cache-timeout")) {
+                        cache_timeout =
+                                data_to_uint32 (dict_get (options,
+                                                          "cache-timeout"));
+                        if (cache_timeout < 0){
+                                gf_log (this->name, GF_LOG_WARNING,
+                                        "cache-timeout %d seconds invalid,"
+                                        " has to be  >=0", cache_timeout);
+                                ret = -1;
+                                goto out;
+                        }
+
+
+                        if (cache_timeout > 60){
+                                gf_log (this->name, GF_LOG_WARNING,
+                                        "cache-timeout %d seconds invalid,"
+                                        " has to be  <=60", cache_timeout);
+                                ret = -1;
+                                goto out;
+                        }
+
+                        table->cache_timeout = cache_timeout;
+
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "Reconfiguring %d seconds to"
+                                " revalidate cache", table->cache_timeout);
+                }
                 else
                         table->cache_timeout = 1;
 
 
 
-		if (dict_get (options, "cache-size"))
-			cache_size_string = data_to_str (dict_get (options,
-							   "cache-size"));
-		if (cache_size_string) {
-			if (gf_string2bytesize (cache_size_string,
-						&cache_size) != 0) {
-				gf_log ("io-cache", GF_LOG_ERROR,
-					"invalid number format \"%s\" of "
-					"\"option cache-size\" Defaulting"
-					"to old value", cache_size_string);
-                        	ret = -1;
-				goto out;
-			}
+                if (dict_get (options, "cache-size"))
+                        cache_size_string
+                                = data_to_str (dict_get (options,
+                                                         "cache-size"));
+                if (cache_size_string) {
+                        if (gf_string2bytesize (cache_size_string,
+                                                &cache_size) != 0) {
+                                gf_log ("io-cache", GF_LOG_ERROR,
+                                        "invalid number format \"%s\" of "
+                                        "\"option cache-size\" Defaulting"
+                                        "to old value", cache_size_string);
+                                ret = -1;
+                                goto out;
+                        }
 
-			if (cache_size < (4 * GF_UNIT_MB)) {
-	                        gf_log(this->name, GF_LOG_ERROR,
+                        if (cache_size < (4 * GF_UNIT_MB)) {
+                                gf_log(this->name, GF_LOG_ERROR,
                                        "Reconfiguration"
                                        "'option cache-size %s' failed , "
                                        "Max value can be 4MiB, Defaulting to "
                                        "old value (%"PRIu64")",
                                        cache_size_string, table->cache_size);
-				ret = -1;
-				goto out;
-       		        }
+                                ret = -1;
+                                goto out;
+                        }
 
-			if (cache_size > (6 * GF_UNIT_GB)) {
-        	                gf_log (this->name, GF_LOG_ERROR,
+                        if (cache_size > (6 * GF_UNIT_GB)) {
+                                gf_log (this->name, GF_LOG_ERROR,
                                         "Reconfiguration"
                                         "'option cache-size %s' failed , "
                                         "Max value can be 6GiB, Defaulting to "
                                         "old value (%"PRIu64")",
                                         cache_size_string, table->cache_size);
-				ret = -1;
-				goto out;
-                	}
+                                ret = -1;
+                                goto out;
+                        }
 
 
-			gf_log (this->name, GF_LOG_DEBUG, "Reconfiguring "
-				" cache-size %"PRIu64"", cache_size);
-			table->cache_size = cache_size;
-		}
+                        gf_log (this->name, GF_LOG_DEBUG, "Reconfiguring "
+                                " cache-size %"PRIu64"", cache_size);
+                        table->cache_size = cache_size;
+                }
                 else
                         table->cache_size = IOC_CACHE_SIZE;
 
 
-		if (dict_get (options, "priority")) {
-			char *option_list = data_to_str (dict_get (options,
-							   "priority"));
-			gf_log (this->name, GF_LOG_TRACE,
-				"option path %s", option_list);
-			/* parse the list of pattern:priority */
-			table->max_pri = ioc_get_priority_list (option_list,
-								&table->priority_list);
-
-			if (table->max_pri == -1) {
-        	                ret = -1;
-				goto out;
-                	}
-			table->max_pri ++;
-		}
-
-		min_file_size = table->min_file_size;
-		tmp = data_to_str (dict_get (options, "min-file-size"));
-	        if (tmp != NULL) {
-			if (gf_string2bytesize (tmp,
-                	                        (uint64_t *)&min_file_size)
-						!= 0) {
-				gf_log ("io-cache", GF_LOG_ERROR,
-					"invalid number format \"%s\" of "
-					"\"option min-file-size\"", tmp);
-                        	ret = -1;
-				goto out;
-			}
-
-			gf_log (this->name, GF_LOG_DEBUG,
-				"Reconfiguring min-file-size %"PRIu64"",
-				table->min_file_size);
-		}
-
-		max_file_size = table->max_file_size;
-        	tmp = data_to_str (dict_get (options, "max-file-size"));
-       		if (tmp != NULL) {
-                	if (gf_string2bytesize (tmp,
-                        	                (uint64_t *)&max_file_size)
-						!= 0) {
-				gf_log ("io-cache", GF_LOG_ERROR,
-                                	"invalid number format \"%s\" of "
-                                	"\"option max-file-size\"", tmp);
-                        	ret = -1;
-                		goto out;
-			}
-
-
-                	gf_log (this->name, GF_LOG_DEBUG,
-                        	"Reconfiguring max-file-size %"PRIu64"",
-			 	table->max_file_size);
-        	}
-
-        	if ((max_file_size >= 0) && (min_file_size > max_file_size)) {
+                if (dict_get (options, "priority")) {
+                        char *option_list = data_to_str (dict_get (options,
+                                                                   "priority"));
+                        gf_log (this->name, GF_LOG_TRACE,
+                                "option path %s", option_list);
+                        /* parse the list of pattern:priority */
+                        table->max_pri
+                                = ioc_get_priority_list (option_list,
+                                                         &table->priority_list);
+
+                        if (table->max_pri == -1) {
+                                ret = -1;
+                                goto out;
+                        }
+                        table->max_pri ++;
+                }
+
+                min_file_size = table->min_file_size;
+                tmp = data_to_str (dict_get (options, "min-file-size"));
+                if (tmp != NULL) {
+                        if (gf_string2bytesize (tmp,
+                                                (uint64_t *)&min_file_size)
+                            != 0) {
+                                gf_log ("io-cache", GF_LOG_ERROR,
+                                        "invalid number format \"%s\" of "
+                                        "\"option min-file-size\"", tmp);
+                                ret = -1;
+                                goto out;
+                        }
+
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "Reconfiguring min-file-size %"PRIu64"",
+                                table->min_file_size);
+                }
+
+                max_file_size = table->max_file_size;
+                tmp = data_to_str (dict_get (options, "max-file-size"));
+                if (tmp != NULL) {
+                        if (gf_string2bytesize (tmp,
+                                                (uint64_t *)&max_file_size)
+                            != 0) {
+                                gf_log ("io-cache", GF_LOG_ERROR,
+                                        "invalid number format \"%s\" of "
+                                        "\"option max-file-size\"", tmp);
+                                ret = -1;
+                                goto out;
+                        }
+
+
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "Reconfiguring max-file-size %"PRIu64"",
+                                table->max_file_size);
+                }
+
+                if ((max_file_size >= 0) && (min_file_size > max_file_size)) {
                         gf_log ("io-cache", GF_LOG_ERROR, "minimum size (%"
                                 PRIu64") of a file that can be cached is "
                                 "greater than maximum size (%"PRIu64"). "
-				"Hence Defaulting to old value",
+                                "Hence Defaulting to old value",
                                 table->min_file_size, table->max_file_size);
                         ret = -1;
-			goto out;
-		}
+                        goto out;
+                }
 
-		table->min_file_size = min_file_size;
-		table->max_file_size = max_file_size;
+                table->min_file_size = min_file_size;
+                table->max_file_size = max_file_size;
                 if (!data_to_str (dict_get (options, "min-file-size")))
-                    table->min_file_size = 0;
+                        table->min_file_size = 0;
                 if (data_to_str (dict_get (options, "max-file-size")))
-                    table->max_file_size = 0;
-	}
+                        table->max_file_size = 0;
+        }
 
-	ioc_table_unlock (table);
+        ioc_table_unlock (table);
 out:
-	return ret;
+        return ret;
 
 }
 
@@ -1824,118 +1844,119 @@ out:
 int32_t
 init (xlator_t *this)
 {
-	ioc_table_t     *table = NULL;
-	dict_t          *xl_options = this->options;
-	uint32_t         index = 0;
-	char            *cache_size_string = NULL, *tmp = NULL;
-        int32_t          ret = -1;
-        glusterfs_ctx_t *ctx = NULL;
-        char            *def_val = NULL;
-
-	if (!this->children || this->children->next) {
-		gf_log (this->name, GF_LOG_ERROR,
-			"FATAL: io-cache not configured with exactly "
-			"one child");
+        ioc_table_t     *table             = NULL;
+        dict_t          *xl_options        = NULL;
+        uint32_t         index             = 0;
+        char            *cache_size_string = NULL, *tmp = NULL;
+        int32_t          ret               = -1;
+        glusterfs_ctx_t *ctx               = NULL;
+        char            *def_val           = NULL;
+
+        xl_options = this->options;
+        if (!this->children || this->children->next) {
+                gf_log (this->name, GF_LOG_ERROR,
+                        "FATAL: io-cache not configured with exactly "
+                        "one child");
                 goto out;
-	}
+        }
 
-	if (!this->parents) {
-		gf_log (this->name, GF_LOG_WARNING,
-			"dangling volume. check volfile ");
-	}
+        if (!this->parents) {
+                gf_log (this->name, GF_LOG_WARNING,
+                        "dangling volume. check volfile ");
+        }
 
-	table = (void *) GF_CALLOC (1, sizeof (*table), gf_ioc_mt_ioc_table_t);
+        table = (void *) GF_CALLOC (1, sizeof (*table), gf_ioc_mt_ioc_table_t);
         if (table == NULL) {
                 gf_log (this->name, GF_LOG_ERROR, "out of memory");
                 goto out;
         }
 
-	table->xl = this;
-	table->page_size = this->ctx->page_size;
+        table->xl = this;
+        table->page_size = this->ctx->page_size;
         if (xlator_get_volopt_info (&this->volume_options, "cache-size",
-                                     &def_val, NULL)) {
+                                    &def_val, NULL)) {
                 gf_log (this->name, GF_LOG_ERROR, "Default value of cache-size "
-                         "not found");
+                        "not found");
                 ret = -1;
                 goto out;
         } else {
                 if (gf_string2bytesize (def_val, &table->cache_size)) {
                         gf_log (this->name, GF_LOG_ERROR, "Default value of "
-                                 "cache-size corrupt");
+                                "cache-size corrupt");
                         ret = -1;
                         goto out;
                 }
         }
 
         if (dict_get (xl_options, "cache-size"))
-		cache_size_string = data_to_str (dict_get (xl_options,
-							   "cache-size"));
-	if (cache_size_string) {
-		if (gf_string2bytesize (cache_size_string,
-					&table->cache_size) != 0) {
-			gf_log ("io-cache", GF_LOG_ERROR,
-				"invalid number format \"%s\" of "
-				"\"option cache-size\"",
-				cache_size_string);
+                cache_size_string = data_to_str (dict_get (xl_options,
+                                                           "cache-size"));
+        if (cache_size_string) {
+                if (gf_string2bytesize (cache_size_string,
+                                        &table->cache_size) != 0) {
+                        gf_log ("io-cache", GF_LOG_ERROR,
+                                "invalid number format \"%s\" of "
+                                "\"option cache-size\"",
+                                cache_size_string);
                         goto out;
-		}
+                }
 
-		gf_log (this->name, GF_LOG_TRACE,
-			"using cache-size %"PRIu64"", table->cache_size);
-	}
+                gf_log (this->name, GF_LOG_TRACE,
+                        "using cache-size %"PRIu64"", table->cache_size);
+        }
 
         if (xlator_get_volopt_info (&this->volume_options, "cache-timeout",
                                     &def_val, NULL)) {
                 gf_log (this->name, GF_LOG_ERROR, "Default value of "
-                         "cache-timeout not found");
+                        "cache-timeout not found");
                 ret = -1;
                 goto out;
         } else {
                 if (gf_string2int32 (def_val, &table->cache_timeout)) {
                         gf_log (this->name, GF_LOG_ERROR, "Default value of "
-                                 "cache-timeout corrupt");
+                                "cache-timeout corrupt");
                         ret = -1;
                         goto out;
                 }
         }
 
         if (dict_get (xl_options, "cache-timeout")){
-		table->cache_timeout =
-			data_to_uint32 (dict_get (xl_options,
-						  "cache-timeout"));
-		gf_log (this->name, GF_LOG_TRACE,
-			"Using %d seconds to revalidate cache",
-			table->cache_timeout);
-	}
-
-	INIT_LIST_HEAD (&table->priority_list);
-	table->max_pri = 1;
+                table->cache_timeout =
+                        data_to_uint32 (dict_get (xl_options,
+                                                  "cache-timeout"));
+                gf_log (this->name, GF_LOG_TRACE,
+                        "Using %d seconds to revalidate cache",
+                        table->cache_timeout);
+        }
+
+        INIT_LIST_HEAD (&table->priority_list);
+        table->max_pri = 1;
         if (dict_get (xl_options, "priority")) {
-		char *option_list = data_to_str (dict_get (xl_options,
-							   "priority"));
-		gf_log (this->name, GF_LOG_TRACE,
-			"option path %s", option_list);
-		/* parse the list of pattern:priority */
-		table->max_pri = ioc_get_priority_list (option_list,
-							&table->priority_list);
-
-		if (table->max_pri == -1) {
+                char *option_list = data_to_str (dict_get (xl_options,
+                                                           "priority"));
+                gf_log (this->name, GF_LOG_TRACE,
+                        "option path %s", option_list);
+                /* parse the list of pattern:priority */
+                table->max_pri = ioc_get_priority_list (option_list,
+                                                        &table->priority_list);
+
+                if (table->max_pri == -1) {
                         goto out;
                 }
-	}
-	table->max_pri ++;
+        }
+        table->max_pri ++;
 
         if (xlator_get_volopt_info (&this->volume_options, "min-file-size",
                                     &def_val, NULL)) {
                 gf_log (this->name, GF_LOG_ERROR, "Default value of "
-                         "min-file-size not found");
+                        "min-file-size not found");
                 ret = -1;
                 goto out;
         } else {
                 if (gf_string2bytesize (def_val,
                                         (uint64_t *) &table->min_file_size)) {
                         gf_log (this->name, GF_LOG_ERROR, "Default value of "
-                                 "min-file-size corrupt");
+                                "min-file-size corrupt");
                         ret = -1;
                         goto out;
                 }
@@ -1945,29 +1966,30 @@ init (xlator_t *this)
         if (dict_get (xl_options, "min-file-size"))
                 tmp = data_to_str (dict_get (xl_options, "min-file-size"));
         if (tmp != NULL) {
-		if (gf_string2bytesize (tmp,
-                                        (uint64_t *)&table->min_file_size) != 0) {
-			gf_log ("io-cache", GF_LOG_ERROR,
-				"invalid number format \"%s\" of "
-				"\"option min-file-size\"", tmp);
+                if (gf_string2bytesize (tmp,
+                                        (uint64_t *)&table->min_file_size)
+                    != 0) {
+                        gf_log ("io-cache", GF_LOG_ERROR,
+                                "invalid number format \"%s\" of "
+                                "\"option min-file-size\"", tmp);
                         goto out;
-		}
+                }
 
-		gf_log (this->name, GF_LOG_TRACE,
-			"using min-file-size %"PRIu64"", table->min_file_size);
+                gf_log (this->name, GF_LOG_TRACE,
+                        "using min-file-size %"PRIu64"", table->min_file_size);
         }
 
         if (xlator_get_volopt_info (&this->volume_options, "max-file-size",
                                     &def_val, NULL)) {
                 gf_log (this->name, GF_LOG_ERROR, "Default value of "
-                         "max-file-size not found");
+                        "max-file-size not found");
                 ret = -1;
                 goto out;
         } else {
                 if (gf_string2bytesize (def_val,
                                         (uint64_t *) &table->max_file_size)) {
                         gf_log (this->name, GF_LOG_ERROR, "Default value of "
-                                 "max-file-size corrupt");
+                                "max-file-size corrupt");
                         ret = -1;
                         goto out;
                 }
@@ -1978,7 +2000,8 @@ init (xlator_t *this)
                 tmp = data_to_str (dict_get (xl_options, "max-file-size"));
         if (tmp != NULL) {
                 if (gf_string2bytesize (tmp,
-                                        (uint64_t *)&table->max_file_size) != 0) {
+                                        (uint64_t *)&table->max_file_size)
+                    != 0) {
                         gf_log ("io-cache", GF_LOG_ERROR,
                                 "invalid number format \"%s\" of "
                                 "\"option max-file-size\"", tmp);
@@ -1988,29 +2011,29 @@ init (xlator_t *this)
                 gf_log (this->name, GF_LOG_TRACE,
                         "using max-file-size %"PRIu64"", table->max_file_size);
         }
-	INIT_LIST_HEAD (&table->inodes);
+        INIT_LIST_HEAD (&table->inodes);
 
         if ((table->max_file_size >= 0)
             && (table->min_file_size > table->max_file_size)) {
-                        gf_log ("io-cache", GF_LOG_ERROR, "minimum size (%"
-                                PRIu64") of a file that can be cached is "
-                                "greater than maximum size (%"PRIu64")",
-                                table->min_file_size, table->max_file_size);
-                        goto out;
+                gf_log ("io-cache", GF_LOG_ERROR, "minimum size (%"
+                        PRIu64") of a file that can be cached is "
+                        "greater than maximum size (%"PRIu64")",
+                        table->min_file_size, table->max_file_size);
+                goto out;
         }
 
-	table->inode_lru = GF_CALLOC (table->max_pri,
+        table->inode_lru = GF_CALLOC (table->max_pri,
                                       sizeof (struct list_head),
                                       gf_ioc_mt_list_head);
         if (table->inode_lru == NULL) {
                 goto out;
         }
 
-	for (index = 0; index < (table->max_pri); index++)
-		INIT_LIST_HEAD (&table->inode_lru[index]);
+        for (index = 0; index < (table->max_pri); index++)
+                INIT_LIST_HEAD (&table->inode_lru[index]);
 
-	pthread_mutex_init (&table->table_lock, NULL);
-	this->private = table;
+        pthread_mutex_init (&table->table_lock, NULL);
+        this->private = table;
         ret = 0;
 
         ctx = this->ctx;
@@ -2024,15 +2047,15 @@ out:
                 }
         }
 
-	return ret;
+        return ret;
 }
 
 int
 ioc_priv_dump (xlator_t *this)
 {
-        ioc_table_t     *priv = NULL;
-        char            key_prefix[GF_DUMP_MAX_BUF_LEN];
-        char            key[GF_DUMP_MAX_BUF_LEN];
+        ioc_table_t *priv                            = NULL;
+        char         key_prefix[GF_DUMP_MAX_BUF_LEN] = {0, };
+        char         key[GF_DUMP_MAX_BUF_LEN]        = {0, };
 
         if (!this || !this->private)
                 goto out;
@@ -2064,7 +2087,7 @@ out:
 void
 fini (xlator_t *this)
 {
-	ioc_table_t *table = NULL;
+        ioc_table_t *table = NULL;
 
         table = this->private;
 
@@ -2076,22 +2099,22 @@ fini (xlator_t *this)
                 table->mem_pool = NULL;
         }
 
-	pthread_mutex_destroy (&table->table_lock);
-	GF_FREE (table);
+        pthread_mutex_destroy (&table->table_lock);
+        GF_FREE (table);
 
-	this->private = NULL;
-	return;
+        this->private = NULL;
+        return;
 }
 
 struct xlator_fops fops = {
-	.open        = ioc_open,
-	.create      = ioc_create,
-	.readv       = ioc_readv,
-	.writev      = ioc_writev,
-	.truncate    = ioc_truncate,
-	.ftruncate   = ioc_ftruncate,
-	.lookup      = ioc_lookup,
-	.lk          = ioc_lk,
+        .open        = ioc_open,
+        .create      = ioc_create,
+        .readv       = ioc_readv,
+        .writev      = ioc_writev,
+        .truncate    = ioc_truncate,
+        .ftruncate   = ioc_ftruncate,
+        .lookup      = ioc_lookup,
+        .lk          = ioc_lk,
         .setattr     = ioc_setattr,
         .mknod       = ioc_mknod
 };
@@ -2102,46 +2125,46 @@ struct xlator_dumpops dumpops = {
 };
 
 struct xlator_cbks cbks = {
-	.forget      = ioc_forget,
-  	.release     = ioc_release
+        .forget      = ioc_forget,
+        .release     = ioc_release
 };
 
 struct volume_options options[] = {
-	{ .key  = {"priority"},
-	  .type = GF_OPTION_TYPE_ANY,
+        { .key  = {"priority"},
+          .type = GF_OPTION_TYPE_ANY,
           .default_value = "",
           .description = "Assigns priority to filenames with specific "
-                         "patterns so that when a page needs to be ejected "
-                         "out of the cache, the page of a file whose "
-                         "priority is the lowest will be ejected earlier"
-	},
-	{ .key  = {"cache-timeout", "force-revalidate-timeout"},
-	  .type = GF_OPTION_TYPE_INT,
-	  .min  = 0,
-	  .max  = 60,
+          "patterns so that when a page needs to be ejected "
+          "out of the cache, the page of a file whose "
+          "priority is the lowest will be ejected earlier"
+        },
+        { .key  = {"cache-timeout", "force-revalidate-timeout"},
+          .type = GF_OPTION_TYPE_INT,
+          .min  = 0,
+          .max  = 60,
           .default_value = "1",
           .description = "The cached data for a file will be retained till "
-                         "'cache-refresh-timeout' seconds, after which data "
-                         "re-validation is performed."
-	},
-	{ .key  = {"cache-size"},
-	  .type = GF_OPTION_TYPE_SIZET,
-	  .min  = 4 * GF_UNIT_MB,
+          "'cache-refresh-timeout' seconds, after which data "
+          "re-validation is performed."
+        },
+        { .key  = {"cache-size"},
+          .type = GF_OPTION_TYPE_SIZET,
+          .min  = 4 * GF_UNIT_MB,
           .max  = 6 * GF_UNIT_GB,
           .default_value = "32MB",
           .description = "Size of the read cache."
-	},
+        },
         { .key  = {"min-file-size"},
           .type = GF_OPTION_TYPE_SIZET,
           .default_value = "0",
           .description = "Minimum file size which would be cached by the "
-                         "io-cache translator."
+          "io-cache translator."
         },
         { .key  = {"max-file-size"},
           .type = GF_OPTION_TYPE_SIZET,
           .default_value = "0",
           .description = "Maximum file size which would be cached by the "
-                         "io-cache translator."
+          "io-cache translator."
         },
-	{ .key = {NULL} },
+        { .key = {NULL} },
 };
diff --git a/xlators/performance/io-cache/src/io-cache.h b/xlators/performance/io-cache/src/io-cache.h
index e9cb56e0a..a69b78778 100644
--- a/xlators/performance/io-cache/src/io-cache.h
+++ b/xlators/performance/io-cache/src/io-cache.h
@@ -49,132 +49,132 @@ struct ioc_page;
 struct ioc_inode;
 
 struct ioc_priority {
-	struct list_head list;
-	char             *pattern;
-	uint32_t         priority;
+        struct list_head list;
+        char             *pattern;
+        uint32_t         priority;
 };
 
 /*
- * ioc_waitq - this structure is used to represents the waiting 
+ * ioc_waitq - this structure is used to represents the waiting
  *             frames on a page
  *
  * @next: pointer to next object in waitq
  * @data: pointer to the frame which is waiting
  */
 struct ioc_waitq {
-	struct ioc_waitq *next;
-	void             *data;
-	off_t            pending_offset;
-	size_t           pending_size;
+        struct ioc_waitq *next;
+        void             *data;
+        off_t            pending_offset;
+        size_t           pending_size;
 };
 
 /*
- * ioc_fill - 
+ * ioc_fill -
  *
  */
 struct ioc_fill {
-	struct list_head list;  /* list of ioc_fill structures of a frame */
-	off_t            offset;          
-	size_t           size;           
-	struct iovec     *vector;  
-	int32_t          count;
-	struct iobref    *iobref;
+        struct list_head list;  /* list of ioc_fill structures of a frame */
+        off_t            offset;
+        size_t           size;
+        struct iovec     *vector;
+        int32_t          count;
+        struct iobref    *iobref;
 };
 
 struct ioc_local {
-	mode_t           mode;
-	int32_t          flags;
+        mode_t           mode;
+        int32_t          flags;
         int32_t          wbflags;
-	loc_t            file_loc;
-	off_t            offset;
-	size_t           size;
-	int32_t          op_ret;
-	int32_t          op_errno;
-	struct list_head fill_list;      /* list of ioc_fill structures */
-	off_t            pending_offset; /* 
+        loc_t            file_loc;
+        off_t            offset;
+        size_t           size;
+        int32_t          op_ret;
+        int32_t          op_errno;
+        struct list_head fill_list;      /* list of ioc_fill structures */
+        off_t            pending_offset; /*
                                           * offset from this frame should
                                           * continue
                                           */
-	size_t           pending_size;   /* 
+        size_t           pending_size;   /*
                                           * size of data this frame is waiting
                                           * on
                                           */
-	struct ioc_inode *inode;
-	int32_t          wait_count;
-	pthread_mutex_t  local_lock;
-	struct ioc_waitq *waitq;
-	void             *stub;
-	fd_t             *fd;
-	int32_t          need_xattr;
-	dict_t           *xattr_req;
+        struct ioc_inode *inode;
+        int32_t          wait_count;
+        pthread_mutex_t  local_lock;
+        struct ioc_waitq *waitq;
+        void             *stub;
+        fd_t             *fd;
+        int32_t          need_xattr;
+        dict_t           *xattr_req;
 };
 
 /*
- * ioc_page - structure to store page of data from file 
+ * ioc_page - structure to store page of data from file
  *
  */
 struct ioc_page {
-	struct list_head    page_lru;
-	struct ioc_inode    *inode;   /* inode this page belongs to */
-	struct ioc_priority *priority;
-	char                dirty;
-	char                ready;
-	struct iovec        *vector;
-	int32_t             count;
-	off_t               offset;
-	size_t              size;
-	struct ioc_waitq    *waitq;
-	struct iobref       *iobref;
-	pthread_mutex_t     page_lock;
+        struct list_head    page_lru;
+        struct ioc_inode    *inode;   /* inode this page belongs to */
+        struct ioc_priority *priority;
+        char                dirty;
+        char                ready;
+        struct iovec        *vector;
+        int32_t             count;
+        off_t               offset;
+        size_t              size;
+        struct ioc_waitq    *waitq;
+        struct iobref       *iobref;
+        pthread_mutex_t     page_lock;
 };
 
 struct ioc_cache {
         rbthash_table_t  *page_table;
         struct list_head  page_lru;
-	time_t            mtime;       /*
+        time_t            mtime;       /*
                                         * seconds component of file mtime
                                         */
         time_t            mtime_nsec;  /*
                                         * nanosecond component of file mtime
                                         */
-	struct timeval    tv;          /*
+        struct timeval    tv;          /*
                                         * time-stamp at last re-validate
                                         */
 };
 
 struct ioc_inode {
-	struct ioc_table      *table;
+        struct ioc_table      *table;
         off_t                  ia_size;
-        struct ioc_cache       cache;        
-	struct list_head       inode_list; /*
+        struct ioc_cache       cache;
+        struct list_head       inode_list; /*
                                             * list of inodes, maintained by
                                             * io-cache translator
                                             */
-	struct list_head       inode_lru;
-	struct ioc_waitq      *waitq;
-	pthread_mutex_t        inode_lock;
-	uint32_t               weight;      /*
+        struct list_head       inode_lru;
+        struct ioc_waitq      *waitq;
+        pthread_mutex_t        inode_lock;
+        uint32_t               weight;      /*
                                              * weight of the inode, increases
                                              * on each read
                                              */
 };
 
 struct ioc_table {
-	uint64_t         page_size;
-	uint64_t         cache_size;
-	uint64_t         cache_used;
+        uint64_t         page_size;
+        uint64_t         cache_size;
+        uint64_t         cache_used;
         int64_t          min_file_size;
         int64_t          max_file_size;
-	struct list_head inodes; /* list of inodes cached */
-	struct list_head active; 
-	struct list_head *inode_lru;
-	struct list_head priority_list;
-	int32_t          readv_count;
-	pthread_mutex_t  table_lock;
-	xlator_t         *xl;
-	uint32_t         inode_count;
-	int32_t          cache_timeout;
-	int32_t          max_pri;
+        struct list_head inodes; /* list of inodes cached */
+        struct list_head active;
+        struct list_head *inode_lru;
+        struct list_head priority_list;
+        int32_t          readv_count;
+        pthread_mutex_t  table_lock;
+        xlator_t         *xl;
+        uint32_t         inode_count;
+        int32_t          cache_timeout;
+        int32_t          max_pri;
         struct mem_pool  *mem_pool;
 };
 
@@ -191,36 +191,33 @@ str_to_ptr (char *string);
 char *
 ptr_to_str (void *ptr);
 
-int32_t 
+int32_t
 ioc_readv_disabled_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                         int32_t op_ret,	int32_t op_errno, struct iovec *vector,
-			int32_t count, struct iatt *stbuf,
+                        int32_t count, struct iatt *stbuf,
                         struct iobref *iobref);
 
 ioc_page_t *
-ioc_page_get (ioc_inode_t *ioc_inode, off_t offset);
+__ioc_page_get (ioc_inode_t *ioc_inode, off_t offset);
 
 ioc_page_t *
-ioc_page_create (ioc_inode_t *ioc_inode, off_t offset);
+__ioc_page_create (ioc_inode_t *ioc_inode, off_t offset);
 
 void
 ioc_page_fault (ioc_inode_t *ioc_inode,	call_frame_t *frame, fd_t *fd,
-		off_t offset);
+                off_t offset);
 void
-ioc_wait_on_page (ioc_page_t *page, call_frame_t *frame, off_t offset,
-		  size_t size);
+__ioc_wait_on_page (ioc_page_t *page, call_frame_t *frame, off_t offset,
+                    size_t size);
 
 ioc_waitq_t *
-ioc_page_wakeup (ioc_page_t *page);
+__ioc_page_wakeup (ioc_page_t *page);
 
 void
 ioc_page_flush (ioc_page_t *page);
 
 ioc_waitq_t *
-ioc_page_error (ioc_page_t *page, int32_t op_ret, int32_t op_errno);
-
-void
-ioc_page_purge (ioc_page_t *page);
+__ioc_page_error (ioc_page_t *page, int32_t op_ret, int32_t op_errno);
 
 void
 ioc_frame_return (call_frame_t *frame);
@@ -230,95 +227,95 @@ ioc_waitq_return (ioc_waitq_t *waitq);
 
 int32_t
 ioc_frame_fill (ioc_page_t *page, call_frame_t *frame, off_t offset,
-		size_t size);
+                size_t size);
 
 #define ioc_inode_lock(ioc_inode)					\
-	do {								\
-		gf_log (ioc_inode->table->xl->name, GF_LOG_TRACE,	\
-			"locked inode(%p)", ioc_inode);			\
-		pthread_mutex_lock (&ioc_inode->inode_lock);		\
-	} while (0)
+        do {								\
+                gf_log (ioc_inode->table->xl->name, GF_LOG_TRACE,	\
+                        "locked inode(%p)", ioc_inode);			\
+                pthread_mutex_lock (&ioc_inode->inode_lock);		\
+        } while (0)
 
 
 #define ioc_inode_unlock(ioc_inode)					\
-	do {								\
-		gf_log (ioc_inode->table->xl->name, GF_LOG_TRACE,	\
-			"unlocked inode(%p)", ioc_inode);		\
-		pthread_mutex_unlock (&ioc_inode->inode_lock);		\
-	} while (0)
+        do {								\
+                gf_log (ioc_inode->table->xl->name, GF_LOG_TRACE,	\
+                        "unlocked inode(%p)", ioc_inode);		\
+                pthread_mutex_unlock (&ioc_inode->inode_lock);		\
+        } while (0)
 
 
 #define ioc_table_lock(table)					\
-	do {							\
-		gf_log (table->xl->name, GF_LOG_TRACE,		\
-			"locked table(%p)", table);		\
-		pthread_mutex_lock (&table->table_lock);	\
-	} while (0)
+        do {							\
+                gf_log (table->xl->name, GF_LOG_TRACE,		\
+                        "locked table(%p)", table);		\
+                pthread_mutex_lock (&table->table_lock);	\
+        } while (0)
 
 
 #define ioc_table_unlock(table)					\
-	do {							\
-		gf_log (table->xl->name, GF_LOG_TRACE,		\
-			"unlocked table(%p)", table);		\
-		pthread_mutex_unlock (&table->table_lock);	\
-	} while (0)
+        do {							\
+                gf_log (table->xl->name, GF_LOG_TRACE,		\
+                        "unlocked table(%p)", table);		\
+                pthread_mutex_unlock (&table->table_lock);	\
+        } while (0)
 
 
 #define ioc_local_lock(local)						\
-	do {								\
-		gf_log (local->inode->table->xl->name, GF_LOG_TRACE,	\
-			"locked local(%p)", local);			\
-		pthread_mutex_lock (&local->local_lock);		\
-	} while (0)
+        do {								\
+                gf_log (local->inode->table->xl->name, GF_LOG_TRACE,	\
+                        "locked local(%p)", local);			\
+                pthread_mutex_lock (&local->local_lock);		\
+        } while (0)
 
 
 #define ioc_local_unlock(local)						\
-	do {								\
-		gf_log (local->inode->table->xl->name, GF_LOG_TRACE,	\
-			"unlocked local(%p)", local);			\
-		pthread_mutex_unlock (&local->local_lock);		\
-	} while (0)
+        do {								\
+                gf_log (local->inode->table->xl->name, GF_LOG_TRACE,	\
+                        "unlocked local(%p)", local);			\
+                pthread_mutex_unlock (&local->local_lock);		\
+        } while (0)
 
 
 #define ioc_page_lock(page)						\
-	do {								\
-		gf_log (page->inode->table->xl->name, GF_LOG_TRACE,	\
-			"locked page(%p)", page);			\
-		pthread_mutex_lock (&page->page_lock);			\
-	} while (0)
+        do {								\
+                gf_log (page->inode->table->xl->name, GF_LOG_TRACE,	\
+                        "locked page(%p)", page);			\
+                pthread_mutex_lock (&page->page_lock);			\
+        } while (0)
 
 
 #define ioc_page_unlock(page)						\
-	do {								\
-		gf_log (page->inode->table->xl->name, GF_LOG_TRACE,	\
-			"unlocked page(%p)", page);			\
-		pthread_mutex_unlock (&page->page_lock);		\
-	} while (0)
+        do {								\
+                gf_log (page->inode->table->xl->name, GF_LOG_TRACE,	\
+                        "unlocked page(%p)", page);			\
+                pthread_mutex_unlock (&page->page_lock);		\
+        } while (0)
 
 
 static inline uint64_t
 time_elapsed (struct timeval *now,
-	      struct timeval *then)
+              struct timeval *then)
 {
-	uint64_t sec = now->tv_sec - then->tv_sec;
+        uint64_t sec = now->tv_sec - then->tv_sec;
 
-	if (sec)
-		return sec;
-  
-	return 0;
+        if (sec)
+                return sec;
+
+        return 0;
 }
 
 ioc_inode_t *
 ioc_inode_search (ioc_table_t *table, inode_t *inode);
 
-void 
+void
 ioc_inode_destroy (ioc_inode_t *ioc_inode);
 
 ioc_inode_t *
 ioc_inode_update (ioc_table_t *table, inode_t *inode, uint32_t weight);
 
-int64_t 
-ioc_page_destroy (ioc_page_t *page);
+int64_t
+__ioc_page_destroy (ioc_page_t *page);
 
 int64_t
 __ioc_inode_flush (ioc_inode_t *ioc_inode);
diff --git a/xlators/performance/io-cache/src/ioc-inode.c b/xlators/performance/io-cache/src/ioc-inode.c
index bbf46d935..deb79743a 100644
--- a/xlators/performance/io-cache/src/ioc-inode.c
+++ b/xlators/performance/io-cache/src/ioc-inode.c
@@ -35,10 +35,10 @@ extern int ioc_log2_page_size;
 void *
 str_to_ptr (char *string)
 {
-	void *ptr = NULL;
+        void *ptr = NULL;
 
         ptr = (void *)strtoul (string, NULL, 16);
-	return ptr;
+        return ptr;
 }
 
 
@@ -51,102 +51,106 @@ char *
 ptr_to_str (void *ptr)
 {
         int   ret = 0;
-	char *str = NULL;
-	ret = gf_asprintf (&str, "%p", ptr);
+        char *str = NULL;
+
+        ret = gf_asprintf (&str, "%p", ptr);
         if (-1 == ret) {
-                gf_log ("ioc", GF_LOG_ERROR, 
+                gf_log ("ioc", GF_LOG_ERROR,
                         "asprintf failed while converting ptr to str");
                 return NULL;
         }
-	return str;
+        return str;
 }
 
 void
-ioc_inode_wakeup (call_frame_t *frame, ioc_inode_t *ioc_inode, 
+ioc_inode_wakeup (call_frame_t *frame, ioc_inode_t *ioc_inode,
                   struct iatt *stbuf)
 {
-	ioc_waitq_t *waiter = NULL, *waited = NULL;
-	ioc_waitq_t *page_waitq = NULL;
-	int8_t      cache_still_valid = 1;
-	ioc_local_t *local = NULL;
-	int8_t      need_fault = 0;
-	ioc_page_t  *waiter_page = NULL;
+        ioc_waitq_t *waiter            = NULL, *waited = NULL;
+        ioc_waitq_t *page_waitq        = NULL;
+        int8_t       cache_still_valid = 1;
+        ioc_local_t *local             = NULL;
+        int8_t       need_fault        = 0;
+        ioc_page_t  *waiter_page       = NULL;
 
         local = frame->local;
-	ioc_inode_lock (ioc_inode);
-	{
-		waiter = ioc_inode->waitq;
-		ioc_inode->waitq = NULL;
-	}
-	ioc_inode_unlock (ioc_inode);
-
-	if (stbuf)
-		cache_still_valid = ioc_cache_still_valid (ioc_inode, stbuf);
-	else
-		cache_still_valid = 0;
-
-	if (!waiter) {
-		gf_log (frame->this->name, GF_LOG_DEBUG,
-			"cache validate called without any "
-			"page waiting to be validated");
-	}
-
-	while (waiter) {
-		waiter_page = waiter->data;
-		page_waitq = NULL;
-    
-		if (waiter_page) {
-			if (cache_still_valid) {
-				/* cache valid, wake up page */
-				ioc_inode_lock (ioc_inode);
-				{
-					page_waitq = 
-						ioc_page_wakeup (waiter_page);
-				}
-				ioc_inode_unlock (ioc_inode);
-				if (page_waitq)
-					ioc_waitq_return (page_waitq);
-			} else {
-				/* cache invalid, generate page fault and set 
-				 * page->ready = 0, to avoid double faults  
-				 */
-				ioc_inode_lock (ioc_inode);
-	
-				if (waiter_page->ready) {
-					waiter_page->ready = 0;
-					need_fault = 1;
-				} else {
-					gf_log (frame->this->name, 
-						GF_LOG_TRACE,
-						"validate frame(%p) is waiting"
-						"for in-transit page = %p",
-						frame, waiter_page);
-				}
-	
-				ioc_inode_unlock (ioc_inode);
-      
-				if (need_fault) {
-					need_fault = 0;
-					ioc_page_fault (ioc_inode, frame, 
-							local->fd, 
-							waiter_page->offset);
-				}
-			}
-		}
-
-		waited = waiter;
-		waiter = waiter->next;
-    
-		waited->data = NULL;
-		GF_FREE (waited);
-	}
+        ioc_inode_lock (ioc_inode);
+        {
+                waiter = ioc_inode->waitq;
+                ioc_inode->waitq = NULL;
+        }
+        ioc_inode_unlock (ioc_inode);
+
+        if (stbuf)
+                cache_still_valid = ioc_cache_still_valid (ioc_inode, stbuf);
+        else
+                cache_still_valid = 0;
+
+        if (!waiter) {
+                gf_log (frame->this->name, GF_LOG_DEBUG,
+                        "cache validate called without any "
+                        "page waiting to be validated");
+        }
+
+        while (waiter) {
+                waiter_page = waiter->data;
+                page_waitq = NULL;
+
+                if (waiter_page) {
+                        if (cache_still_valid) {
+                                /* cache valid, wake up page */
+                                ioc_inode_lock (ioc_inode);
+                                {
+                                        page_waitq =
+                                                __ioc_page_wakeup (waiter_page);
+                                }
+                                ioc_inode_unlock (ioc_inode);
+
+                                if (page_waitq)
+                                        ioc_waitq_return (page_waitq);
+                        } else {
+                                /* cache invalid, generate page fault and set
+                                 * page->ready = 0, to avoid double faults
+                                 */
+                                ioc_inode_lock (ioc_inode);
+                                {
+                                        if (waiter_page->ready) {
+                                                waiter_page->ready = 0;
+                                                need_fault = 1;
+                                        } else {
+                                                gf_log (frame->this->name,
+                                                        GF_LOG_TRACE,
+                                                        "validate frame(%p) is "
+                                                        "waiting "
+                                                        "for in-transit page = "
+                                                        "%p",
+                                                        frame, waiter_page);
+                                        }
+                                }
+                                ioc_inode_unlock (ioc_inode);
+
+                                if (need_fault) {
+                                        need_fault = 0;
+                                        ioc_page_fault (ioc_inode, frame,
+                                                        local->fd,
+                                                        waiter_page->offset);
+                                }
+                        }
+                }
+
+                waited = waiter;
+                waiter = waiter->next;
+
+                waited->data = NULL;
+                GF_FREE (waited);
+        }
 }
 
-/* 
- * ioc_inode_update - create a new ioc_inode_t structure and add it to 
- *                    the table table. fill in the fields which are derived 
+/*
+ * ioc_inode_update - create a new ioc_inode_t structure and add it to
+ *                    the table table. fill in the fields which are derived
  *                    from inode_t corresponding to the file
- * 
+ *
  * @table: io-table structure
  * @inode: inode structure
  *
@@ -155,60 +159,60 @@ ioc_inode_wakeup (call_frame_t *frame, ioc_inode_t *ioc_inode,
 ioc_inode_t *
 ioc_inode_update (ioc_table_t *table, inode_t *inode, uint32_t weight)
 {
-	ioc_inode_t     *ioc_inode   = NULL;
+        ioc_inode_t     *ioc_inode   = NULL;
 
         ioc_inode = GF_CALLOC (1, sizeof (ioc_inode_t),
                                gf_ioc_mt_ioc_inode_t);
         if (ioc_inode == NULL) {
                 goto out;
         }
-  
-	ioc_inode->table = table;
-	INIT_LIST_HEAD (&ioc_inode->cache.page_lru);
 
-	ioc_table_lock (table);
+        ioc_inode->table = table;
+        INIT_LIST_HEAD (&ioc_inode->cache.page_lru);
+
+        ioc_table_lock (table);
 
-	table->inode_count++;
-	list_add (&ioc_inode->inode_list, &table->inodes);
-	list_add_tail (&ioc_inode->inode_lru, &table->inode_lru[weight]);
+        table->inode_count++;
+        list_add (&ioc_inode->inode_list, &table->inodes);
+        list_add_tail (&ioc_inode->inode_lru, &table->inode_lru[weight]);
 
-	gf_log (table->xl->name,
-		GF_LOG_TRACE,
-		"adding to inode_lru[%d]", weight);
+        gf_log (table->xl->name,
+                GF_LOG_TRACE,
+                "adding to inode_lru[%d]", weight);
 
-	ioc_table_unlock (table);
+        ioc_table_unlock (table);
+
+        pthread_mutex_init (&ioc_inode->inode_lock, NULL);
+        ioc_inode->weight = weight;
 
-	pthread_mutex_init (&ioc_inode->inode_lock, NULL);
-	ioc_inode->weight = weight;
-  
 out:
-	return ioc_inode;
+        return ioc_inode;
 }
 
 
-/* 
+/*
  * ioc_inode_destroy - destroy an ioc_inode_t object.
  *
  * @inode: inode to destroy
  *
- * to be called only from ioc_forget. 
+ * to be called only from ioc_forget.
  */
 void
 ioc_inode_destroy (ioc_inode_t *ioc_inode)
 {
-	ioc_table_t *table = NULL;
+        ioc_table_t *table = NULL;
 
         table = ioc_inode->table;
 
-	ioc_table_lock (table);
-	table->inode_count--;
-	list_del (&ioc_inode->inode_list);
-	list_del (&ioc_inode->inode_lru);
-	ioc_table_unlock (table);
-  
-	ioc_inode_flush (ioc_inode);
+        ioc_table_lock (table);
+        table->inode_count--;
+        list_del (&ioc_inode->inode_list);
+        list_del (&ioc_inode->inode_lru);
+        ioc_table_unlock (table);
+
+        ioc_inode_flush (ioc_inode);
         rbthash_table_destroy (ioc_inode->cache.page_table);
 
-	pthread_mutex_destroy (&ioc_inode->inode_lock);
-	GF_FREE (ioc_inode);
+        pthread_mutex_destroy (&ioc_inode->inode_lock);
+        GF_FREE (ioc_inode);
 }
diff --git a/xlators/performance/io-cache/src/ioc-mem-types.h b/xlators/performance/io-cache/src/ioc-mem-types.h
index 2cb5ea878..1f075ca9b 100644
--- a/xlators/performance/io-cache/src/ioc-mem-types.h
+++ b/xlators/performance/io-cache/src/ioc-mem-types.h
@@ -1,20 +1,20 @@
 /*
-   Copyright (c) 2007-2010 Gluster, Inc. <http://www.gluster.com>
-   This file is part of GlusterFS.
+  Copyright (c) 2007-2010 Gluster, Inc. <http://www.gluster.com>
+  This file is part of GlusterFS.
 
-   GlusterFS is free software; you can redistribute it and/or modify
-   it under the terms of the GNU Affero General Public License as published
-   by the Free Software Foundation; either version 3 of the License,
-   or (at your option) any later version.
+  GlusterFS is free software; you can redistribute it and/or modify
+  it under the terms of the GNU Affero General Public License as published
+  by the Free Software Foundation; either version 3 of the License,
+  or (at your option) any later version.
 
-   GlusterFS is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Affero General Public License for more details.
+  GlusterFS is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Affero General Public License for more details.
 
-   You should have received a copy of the GNU Affero General Public License
-   along with this program.  If not, see
-   <http://www.gnu.org/licenses/>.
+  You should have received a copy of the GNU Affero General Public License
+  along with this program.  If not, see
+  <http://www.gnu.org/licenses/>.
 */
 
 #ifndef __IOC_MT_H__
diff --git a/xlators/performance/io-cache/src/page.c b/xlators/performance/io-cache/src/page.c
index 47a8fbb66..728f03736 100644
--- a/xlators/performance/io-cache/src/page.c
+++ b/xlators/performance/io-cache/src/page.c
@@ -38,26 +38,44 @@ ioc_empty (struct ioc_cache *cache)
 }
 
 ioc_page_t *
-ioc_page_get (ioc_inode_t *ioc_inode, off_t offset)
+__ioc_page_get (ioc_inode_t *ioc_inode, off_t offset)
 {
-	ioc_page_t   *page           = NULL;
-	ioc_table_t  *table          = NULL;
-	off_t         rounded_offset = 0;
+        ioc_page_t   *page           = NULL;
+        ioc_table_t  *table          = NULL;
+        off_t         rounded_offset = 0;
 
         table = ioc_inode->table;
         rounded_offset = floor (offset, table->page_size);
- 
+
         page = rbthash_get (ioc_inode->cache.page_table, &rounded_offset,
                             sizeof (rounded_offset));
 
         if (page != NULL) {
-		/* push the page to the end of the lru list */
-		list_move_tail (&page->page_lru, &ioc_inode->cache.page_lru);
-	}
+                /* push the page to the end of the lru list */
+                list_move_tail (&page->page_lru, &ioc_inode->cache.page_lru);
+        }
 
-	return page;
+        return page;
 }
 
+ioc_page_t *
+ioc_page_get (ioc_inode_t *ioc_inode, off_t offset)
+{
+        ioc_page_t *page = NULL;
+
+        if (ioc_inode == NULL) {
+                goto out;
+        }
+
+        ioc_inode_lock (ioc_inode);
+        {
+                page = __ioc_page_get (ioc_inode, offset);
+        }
+        ioc_inode_unlock (ioc_inode);
+
+out:
+        return page;
+}
 
 /*
  * ioc_page_destroy -
@@ -66,40 +84,98 @@ ioc_page_get (ioc_inode_t *ioc_inode, off_t offset)
  *
  */
 int64_t
-ioc_page_destroy (ioc_page_t *page)
+__ioc_page_destroy (ioc_page_t *page)
 {
-	int64_t  page_size = 0;
+        int64_t  page_size = 0;
 
-	page_size = iobref_size (page->iobref);
+        page_size = iobref_size (page->iobref);
 
-	if (page->waitq) {
-		/* frames waiting on this page, do not destroy this page */
-		page_size = -1;
-	} else {
+        if (page->waitq) {
+                /* frames waiting on this page, do not destroy this page */
+                page_size = -1;
+        } else {
                 rbthash_remove (page->inode->cache.page_table, &page->offset,
                                 sizeof (page->offset));
-		list_del (&page->page_lru);
-    
-		gf_log (page->inode->table->xl->name, GF_LOG_TRACE,
-			"destroying page = %p, offset = %"PRId64" "
-			"&& inode = %p",
-			page, page->offset, page->inode);
-    
-		if (page->vector){
-			iobref_unref (page->iobref);
-			GF_FREE (page->vector);
-			page->vector = NULL;
-		}
-    
-		page->inode = NULL;
-	}
-
-	if (page_size != -1) {
-		pthread_mutex_destroy (&page->page_lock);
-		GF_FREE (page);
-	}
-
-	return page_size;
+                list_del (&page->page_lru);
+
+                gf_log (page->inode->table->xl->name, GF_LOG_TRACE,
+                        "destroying page = %p, offset = %"PRId64" "
+                        "&& inode = %p",
+                        page, page->offset, page->inode);
+
+                if (page->vector){
+                        iobref_unref (page->iobref);
+                        GF_FREE (page->vector);
+                        page->vector = NULL;
+                }
+
+                page->inode = NULL;
+        }
+
+        if (page_size != -1) {
+                pthread_mutex_destroy (&page->page_lock);
+                GF_FREE (page);
+        }
+
+        return page_size;
+}
+
+
+int64_t
+ioc_page_destroy (ioc_page_t *page)
+{
+        int64_t ret = 0;
+
+        if (page == NULL) {
+                goto out;
+        }
+
+        ioc_inode_lock (page->inode);
+        {
+                ret = __ioc_page_destroy (page);
+        }
+        ioc_inode_unlock (page->inode);
+
+out:
+        return ret;
+}
+
+int32_t
+__ioc_inode_prune (ioc_inode_t *curr, uint64_t *size_pruned,
+                   uint64_t size_to_prune, uint32_t index)
+{
+        ioc_page_t  *page  = NULL, *next = NULL;
+        int32_t      ret   = 0;
+        ioc_table_t *table = NULL;
+
+        if (curr == NULL) {
+                goto out;
+        }
+
+        table = curr->table;
+
+        list_for_each_entry_safe (page, next, &curr->cache.page_lru, page_lru) {
+                *size_pruned += page->size;
+                ret = __ioc_page_destroy (page);
+
+                if (ret != -1)
+                        table->cache_used -= ret;
+
+                gf_log (table->xl->name, GF_LOG_TRACE,
+                        "index = %d && table->cache_used = %"PRIu64" && table->"
+                        "cache_size = %"PRIu64, index, table->cache_used,
+                        table->cache_size);
+
+                if ((*size_pruned) >= size_to_prune)
+                        break;
+        }
+
+        if (ioc_empty (&curr->cache)) {
+                list_del_init (&curr->inode_lru);
+        }
+
+out:
+        return 0;
 }
 
 /*
@@ -112,69 +188,41 @@ ioc_page_destroy (ioc_page_t *page)
 int32_t
 ioc_prune (ioc_table_t *table)
 {
-	ioc_inode_t *curr = NULL, *next_ioc_inode = NULL;
-	ioc_page_t  *page = NULL, *next = NULL;
-	int32_t     ret = -1;
-	int32_t     index = 0;
-	uint64_t    size_to_prune = 0;
-	uint64_t    size_pruned = 0;
-
-	ioc_table_lock (table);
-	{
-		size_to_prune = table->cache_used - table->cache_size;
-		/* take out the least recently used inode */
-		for (index=0; index < table->max_pri; index++) {
-			list_for_each_entry_safe (curr, next_ioc_inode, 
-						  &table->inode_lru[index], 
-						  inode_lru) {
-				/* prune page-by-page for this inode, till 
-				 * we reach the equilibrium */
-				ioc_inode_lock (curr);
-				/* { */
-
-				list_for_each_entry_safe (page, next, 
-							  &curr->cache.page_lru,
-                                                          page_lru) {
-					/* done with all pages, and not 
-					 * reached equilibrium yet??
-					 * continue with next inode in 
-					 * lru_list */
-					size_pruned += page->size;
-					ret = ioc_page_destroy (page);
-
-					if (ret != -1)
-						table->cache_used -= ret;
-	    
-					gf_log (table->xl->name,
-						GF_LOG_TRACE,
-						"index = %d && table->cache_"
-						"used = %"PRIu64" && table->"
-						"cache_size = %"PRIu64, 
-						index, table->cache_used, 
-						table->cache_size);
-	    
-					if (size_pruned >= size_to_prune)
-						break;
-				} /* list_for_each_entry_safe(page...) */
-				if (ioc_empty (&curr->cache)) {
-					list_del_init (&curr->inode_lru);
-				}
-
-				/* } */ 
-				ioc_inode_unlock (curr);
-	
-				if (size_pruned >= size_to_prune)
-					break;
-			} /* list_for_each_entry_safe (curr...) */
-      
-			if (size_pruned >= size_to_prune)
-				break;
-		} /* for(index=0;...) */
-
-	} /* ioc_inode_table locked region end */
-	ioc_table_unlock (table);
-
-	return 0;
+        ioc_inode_t *curr = NULL, *next_ioc_inode = NULL;
+        int32_t     index = 0;
+        uint64_t    size_to_prune = 0;
+        uint64_t    size_pruned = 0;
+
+        ioc_table_lock (table);
+        {
+                size_to_prune = table->cache_used - table->cache_size;
+                /* take out the least recently used inode */
+                for (index=0; index < table->max_pri; index++) {
+                        list_for_each_entry_safe (curr, next_ioc_inode,
+                                                  &table->inode_lru[index],
+                                                  inode_lru) {
+                                /* prune page-by-page for this inode, till
+                                 * we reach the equilibrium */
+                                ioc_inode_lock (curr);
+                                {
+                                        __ioc_inode_prune (curr, &size_pruned,
+                                                           size_to_prune,
+                                                           index);
+                                }
+                                ioc_inode_unlock (curr);
+
+                                if (size_pruned >= size_to_prune)
+                                        break;
+                        } /* list_for_each_entry_safe (curr...) */
+
+                        if (size_pruned >= size_to_prune)
+                                break;
+                } /* for(index=0;...) */
+
+        } /* ioc_inode_table locked region end */
+        ioc_table_unlock (table);
+
+        return 0;
 }
 
 /*
@@ -185,12 +233,12 @@ ioc_prune (ioc_table_t *table)
  *
  */
 ioc_page_t *
-ioc_page_create (ioc_inode_t *ioc_inode, off_t offset)
+__ioc_page_create (ioc_inode_t *ioc_inode, off_t offset)
 {
-	ioc_table_t *table          = NULL;
-	ioc_page_t  *page           = NULL;
-	off_t        rounded_offset = 0;
-	ioc_page_t  *newpage        = NULL;
+        ioc_table_t *table          = NULL;
+        ioc_page_t  *page           = NULL;
+        off_t        rounded_offset = 0;
+        ioc_page_t  *newpage        = NULL;
 
         table = ioc_inode->table;
         rounded_offset = floor (offset, table->page_size);
@@ -201,71 +249,71 @@ ioc_page_create (ioc_inode_t *ioc_inode, off_t offset)
                 goto out;
         }
 
-	if (!ioc_inode) {
+        if (!ioc_inode) {
                 GF_FREE (newpage);
                 newpage = NULL;
                 goto out;
-	}
+        }
 
-	newpage->offset = rounded_offset;
-	newpage->inode = ioc_inode;
-	pthread_mutex_init (&newpage->page_lock, NULL);
+        newpage->offset = rounded_offset;
+        newpage->inode = ioc_inode;
+        pthread_mutex_init (&newpage->page_lock, NULL);
 
         rbthash_insert (ioc_inode->cache.page_table, newpage, &rounded_offset,
                         sizeof (rounded_offset));
 
-	list_add_tail (&newpage->page_lru, &ioc_inode->cache.page_lru);
+        list_add_tail (&newpage->page_lru, &ioc_inode->cache.page_lru);
 
-	page = newpage;
+        page = newpage;
 
-	gf_log ("io-cache", GF_LOG_TRACE,
-		"returning new page %p", page);
+        gf_log ("io-cache", GF_LOG_TRACE,
+                "returning new page %p", page);
 
 out:
-	return page;
+        return page;
 }
 
-/* 
- * ioc_wait_on_page - pause a frame to wait till the arrival of a page. 
- * here we need to handle the case when the frame who calls wait_on_page 
- * himself has caused page_fault 
+/*
+ * ioc_wait_on_page - pause a frame to wait till the arrival of a page.
+ * here we need to handle the case when the frame who calls wait_on_page
+ * himself has caused page_fault
  *
  * @page: page to wait on
  * @frame: call frame who is waiting on page
  *
  */
 void
-ioc_wait_on_page (ioc_page_t *page, call_frame_t *frame, off_t offset,
-		  size_t size)
+__ioc_wait_on_page (ioc_page_t *page, call_frame_t *frame, off_t offset,
+                    size_t size)
 {
-	ioc_waitq_t *waitq = NULL;
-	ioc_local_t *local = frame->local;
+        ioc_waitq_t *waitq = NULL;
+        ioc_local_t *local = frame->local;
 
-	waitq = GF_CALLOC (1, sizeof (*waitq), gf_ioc_mt_ioc_waitq_t);
+        waitq = GF_CALLOC (1, sizeof (*waitq), gf_ioc_mt_ioc_waitq_t);
         if (waitq == NULL) {
                 local->op_ret = -1;
                 local->op_errno = ENOMEM;
                 gf_log (frame->this->name, GF_LOG_ERROR, "out of memory");
                 goto out;
-        } 
-
-	gf_log (frame->this->name, GF_LOG_TRACE,
-		"frame(%p) waiting on page = %p, offset=%"PRId64", "
-		"size=%"GF_PRI_SIZET"",
-		frame, page, offset, size);
-
-	waitq->data = frame;
-	waitq->next = page->waitq;
-	waitq->pending_offset = offset;
-	waitq->pending_size = size;
-	page->waitq = waitq;
-	/* one frame can wait only once on a given page, 
-	 * local->wait_count is number of pages a frame is waiting on */
-	ioc_local_lock (local);
-	{
-		local->wait_count++;
-	}
-	ioc_local_unlock (local);
+        }
+
+        gf_log (frame->this->name, GF_LOG_TRACE,
+                "frame(%p) waiting on page = %p, offset=%"PRId64", "
+                "size=%"GF_PRI_SIZET"",
+                frame, page, offset, size);
+
+        waitq->data = frame;
+        waitq->next = page->waitq;
+        waitq->pending_offset = offset;
+        waitq->pending_size = size;
+        page->waitq = waitq;
+        /* one frame can wait only once on a given page,
+         * local->wait_count is number of pages a frame is waiting on */
+        ioc_local_lock (local);
+        {
+                local->wait_count++;
+        }
+        ioc_local_unlock (local);
 
 out:
         return;
@@ -273,7 +321,7 @@ out:
 
 
 /*
- * ioc_cache_still_valid - see if cached pages ioc_inode are still valid 
+ * ioc_cache_still_valid - see if cached pages ioc_inode are still valid
  * against given stbuf
  *
  * @ioc_inode:
@@ -284,62 +332,62 @@ out:
 int8_t
 ioc_cache_still_valid (ioc_inode_t *ioc_inode, struct iatt *stbuf)
 {
-	int8_t cache_still_valid = 1;
+        int8_t cache_still_valid = 1;
 
 #if 0
-	if (!stbuf || (stbuf->ia_mtime != ioc_inode->cache.mtime) || 
-	    (stbuf->st_mtim.tv_nsec != ioc_inode->stbuf.st_mtim.tv_nsec))
-		cache_still_valid = 0;
+        if (!stbuf || (stbuf->ia_mtime != ioc_inode->cache.mtime) ||
+            (stbuf->st_mtim.tv_nsec != ioc_inode->stbuf.st_mtim.tv_nsec))
+                cache_still_valid = 0;
 
 #else
-	if (!stbuf || (stbuf->ia_mtime != ioc_inode->cache.mtime)
+        if (!stbuf || (stbuf->ia_mtime != ioc_inode->cache.mtime)
             || (stbuf->ia_mtime_nsec != ioc_inode->cache.mtime_nsec))
-		cache_still_valid = 0;
+                cache_still_valid = 0;
 
 #endif
 
 #if 0
-	/* talk with avati@gluster.com to enable this section */
-	if (!ioc_inode->mtime && stbuf) {
-		cache_still_valid = 1;
-		ioc_inode->mtime = stbuf->ia_mtime;
-	}
+        /* talk with avati@gluster.com to enable this section */
+        if (!ioc_inode->mtime && stbuf) {
+                cache_still_valid = 1;
+                ioc_inode->mtime = stbuf->ia_mtime;
+        }
 #endif
 
-	return cache_still_valid;
+        return cache_still_valid;
 }
 
 
 void
 ioc_waitq_return (ioc_waitq_t *waitq)
 {
-	ioc_waitq_t  *trav   = NULL;
-	ioc_waitq_t  *next   = NULL;
-	call_frame_t *frame = NULL;
+        ioc_waitq_t  *trav   = NULL;
+        ioc_waitq_t  *next   = NULL;
+        call_frame_t *frame = NULL;
 
-	for (trav = waitq; trav; trav = next) {
-		next = trav->next;
+        for (trav = waitq; trav; trav = next) {
+                next = trav->next;
 
-		frame = trav->data;
-		ioc_frame_return (frame);
-		GF_FREE (trav);
-	}
+                frame = trav->data;
+                ioc_frame_return (frame);
+                GF_FREE (trav);
+        }
 }
 
 
 int
 ioc_fault_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                int32_t op_ret, int32_t op_errno, struct iovec *vector,
-	       int32_t count, struct iatt *stbuf, struct iobref *iobref)
+               int32_t count, struct iatt *stbuf, struct iobref *iobref)
 {
-	ioc_local_t *local = NULL;
-	off_t       offset = 0;
-	ioc_inode_t *ioc_inode = NULL;
-	ioc_table_t *table = NULL;
-	ioc_page_t  *page = NULL;
-	int32_t     destroy_size = 0;
-	size_t      page_size = 0;
-	ioc_waitq_t *waitq = NULL;
+        ioc_local_t *local = NULL;
+        off_t       offset = 0;
+        ioc_inode_t *ioc_inode = NULL;
+        ioc_table_t *table = NULL;
+        ioc_page_t  *page = NULL;
+        int32_t     destroy_size = 0;
+        size_t      page_size = 0;
+        ioc_waitq_t *waitq = NULL;
         size_t      iobref_page_size = 0;
         char        zero_filled = 0;
 
@@ -351,127 +399,128 @@ ioc_fault_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         zero_filled = ((op_ret >=0)
                        && (stbuf->ia_mtime == 0));
 
-	ioc_inode_lock (ioc_inode);
-	{
-		if (op_ret == -1 ||
-		    !(zero_filled ||
+        ioc_inode_lock (ioc_inode);
+        {
+                if (op_ret == -1 ||
+                    !(zero_filled ||
                       ioc_cache_still_valid(ioc_inode, stbuf))) {
-			gf_log (ioc_inode->table->xl->name, GF_LOG_TRACE,
-				"cache for inode(%p) is invalid. flushing "
-				"all pages", ioc_inode);
-			destroy_size = __ioc_inode_flush (ioc_inode);
-		}
-
-		if ((op_ret >= 0) && !zero_filled) {
-			ioc_inode->cache.mtime = stbuf->ia_mtime;
+                        gf_log (ioc_inode->table->xl->name, GF_LOG_TRACE,
+                                "cache for inode(%p) is invalid. flushing "
+                                "all pages", ioc_inode);
+                        destroy_size = __ioc_inode_flush (ioc_inode);
+                }
+
+                if ((op_ret >= 0) && !zero_filled) {
+                        ioc_inode->cache.mtime = stbuf->ia_mtime;
                         ioc_inode->cache.mtime_nsec = stbuf->ia_mtime_nsec;
                 }
 
-		gettimeofday (&ioc_inode->cache.tv, NULL);
-
-		if (op_ret < 0) {
-			/* error, readv returned -1 */
-			page = ioc_page_get (ioc_inode, offset);
-			if (page)
-				waitq = ioc_page_error (page, op_ret, 
-							op_errno);
-		} else {
-			gf_log (ioc_inode->table->xl->name, GF_LOG_TRACE,
-				"op_ret = %d", op_ret);
-			page = ioc_page_get (ioc_inode, offset);
-			if (!page) {
-				/* page was flushed */
-				/* some serious bug ? */
-				gf_log (this->name, GF_LOG_DEBUG,
-					"wasted copy: %"PRId64"[+%"PRId64"] "
-					"ioc_inode=%p", offset, 
-					table->page_size, ioc_inode);
-			} else {
-				if (page->vector) {
-					iobref_unref (page->iobref);
-					GF_FREE (page->vector);
-					page->vector = NULL;
-				}
-
-				/* keep a copy of the page for our cache */
-				page->vector = iov_dup (vector, count);
+                gettimeofday (&ioc_inode->cache.tv, NULL);
+
+                if (op_ret < 0) {
+                        /* error, readv returned -1 */
+                        page = __ioc_page_get (ioc_inode, offset);
+                        if (page)
+                                waitq = __ioc_page_error (page, op_ret,
+                                                          op_errno);
+                } else {
+                        gf_log (ioc_inode->table->xl->name, GF_LOG_TRACE,
+                                "op_ret = %d", op_ret);
+                        page = __ioc_page_get (ioc_inode, offset);
+                        if (!page) {
+                                /* page was flushed */
+                                /* some serious bug ? */
+                                gf_log (this->name, GF_LOG_DEBUG,
+                                        "wasted copy: %"PRId64"[+%"PRId64"] "
+                                        "ioc_inode=%p", offset,
+                                        table->page_size, ioc_inode);
+                        } else {
+                                if (page->vector) {
+                                        iobref_unref (page->iobref);
+                                        GF_FREE (page->vector);
+                                        page->vector = NULL;
+                                }
+
+                                /* keep a copy of the page for our cache */
+                                page->vector = iov_dup (vector, count);
                                 if (page->vector == NULL) {
-                                        page = ioc_page_get (ioc_inode, offset);
+                                        page = __ioc_page_get (ioc_inode,
+                                                               offset);
                                         if (page != NULL)
-                                                waitq = ioc_page_error (page,
-                                                                        -1, 
-                                                                        ENOMEM);
+                                                waitq = __ioc_page_error (page,
+                                                                          -1,
+                                                                          ENOMEM);
                                         goto unlock;
                                 }
 
-				page->count = count;
-				if (iobref) {
-					page->iobref = iobref_ref (iobref);
-				} else {
-					/* TODO: we have got a response to 
-					 * our request and no data */
-					gf_log (this->name, GF_LOG_CRITICAL,
-						"frame>root>rsp_refs is null");
-				} /* if(frame->root->rsp_refs) */
-
-				/* page->size should indicate exactly how 
-				 * much the readv call to the child
-				 * translator returned. earlier op_ret 
-				 * from child translator was used, which 
-				 * gave rise to a bug where reads from 
-				 * io-cached volume were resulting in 0 
-				 * byte replies */
-				page_size = iov_length(vector, count);
-				page->size = page_size;
+                                page->count = count;
+                                if (iobref) {
+                                        page->iobref = iobref_ref (iobref);
+                                } else {
+                                        /* TODO: we have got a response to
+                                         * our request and no data */
+                                        gf_log (this->name, GF_LOG_CRITICAL,
+                                                "frame>root>rsp_refs is null");
+                                } /* if(frame->root->rsp_refs) */
+
+                                /* page->size should indicate exactly how
+                                 * much the readv call to the child
+                                 * translator returned. earlier op_ret
+                                 * from child translator was used, which
+                                 * gave rise to a bug where reads from
+                                 * io-cached volume were resulting in 0
+                                 * byte replies */
+                                page_size = iov_length(vector, count);
+                                page->size = page_size;
 
                                 iobref_page_size = iobref_size (page->iobref);
 
-				if (page->waitq) {
-					/* wake up all the frames waiting on 
-					 * this page, including 
-					 * the frame which triggered fault */
-					waitq = ioc_page_wakeup (page);
-				} /* if(page->waitq) */
-			} /* if(!page)...else */
-		} /* if(op_ret < 0)...else */
-	} /* ioc_inode locked region end */
+                                if (page->waitq) {
+                                        /* wake up all the frames waiting on
+                                         * this page, including
+                                         * the frame which triggered fault */
+                                        waitq = __ioc_page_wakeup (page);
+                                } /* if(page->waitq) */
+                        } /* if(!page)...else */
+                } /* if(op_ret < 0)...else */
+        } /* ioc_inode locked region end */
 unlock:
-	ioc_inode_unlock (ioc_inode);
+        ioc_inode_unlock (ioc_inode);
 
-	ioc_waitq_return (waitq);
+        ioc_waitq_return (waitq);
 
-	if (iobref_page_size) {
-		ioc_table_lock (table);
-		{
-			table->cache_used += iobref_page_size;
-		}
-		ioc_table_unlock (table);
-	}
+        if (iobref_page_size) {
+                ioc_table_lock (table);
+                {
+                        table->cache_used += iobref_page_size;
+                }
+                ioc_table_unlock (table);
+        }
 
-	if (destroy_size) {
-		ioc_table_lock (table);
-		{
-			table->cache_used -= destroy_size;
-		}
-		ioc_table_unlock (table);
-	}
+        if (destroy_size) {
+                ioc_table_lock (table);
+                {
+                        table->cache_used -= destroy_size;
+                }
+                ioc_table_unlock (table);
+        }
 
-	if (ioc_need_prune (ioc_inode->table)) {
-		ioc_prune (ioc_inode->table);
-	}
+        if (ioc_need_prune (ioc_inode->table)) {
+                ioc_prune (ioc_inode->table);
+        }
 
-	gf_log (this->name, GF_LOG_TRACE, "fault frame %p returned", frame);
-	pthread_mutex_destroy (&local->local_lock);
+        gf_log (this->name, GF_LOG_TRACE, "fault frame %p returned", frame);
+        pthread_mutex_destroy (&local->local_lock);
 
-	fd_unref (local->fd);
+        fd_unref (local->fd);
 
-	STACK_DESTROY (frame->root);
-	return 0;
+        STACK_DESTROY (frame->root);
+        return 0;
 }
 
 /*
  * ioc_page_fault -
- * 
+ *
  * @ioc_inode:
  * @frame:
  * @fd:
@@ -480,14 +529,14 @@ unlock:
  */
 void
 ioc_page_fault (ioc_inode_t *ioc_inode,	call_frame_t *frame, fd_t *fd,
-		off_t offset)
+                off_t offset)
 {
-	ioc_table_t  *table = NULL;
-	call_frame_t *fault_frame = NULL;
-	ioc_local_t  *fault_local = NULL;
-        int32_t      op_ret = -1, op_errno = -1;
-        ioc_waitq_t  *waitq = NULL;
-        ioc_page_t   *page = NULL;
+        ioc_table_t  *table       = NULL;
+        call_frame_t *fault_frame = NULL;
+        ioc_local_t  *fault_local = NULL;
+        int32_t       op_ret      = -1, op_errno = -1;
+        ioc_waitq_t  *waitq       = NULL;
+        ioc_page_t   *page        = NULL;
 
         table = ioc_inode->table;
         fault_frame = copy_frame (frame);
@@ -500,7 +549,7 @@ ioc_page_fault (ioc_inode_t *ioc_inode,	call_frame_t *frame, fd_t *fd,
         }
 
         fault_local = GF_CALLOC (1, sizeof (ioc_local_t),
-                                gf_ioc_mt_ioc_local_t);
+                                 gf_ioc_mt_ioc_local_t);
         if (fault_local == NULL) {
                 op_ret = -1;
                 op_errno = ENOMEM;
@@ -510,92 +559,97 @@ ioc_page_fault (ioc_inode_t *ioc_inode,	call_frame_t *frame, fd_t *fd,
                 goto err;
         }
 
-	/* NOTE: copy_frame() means, the frame the fop whose fd_ref we 
-	 * are using till now won't be valid till we get reply from server. 
-	 * we unref this fd, in fault_cbk */
-	fault_local->fd = fd_ref (fd);
+        /* NOTE: copy_frame() means, the frame the fop whose fd_ref we
+         * are using till now won't be valid till we get reply from server.
+         * we unref this fd, in fault_cbk */
+        fault_local->fd = fd_ref (fd);
+
+        fault_frame->local = fault_local;
+        pthread_mutex_init (&fault_local->local_lock, NULL);
 
-	fault_frame->local = fault_local;
-	pthread_mutex_init (&fault_local->local_lock, NULL);
+        INIT_LIST_HEAD (&fault_local->fill_list);
+        fault_local->pending_offset = offset;
+        fault_local->pending_size = table->page_size;
+        fault_local->inode = ioc_inode;
 
-	INIT_LIST_HEAD (&fault_local->fill_list);
-	fault_local->pending_offset = offset;
-	fault_local->pending_size = table->page_size;
-	fault_local->inode = ioc_inode;
+        gf_log (frame->this->name, GF_LOG_TRACE,
+                "stack winding page fault for offset = %"PRId64" with "
+                "frame %p", offset, fault_frame);
 
-	gf_log (frame->this->name, GF_LOG_TRACE,
-		"stack winding page fault for offset = %"PRId64" with "
-		"frame %p", offset, fault_frame);
-  
-	STACK_WIND (fault_frame, ioc_fault_cbk, FIRST_CHILD(fault_frame->this),
-		    FIRST_CHILD(fault_frame->this)->fops->readv, fd,
+        STACK_WIND (fault_frame, ioc_fault_cbk, FIRST_CHILD(fault_frame->this),
+                    FIRST_CHILD(fault_frame->this)->fops->readv, fd,
                     table->page_size, offset);
-	return;
+        return;
 
 err:
-        page = ioc_page_get (ioc_inode, offset);
-        if (page != NULL) {
-                waitq = ioc_page_error (page, op_ret, op_errno);
-                if (waitq != NULL) {
-                        ioc_waitq_return (waitq);
+        ioc_inode_lock (ioc_inode);
+        {
+                page = __ioc_page_get (ioc_inode, offset);
+                if (page != NULL) {
+                        waitq = __ioc_page_error (page, op_ret, op_errno);
                 }
         }
+        ioc_inode_unlock (ioc_inode);
+
+        if (waitq != NULL) {
+                ioc_waitq_return (waitq);
+        }
 }
 
 int32_t
 ioc_frame_fill (ioc_page_t *page, call_frame_t *frame, off_t offset,
                 size_t size)
 {
-	ioc_local_t *local = NULL;
-	ioc_fill_t  *fill = NULL;
-	off_t       src_offset = 0;
-	off_t       dst_offset = 0;
-	ssize_t     copy_size = 0;
-	ioc_inode_t *ioc_inode = NULL;
-        ioc_fill_t  *new = NULL;
-        int8_t      found = 0;
-        int32_t     ret = 0;
+        ioc_local_t *local      = NULL;
+        ioc_fill_t  *fill       = NULL;
+        off_t        src_offset = 0;
+        off_t        dst_offset = 0;
+        ssize_t      copy_size  = 0;
+        ioc_inode_t *ioc_inode  = NULL;
+        ioc_fill_t  *new        = NULL;
+        int8_t       found      = 0;
+        int32_t      ret        = 0;
 
         local = frame->local;
         ioc_inode = page->inode;
 
-	gf_log (frame->this->name, GF_LOG_TRACE,
-		"frame (%p) offset = %"PRId64" && size = %"GF_PRI_SIZET" "
-		"&& page->size = %"GF_PRI_SIZET" && wait_count = %d",
-		frame, offset, size, page->size, local->wait_count);
-
-	/* immediately move this page to the end of the page_lru list */
-	list_move_tail (&page->page_lru, &ioc_inode->cache.page_lru);
-	/* fill local->pending_size bytes from local->pending_offset */
-	if (local->op_ret != -1 && page->size) {
-		if (offset > page->offset)
-			/* offset is offset in file, convert it to offset in
-			 * page */
-			src_offset = offset - page->offset;
-		/*FIXME: since offset is the offset within page is the
-		 * else case valid? */
-		else
-			/* local->pending_offset is in previous page. do not
-			 * fill until we have filled all previous pages */
-			dst_offset = page->offset - offset;
-
-		/* we have to copy from offset to either end of this page
-		 * or till the requested size */
-		copy_size = min (page->size - src_offset,
-				 size - dst_offset);
-
-		if (copy_size < 0) {
-			/* if page contains fewer bytes and the required offset
-			   is beyond the page size in the page */
-			copy_size = src_offset = 0;
-		}
-
-		gf_log (page->inode->table->xl->name, GF_LOG_TRACE,
-			"copy_size = %"GF_PRI_SIZET" && src_offset = "
-			"%"PRId64" && dst_offset = %"PRId64"",
-			copy_size, src_offset, dst_offset);
-
-		{
+        gf_log (frame->this->name, GF_LOG_TRACE,
+                "frame (%p) offset = %"PRId64" && size = %"GF_PRI_SIZET" "
+                "&& page->size = %"GF_PRI_SIZET" && wait_count = %d",
+                frame, offset, size, page->size, local->wait_count);
+
+        /* immediately move this page to the end of the page_lru list */
+        list_move_tail (&page->page_lru, &ioc_inode->cache.page_lru);
+        /* fill local->pending_size bytes from local->pending_offset */
+        if (local->op_ret != -1 && page->size) {
+                if (offset > page->offset)
+                        /* offset is offset in file, convert it to offset in
+                         * page */
+                        src_offset = offset - page->offset;
+                /*FIXME: since offset is the offset within page is the
+                 * else case valid? */
+                else
+                        /* local->pending_offset is in previous page. do not
+                         * fill until we have filled all previous pages */
+                        dst_offset = page->offset - offset;
+
+                /* we have to copy from offset to either end of this page
+                 * or till the requested size */
+                copy_size = min (page->size - src_offset,
+                                 size - dst_offset);
+
+                if (copy_size < 0) {
+                        /* if page contains fewer bytes and the required offset
+                           is beyond the page size in the page */
+                        copy_size = src_offset = 0;
+                }
+
+                gf_log (page->inode->table->xl->name, GF_LOG_TRACE,
+                        "copy_size = %"GF_PRI_SIZET" && src_offset = "
+                        "%"PRId64" && dst_offset = %"PRId64"",
+                        copy_size, src_offset, dst_offset);
+
+                {
                         new = GF_CALLOC (1, sizeof (*new),
                                          gf_ioc_mt_ioc_fill_t);
                         if (new == NULL) {
@@ -607,17 +661,17 @@ ioc_frame_fill (ioc_page_t *page, call_frame_t *frame, off_t offset,
                                 goto out;
                         }
 
-			new->offset = page->offset;
-			new->size = copy_size;
-			new->iobref = iobref_ref (page->iobref);
-			new->count = iov_subset (page->vector,
-						 page->count,
-						 src_offset,
-						 src_offset + copy_size,
-						 NULL);
-
-			new->vector = GF_CALLOC (new->count,
-					         sizeof (struct iovec),
+                        new->offset = page->offset;
+                        new->size = copy_size;
+                        new->iobref = iobref_ref (page->iobref);
+                        new->count = iov_subset (page->vector,
+                                                 page->count,
+                                                 src_offset,
+                                                 src_offset + copy_size,
+                                                 NULL);
+
+                        new->vector = GF_CALLOC (new->count,
+                                                 sizeof (struct iovec),
                                                  gf_ioc_mt_iovec);
                         if (new->vector == NULL) {
                                 local->op_ret = -1;
@@ -632,50 +686,50 @@ ioc_frame_fill (ioc_page_t *page, call_frame_t *frame, off_t offset,
                                 goto out;
                         }
 
-			new->count = iov_subset (page->vector,
-						 page->count,
-						 src_offset,
-						 src_offset + copy_size,
-						 new->vector);
+                        new->count = iov_subset (page->vector,
+                                                 page->count,
+                                                 src_offset,
+                                                 src_offset + copy_size,
+                                                 new->vector);
 
 
 
-			/* add the ioc_fill to fill_list for this frame */
-			if (list_empty (&local->fill_list)) {
-				/* if list is empty, then this is the first
-				 * time we are filling frame, add the
-				 * ioc_fill_t to the end of list */
-				list_add_tail (&new->list, &local->fill_list);
-			} else {
+                        /* add the ioc_fill to fill_list for this frame */
+                        if (list_empty (&local->fill_list)) {
+                                /* if list is empty, then this is the first
+                                 * time we are filling frame, add the
+                                 * ioc_fill_t to the end of list */
+                                list_add_tail (&new->list, &local->fill_list);
+                        } else {
                                 found = 0;
-				/* list is not empty, we need to look for
-				 * where this offset fits in list */
-				list_for_each_entry (fill, &local->fill_list,
-						     list) {
-					if (fill->offset > new->offset) {
-						found = 1;
-						break;
-					}
-				}
-
-				if (found) {
-					list_add_tail (&new->list,
-						       &fill->list);
-				} else {
-					list_add_tail (&new->list,
-						       &local->fill_list);
-				}
-			}
-		}
-		local->op_ret += copy_size;
-	}
+                                /* list is not empty, we need to look for
+                                 * where this offset fits in list */
+                                list_for_each_entry (fill, &local->fill_list,
+                                                     list) {
+                                        if (fill->offset > new->offset) {
+                                                found = 1;
+                                                break;
+                                        }
+                                }
+
+                                if (found) {
+                                        list_add_tail (&new->list,
+                                                       &fill->list);
+                                } else {
+                                        list_add_tail (&new->list,
+                                                       &local->fill_list);
+                                }
+                        }
+                }
+                local->op_ret += copy_size;
+        }
 
 out:
         return ret;
 }
 
 /*
- * ioc_frame_unwind - frame unwinds only from here 
+ * ioc_frame_unwind - frame unwinds only from here
  *
  * @frame: call frame to unwind
  *
@@ -686,43 +740,43 @@ out:
 static void
 ioc_frame_unwind (call_frame_t *frame)
 {
-	ioc_local_t   *local = NULL;
-	ioc_fill_t    *fill = NULL, *next = NULL;
-	int32_t       count = 0;
-	struct iovec  *vector = NULL;
-	int32_t       copied = 0;
-	struct iobref *iobref = NULL;
-	struct iatt   stbuf = {0,};
-	int32_t       op_ret = 0;
+        ioc_local_t   *local  = NULL;
+        ioc_fill_t    *fill   = NULL, *next = NULL;
+        int32_t        count  = 0;
+        struct iovec  *vector = NULL;
+        int32_t        copied = 0;
+        struct iobref *iobref = NULL;
+        struct iatt    stbuf  = {0,};
+        int32_t        op_ret = 0;
 
         local = frame->local;
-	//  ioc_local_lock (local);
-	frame->local = NULL;
-	iobref = iobref_new ();
+        //  ioc_local_lock (local);
+        frame->local = NULL;
+        iobref = iobref_new ();
         if (iobref == NULL) {
                 op_ret = -1;
                 gf_log (frame->this->name, GF_LOG_ERROR, "out of memory");
         }
 
-	if (list_empty (&local->fill_list)) {
-		gf_log (frame->this->name, GF_LOG_TRACE,
-			"frame(%p) has 0 entries in local->fill_list "
-			"(offset = %"PRId64" && size = %"GF_PRI_SIZET")",
-			frame, local->offset, local->size);
-	}
+        if (list_empty (&local->fill_list)) {
+                gf_log (frame->this->name, GF_LOG_TRACE,
+                        "frame(%p) has 0 entries in local->fill_list "
+                        "(offset = %"PRId64" && size = %"GF_PRI_SIZET")",
+                        frame, local->offset, local->size);
+        }
 
-	list_for_each_entry (fill, &local->fill_list, list) {
-		count += fill->count;
-	}
+        list_for_each_entry (fill, &local->fill_list, list) {
+                count += fill->count;
+        }
 
-	vector = GF_CALLOC (count, sizeof (*vector), gf_ioc_mt_iovec);
+        vector = GF_CALLOC (count, sizeof (*vector), gf_ioc_mt_iovec);
         if (vector == NULL) {
                 op_ret = -1;
 
                 gf_log (frame->this->name, GF_LOG_ERROR, "out of memory");
         }
 
-	list_for_each_entry_safe (fill, next, &local->fill_list, list) {
+        list_for_each_entry_safe (fill, next, &local->fill_list, list) {
                 if ((vector != NULL) &&  (iobref != NULL)) {
                         memcpy (((char *)vector) + copied,
                                 fill->vector,
@@ -733,22 +787,22 @@ ioc_frame_unwind (call_frame_t *frame)
                         iobref_merge (iobref, fill->iobref);
                 }
 
-		list_del (&fill->list);
-		iobref_unref (fill->iobref);
-		GF_FREE (fill->vector);
-		GF_FREE (fill);
-	}
+                list_del (&fill->list);
+                iobref_unref (fill->iobref);
+                GF_FREE (fill->vector);
+                GF_FREE (fill);
+        }
 
         if (op_ret != -1) {
                 op_ret = iov_length (vector, count);
         }
 
-	gf_log (frame->this->name, GF_LOG_TRACE,
-		"frame(%p) unwinding with op_ret=%d", frame, op_ret);
+        gf_log (frame->this->name, GF_LOG_TRACE,
+                "frame(%p) unwinding with op_ret=%d", frame, op_ret);
 
-	//  ioc_local_unlock (local);
+        //  ioc_local_unlock (local);
 
-	STACK_UNWIND_STRICT (readv, frame, op_ret, local->op_errno, vector,
+        STACK_UNWIND_STRICT (readv, frame, op_ret, local->op_errno, vector,
                              count, &stbuf, iobref);
 
         if (iobref != NULL) {
@@ -760,8 +814,8 @@ ioc_frame_unwind (call_frame_t *frame)
                 vector = NULL;
         }
 
-	pthread_mutex_destroy (&local->local_lock);
-	GF_FREE (local);
+        pthread_mutex_destroy (&local->local_lock);
+        GF_FREE (local);
 
         return;
 }
@@ -775,56 +829,104 @@ ioc_frame_unwind (call_frame_t *frame)
 void
 ioc_frame_return (call_frame_t *frame)
 {
-	ioc_local_t *local = NULL;
-	int32_t wait_count = 0;
+        ioc_local_t *local = NULL;
+        int32_t wait_count = 0;
 
         local = frame->local;
         GF_ASSERT (local->wait_count > 0);
 
-	ioc_local_lock (local);
-	{
-		wait_count = --local->wait_count;
-	}
-	ioc_local_unlock (local);
+        ioc_local_lock (local);
+        {
+                wait_count = --local->wait_count;
+        }
+        ioc_local_unlock (local);
 
-	if (!wait_count) {
-		ioc_frame_unwind (frame);
-	}
+        if (!wait_count) {
+                ioc_frame_unwind (frame);
+        }
 
-	return;
+        return;
 }
 
 /*
- * ioc_page_wakeup -
+ * __ioc_page_wakeup -
  * @page:
  *
  * to be called only when a frame is waiting on an in-transit page
  */
 ioc_waitq_t *
-ioc_page_wakeup (ioc_page_t *page)
+__ioc_page_wakeup (ioc_page_t *page)
 {
-	ioc_waitq_t  *waitq = NULL, *trav = NULL;
-	call_frame_t *frame = NULL;
-        int32_t      ret = -1;
+        ioc_waitq_t  *waitq = NULL, *trav = NULL;
+        call_frame_t *frame = NULL;
+        int32_t       ret   = -1;
 
-	waitq = page->waitq;
-	page->waitq = NULL;
+        waitq = page->waitq;
+        page->waitq = NULL;
 
-	page->ready = 1;
+        page->ready = 1;
 
-	gf_log (page->inode->table->xl->name, GF_LOG_TRACE,
-		"page is %p && waitq = %p", page, waitq);
+        gf_log (page->inode->table->xl->name, GF_LOG_TRACE,
+                "page is %p && waitq = %p", page, waitq);
 
-	for (trav = waitq; trav; trav = trav->next) {
-		frame = trav->data;
-		ret = ioc_frame_fill (page, frame, trav->pending_offset,
+        for (trav = waitq; trav; trav = trav->next) {
+                frame = trav->data;
+                ret = ioc_frame_fill (page, frame, trav->pending_offset,
                                       trav->pending_size);
                 if (ret == -1) {
                         break;
                 }
-	}
-	
-	return waitq;
+        }
+
+        return waitq;
+}
+
+
+/*
+ * ioc_page_error -
+ * @page:
+ * @op_ret:
+ * @op_errno:
+ *
+ */
+ioc_waitq_t *
+__ioc_page_error (ioc_page_t *page, int32_t op_ret, int32_t op_errno)
+{
+        ioc_waitq_t  *waitq = NULL, *trav = NULL;
+        call_frame_t *frame = NULL;
+        int64_t       ret   = 0;
+        ioc_table_t  *table = NULL;
+        ioc_local_t  *local = NULL;
+
+        waitq = page->waitq;
+        page->waitq = NULL;
+
+        gf_log (page->inode->table->xl->name, GF_LOG_DEBUG,
+                "page error for page = %p & waitq = %p", page, waitq);
+
+        for (trav = waitq; trav; trav = trav->next) {
+
+                frame = trav->data;
+
+                local = frame->local;
+                ioc_local_lock (local);
+                {
+                        if (local->op_ret != -1) {
+                                local->op_ret = op_ret;
+                                local->op_errno = op_errno;
+                        }
+                }
+                ioc_local_unlock (local);
+        }
+
+        table = page->inode->table;
+        ret = ioc_page_destroy (page);
+
+        if (ret != -1) {
+                table->cache_used -= ret;
+        }
+
+        return waitq;
 }
 
 
@@ -838,39 +940,18 @@ ioc_page_wakeup (ioc_page_t *page)
 ioc_waitq_t *
 ioc_page_error (ioc_page_t *page, int32_t op_ret, int32_t op_errno)
 {
-	ioc_waitq_t  *waitq = NULL, *trav = NULL;
-	call_frame_t *frame = NULL;
-	int64_t      ret = 0;
-	ioc_table_t  *table = NULL;
-	ioc_local_t  *local = NULL;
-
-	waitq = page->waitq;
-	page->waitq = NULL;
-  
-	gf_log (page->inode->table->xl->name, GF_LOG_DEBUG,
-		"page error for page = %p & waitq = %p", page, waitq);
-
-	for (trav = waitq; trav; trav = trav->next) {
-
-		frame = trav->data;
-
-		local = frame->local;
-		ioc_local_lock (local);
-		{
-			if (local->op_ret != -1) {
-				local->op_ret = op_ret;
-				local->op_errno = op_errno;
-			}
-		}
-		ioc_local_unlock (local);
-	}
-
-	table = page->inode->table;
-	ret = ioc_page_destroy (page);
-
-	if (ret != -1) {
-		table->cache_used -= ret;
-	}
-
-	return waitq;
+        ioc_waitq_t  *waitq = NULL;
+
+        if (page == NULL) {
+                goto out;
+        }
+
+        ioc_inode_lock (page->inode);
+        {
+                waitq = __ioc_page_error (page, op_ret, op_errno);
+        }
+        ioc_inode_unlock (page->inode);
+
+out:
+        return waitq;
 }