cluster/afr: whitespace cleanup

Signed-off-by: Amar Tumballi <amar@gluster.com>
Signed-off-by: Vijay Bellur <vijay@dev.gluster.com>

BUG: 2346 (Log message enhancements in GlusterFS - phase 1)
URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=2346

1 files changed, 272 insertions, 272 deletions

diff --git a/xlators/cluster/afr/src/afr-dir-read.c b/xlators/cluster/afr/src/afr-dir-read.c
index 19ddcbda762..59bd7872e9f 100644
--- a/xlators/cluster/afr/src/afr-dir-read.c
+++ b/xlators/cluster/afr/src/afr-dir-read.c
@@ -1,20 +1,20 @@
 /*
-   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 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/>.
+  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 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/>.
 */
 
 
@@ -98,8 +98,8 @@ afr_examine_dir_readdir_cbk (call_frame_t *frame, void *cookie,
                              xlator_t *this, int32_t op_ret, int32_t op_errno,
                              gf_dirent_t *entries)
 {
-	afr_private_t *    priv  = NULL;
-	afr_local_t *      local = NULL;
+        afr_private_t *    priv  = NULL;
+        afr_local_t *      local = NULL;
         afr_self_heal_t *  sh    = NULL;
 
         gf_dirent_t * entry = NULL;
@@ -166,7 +166,7 @@ out:
                                                            sizeof(sh_type_str));
                                 gf_log (this->name, GF_LOG_NORMAL,
                                         "%s self-heal triggered. path: %s, "
-                                         "reason: checksums of directory differ,"
+                                        "reason: checksums of directory differ,"
                                         " forced merge option set",
                                         sh_type_str, local->loc.path);
 
@@ -197,8 +197,8 @@ afr_examine_dir (call_frame_t *frame, xlator_t *this)
         priv  = this->private;
 
         local->cont.opendir.checksum = GF_CALLOC (priv->child_count,
-                                        sizeof (*local->cont.opendir.checksum),
-                                        gf_afr_mt_int32_t);
+                                                  sizeof (*local->cont.opendir.checksum),
+                                                  gf_afr_mt_int32_t);
 
         call_count = afr_up_children_count (priv->child_count, local->child_up);
 
@@ -223,15 +223,15 @@ afr_examine_dir (call_frame_t *frame, xlator_t *this)
 
 int32_t
 afr_opendir_cbk (call_frame_t *frame, void *cookie,
-		 xlator_t *this, int32_t op_ret, int32_t op_errno,
-		 fd_t *fd)
+                 xlator_t *this, int32_t op_ret, int32_t op_errno,
+                 fd_t *fd)
 {
         afr_private_t *priv              = NULL;
-	afr_local_t   *local             = NULL;
+        afr_local_t   *local             = NULL;
         int32_t        up_children_count = 0;
         int           ret                = -1;
 
-	int call_count = -1;
+        int call_count = -1;
 
         priv  = this->private;
         local = frame->local;
@@ -239,18 +239,18 @@ afr_opendir_cbk (call_frame_t *frame, void *cookie,
         up_children_count = afr_up_children_count (priv->child_count,
                                                    local->child_up);
 
-	LOCK (&frame->lock);
-	{
-		if (op_ret >= 0)
-			local->op_ret = op_ret;
+        LOCK (&frame->lock);
+        {
+                if (op_ret >= 0)
+                        local->op_ret = op_ret;
 
-		local->op_errno = op_errno;
-	}
-	UNLOCK (&frame->lock);
+                local->op_errno = op_errno;
+        }
+        UNLOCK (&frame->lock);
 
-	call_count = afr_frame_return (frame);
+        call_count = afr_frame_return (frame);
 
-	if (call_count == 0) {
+        if (call_count == 0) {
                 if (local->op_ret == 0) {
 
                         ret = afr_fd_ctx_set (this, local->fd);
@@ -286,79 +286,79 @@ afr_opendir_cbk (call_frame_t *frame, void *cookie,
                                                   local->op_errno, local->fd);
                         }
                 } else {
-out:
+                out:
                         AFR_STACK_UNWIND (opendir, frame, local->op_ret,
                                           local->op_errno, local->fd);
                 }
         }
 
-	return 0;
+        return 0;
 }
 
 
-int32_t 
+int32_t
 afr_opendir (call_frame_t *frame, xlator_t *this,
-	     loc_t *loc, fd_t *fd)
+             loc_t *loc, fd_t *fd)
 {
-	afr_private_t * priv        = NULL;
-	afr_local_t   * local       = NULL;
+        afr_private_t * priv        = NULL;
+        afr_local_t   * local       = NULL;
 
-	int             child_count = 0;
-	int             i           = 0;
+        int             child_count = 0;
+        int             i           = 0;
 
-	int ret = -1;
-	int call_count = -1;
+        int ret = -1;
+        int call_count = -1;
 
-	int32_t         op_ret   = -1;
-	int32_t         op_errno = 0;
+        int32_t         op_ret   = -1;
+        int32_t         op_errno = 0;
 
-	VALIDATE_OR_GOTO (frame, out);
-	VALIDATE_OR_GOTO (this, out);
-	VALIDATE_OR_GOTO (this->private, out);
+        VALIDATE_OR_GOTO (frame, out);
+        VALIDATE_OR_GOTO (this, out);
+        VALIDATE_OR_GOTO (this->private, out);
 
-	priv = this->private;
+        priv = this->private;
 
-	child_count = priv->child_count;
+        child_count = priv->child_count;
 
-	ALLOC_OR_GOTO (local, afr_local_t, out);
-	ret = AFR_LOCAL_INIT (local, priv);
-	if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-	}
+        ALLOC_OR_GOTO (local, afr_local_t, out);
+        ret = AFR_LOCAL_INIT (local, priv);
+        if (ret < 0) {
+                op_errno = -ret;
+                goto out;
+        }
 
         loc_copy (&local->loc, loc);
 
-	frame->local = local;
-	local->fd    = fd_ref (fd);
+        frame->local = local;
+        local->fd    = fd_ref (fd);
 
-	call_count = local->call_count;
-	
-	for (i = 0; i < child_count; i++) {
-		if (local->child_up[i]) {
-			STACK_WIND (frame, afr_opendir_cbk, 
-				    priv->children[i],
-				    priv->children[i]->fops->opendir,
-				    loc, fd);
+        call_count = local->call_count;
 
-			if (!--call_count)
-				break;
-		}
-	}
+        for (i = 0; i < child_count; i++) {
+                if (local->child_up[i]) {
+                        STACK_WIND (frame, afr_opendir_cbk,
+                                    priv->children[i],
+                                    priv->children[i]->fops->opendir,
+                                    loc, fd);
+
+                        if (!--call_count)
+                                break;
+                }
+        }
 
-	op_ret = 0;
+        op_ret = 0;
 out:
-	if (op_ret == -1) {
-		AFR_STACK_UNWIND (opendir, frame, op_ret, op_errno, fd);
-	}
+        if (op_ret == -1) {
+                AFR_STACK_UNWIND (opendir, frame, op_ret, op_errno, fd);
+        }
 
-	return 0;
+        return 0;
 }
 
 
 /**
  * Common algorithm for directory read calls:
- * 
+ *
  * - Try the fop on the first child that is up
  * - if we have failed due to ENOTCONN:
  *     try the next child
@@ -394,110 +394,110 @@ out:
 static void
 afr_remember_entries (gf_dirent_t *entries, fd_t *fd)
 {
-	struct entry_name *n       = NULL;
-	gf_dirent_t *      entry   = NULL;
+        struct entry_name *n       = NULL;
+        gf_dirent_t *      entry   = NULL;
 
-	int ret = 0;
+        int ret = 0;
 
-	uint64_t      ctx;
-	afr_fd_ctx_t *fd_ctx;
+        uint64_t      ctx;
+        afr_fd_ctx_t *fd_ctx;
 
-	ret = fd_ctx_get (fd, THIS, &ctx);
-	if (ret < 0) {
-		gf_log (THIS->name, GF_LOG_DEBUG,
-			"could not get fd ctx for fd=%p", fd);
-		return;
-	}
+        ret = fd_ctx_get (fd, THIS, &ctx);
+        if (ret < 0) {
+                gf_log (THIS->name, GF_LOG_DEBUG,
+                        "could not get fd ctx for fd=%p", fd);
+                return;
+        }
 
         fd_ctx = (afr_fd_ctx_t *)(long) ctx;
 
-	list_for_each_entry (entry, &entries->list, list) {
-		n = GF_CALLOC (1, sizeof (*n), gf_afr_mt_entry_name);
-		n->name = gf_strdup (entry->d_name);
-		INIT_LIST_HEAD (&n->list);
+        list_for_each_entry (entry, &entries->list, list) {
+                n = GF_CALLOC (1, sizeof (*n), gf_afr_mt_entry_name);
+                n->name = gf_strdup (entry->d_name);
+                INIT_LIST_HEAD (&n->list);
 
-		list_add (&n->list, &fd_ctx->entries);
-	}
+                list_add (&n->list, &fd_ctx->entries);
+        }
 }
 
 
 static off_t
 afr_filter_entries (gf_dirent_t *entries, fd_t *fd)
 {
-	gf_dirent_t *entry, *tmp;
-	int ret = 0;
+        gf_dirent_t *entry, *tmp;
+        int ret = 0;
 
-	uint64_t      ctx;
-	afr_fd_ctx_t *fd_ctx;
+        uint64_t      ctx;
+        afr_fd_ctx_t *fd_ctx;
 
-	off_t offset = 0;
+        off_t offset = 0;
 
-	ret = fd_ctx_get (fd, THIS, &ctx);
-	if (ret < 0) {
-		gf_log (THIS->name, GF_LOG_DEBUG,
-			"could not get fd ctx for fd=%p", fd);
-		return -1;
-	}
+        ret = fd_ctx_get (fd, THIS, &ctx);
+        if (ret < 0) {
+                gf_log (THIS->name, GF_LOG_DEBUG,
+                        "could not get fd ctx for fd=%p", fd);
+                return -1;
+        }
 
         fd_ctx = (afr_fd_ctx_t *)(long) ctx;
 
-	list_for_each_entry_safe (entry, tmp, &entries->list, list) {
-		offset = entry->d_off;
+        list_for_each_entry_safe (entry, tmp, &entries->list, list) {
+                offset = entry->d_off;
 
-		if (remembered_name (entry->d_name, &fd_ctx->entries)) {
-			list_del (&entry->list);
-			GF_FREE (entry);
-		}
-	}
+                if (remembered_name (entry->d_name, &fd_ctx->entries)) {
+                        list_del (&entry->list);
+                        GF_FREE (entry);
+                }
+        }
 
-	return offset;
+        return offset;
 }
 
 
 static void
 afr_forget_entries (fd_t *fd)
 {
-	struct entry_name *entry, *tmp;
-	int ret = 0;
+        struct entry_name *entry, *tmp;
+        int ret = 0;
 
-	uint64_t      ctx;
-	afr_fd_ctx_t *fd_ctx;
+        uint64_t      ctx;
+        afr_fd_ctx_t *fd_ctx;
 
-	ret = fd_ctx_get (fd, THIS, &ctx);
-	if (ret < 0) {
-		gf_log (THIS->name, GF_LOG_DEBUG,
-			"could not get fd ctx for fd=%p", fd);
-		return;
-	}
+        ret = fd_ctx_get (fd, THIS, &ctx);
+        if (ret < 0) {
+                gf_log (THIS->name, GF_LOG_DEBUG,
+                        "could not get fd ctx for fd=%p", fd);
+                return;
+        }
 
         fd_ctx = (afr_fd_ctx_t *)(long) ctx;
 
-	list_for_each_entry_safe (entry, tmp, &fd_ctx->entries, list) {
-		GF_FREE (entry->name);
-		list_del (&entry->list);
-		GF_FREE (entry);
-	}
+        list_for_each_entry_safe (entry, tmp, &fd_ctx->entries, list) {
+                GF_FREE (entry->name);
+                list_del (&entry->list);
+                GF_FREE (entry);
+        }
 }
 
 
 int32_t
 afr_readdir_cbk (call_frame_t *frame, void *cookie,
-		 xlator_t *this, int32_t op_ret, int32_t op_errno,
-		 gf_dirent_t *entries)
+                 xlator_t *this, int32_t op_ret, int32_t op_errno,
+                 gf_dirent_t *entries)
 {
-	afr_private_t * priv     = NULL;
-	afr_local_t *   local    = NULL;
+        afr_private_t * priv     = NULL;
+        afr_local_t *   local    = NULL;
 
         gf_dirent_t * entry = NULL;
         gf_dirent_t * tmp   = NULL;
 
         int child_index = -1;
 
-	priv     = this->private;
-	local = frame->local;
+        priv     = this->private;
+        local = frame->local;
         child_index = (long) cookie;
 
-	if (op_ret != -1) {
+        if (op_ret != -1) {
                 list_for_each_entry_safe (entry, tmp, &entries->list, list) {
                         entry->d_ino = afr_itransform (entry->d_ino,
                                                        priv->child_count,
@@ -509,11 +509,11 @@ afr_readdir_cbk (call_frame_t *frame, void *cookie,
                                 GF_FREE (entry);
                         }
                 }
-    	}
+        }
 
         AFR_STACK_UNWIND (readdir, frame, op_ret, op_errno, entries);
 
-	return 0;
+        return 0;
 }
 
 
@@ -537,7 +537,7 @@ afr_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         uint64_t      ctx    = 0;
         afr_fd_ctx_t *fd_ctx = NULL;
 
-	off_t offset = 0;
+        off_t offset = 0;
 
         priv     = this->private;
         children = priv->children;
@@ -546,88 +546,88 @@ afr_readdirp_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
         child_index = (long) cookie;
 
-	if (priv->strict_readdir) {
-		ret = fd_ctx_get (local->fd, this, &ctx);
-		if (ret < 0) {
-			gf_log (this->name, GF_LOG_DEBUG,
-				"could not get fd ctx for fd=%p", local->fd);
-			op_ret   = -1;
-			op_errno = -ret;
-			goto out;
-		}
-
-		fd_ctx = (afr_fd_ctx_t *)(long) ctx;
-
-		if (child_went_down (op_ret, op_errno)) {
-			if (all_tried (child_index, priv->child_count)) {
-				goto out;
-			}
-
-			call_child = ++child_index;
-
-			gf_log (this->name, GF_LOG_TRACE,
-				"starting readdir afresh on child %d, offset %"PRId64,
-				call_child, (uint64_t) 0);
-
-			fd_ctx->failed_over = _gf_true;
-
-			STACK_WIND_COOKIE (frame, afr_readdirp_cbk,
-					   (void *) (long) call_child,
-					   children[call_child],
-					   children[call_child]->fops->readdirp, local->fd,
-					   local->cont.readdir.size, 0);
-			return 0;
-		}
-	}
-
-	if (op_ret != -1) {
-		list_for_each_entry_safe (entry, tmp, &entries->list, list) {
-			inum = afr_itransform (entry->d_ino, priv->child_count,
-					       child_index);
-			entry->d_ino = inum;
-			inum  = afr_itransform (entry->d_stat.ia_ino,
-						priv->child_count, child_index);
-			entry->d_stat.ia_ino = inum;
-
-			if ((local->fd->inode == local->fd->inode->table->root)
-			    && !strcmp (entry->d_name, GF_REPLICATE_TRASH_DIR)) {
-				list_del_init (&entry->list);
-				GF_FREE (entry);
-			}
-		}
-	}
-
-	if (priv->strict_readdir) {
-		if (fd_ctx->failed_over) {
-			if (list_empty (&entries->list)) {
-				goto out;
-			}
-
-			offset = afr_filter_entries (entries, local->fd);
-
-			afr_remember_entries (entries, local->fd);
-
-			if (list_empty (&entries->list)) {
-				/* All the entries we got were duplicate. We
-				   shouldn't send an empty list now, because
-				   that'll make the application stop reading. So
-				   try to get more entries */
-
-				gf_log (this->name, GF_LOG_TRACE,
-					"trying to fetch non-duplicate entries from offset %"PRId64", child %s",
-					offset, children[child_index]->name);
-
-				STACK_WIND_COOKIE (frame, afr_readdirp_cbk,
-						   (void *) (long) child_index,
-						   children[child_index],
-						   children[child_index]->fops->readdirp,
-						   local->fd, local->cont.readdir.size, offset);
-				return 0;
-			}
-		} else {
-			afr_remember_entries (entries, local->fd);
-		}
-	}
+        if (priv->strict_readdir) {
+                ret = fd_ctx_get (local->fd, this, &ctx);
+                if (ret < 0) {
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "could not get fd ctx for fd=%p", local->fd);
+                        op_ret   = -1;
+                        op_errno = -ret;
+                        goto out;
+                }
+
+                fd_ctx = (afr_fd_ctx_t *)(long) ctx;
+
+                if (child_went_down (op_ret, op_errno)) {
+                        if (all_tried (child_index, priv->child_count)) {
+                                goto out;
+                        }
+
+                        call_child = ++child_index;
+
+                        gf_log (this->name, GF_LOG_TRACE,
+                                "starting readdir afresh on child %d, offset %"PRId64,
+                                call_child, (uint64_t) 0);
+
+                        fd_ctx->failed_over = _gf_true;
+
+                        STACK_WIND_COOKIE (frame, afr_readdirp_cbk,
+                                           (void *) (long) call_child,
+                                           children[call_child],
+                                           children[call_child]->fops->readdirp, local->fd,
+                                           local->cont.readdir.size, 0);
+                        return 0;
+                }
+        }
+
+        if (op_ret != -1) {
+                list_for_each_entry_safe (entry, tmp, &entries->list, list) {
+                        inum = afr_itransform (entry->d_ino, priv->child_count,
+                                               child_index);
+                        entry->d_ino = inum;
+                        inum  = afr_itransform (entry->d_stat.ia_ino,
+                                                priv->child_count, child_index);
+                        entry->d_stat.ia_ino = inum;
+
+                        if ((local->fd->inode == local->fd->inode->table->root)
+                            && !strcmp (entry->d_name, GF_REPLICATE_TRASH_DIR)) {
+                                list_del_init (&entry->list);
+                                GF_FREE (entry);
+                        }
+                }
+        }
+
+        if (priv->strict_readdir) {
+                if (fd_ctx->failed_over) {
+                        if (list_empty (&entries->list)) {
+                                goto out;
+                        }
+
+                        offset = afr_filter_entries (entries, local->fd);
+
+                        afr_remember_entries (entries, local->fd);
+
+                        if (list_empty (&entries->list)) {
+                                /* All the entries we got were duplicate. We
+                                   shouldn't send an empty list now, because
+                                   that'll make the application stop reading. So
+                                   try to get more entries */
+
+                                gf_log (this->name, GF_LOG_TRACE,
+                                        "trying to fetch non-duplicate entries from offset %"PRId64", child %s",
+                                        offset, children[child_index]->name);
+
+                                STACK_WIND_COOKIE (frame, afr_readdirp_cbk,
+                                                   (void *) (long) child_index,
+                                                   children[child_index],
+                                                   children[child_index]->fops->readdirp,
+                                                   local->fd, local->cont.readdir.size, offset);
+                                return 0;
+                        }
+                } else {
+                        afr_remember_entries (entries, local->fd);
+                }
+        }
 
 out:
         AFR_STACK_UNWIND (readdirp, frame, op_ret, op_errno, entries);
@@ -638,70 +638,70 @@ out:
 
 int32_t
 afr_do_readdir (call_frame_t *frame, xlator_t *this,
-	        fd_t *fd, size_t size, off_t offset, int whichop)
+                fd_t *fd, size_t size, off_t offset, int whichop)
 {
-	afr_private_t * priv       = NULL;
-	xlator_t **     children   = NULL;
-	int             call_child = 0;
-	afr_local_t     *local     = NULL;
+        afr_private_t * priv       = NULL;
+        xlator_t **     children   = NULL;
+        int             call_child = 0;
+        afr_local_t     *local     = NULL;
 
         uint64_t      ctx;
         afr_fd_ctx_t *fd_ctx;
 
-	int ret = -1;
+        int ret = -1;
 
-	int32_t op_ret   = -1;
-	int32_t op_errno = 0;
+        int32_t op_ret   = -1;
+        int32_t op_errno = 0;
 
-	VALIDATE_OR_GOTO (frame, out);
-	VALIDATE_OR_GOTO (this, out);
-	VALIDATE_OR_GOTO (this->private, out);
+        VALIDATE_OR_GOTO (frame, out);
+        VALIDATE_OR_GOTO (this, out);
+        VALIDATE_OR_GOTO (this->private, out);
 
-	priv     = this->private;
-	children = priv->children;
+        priv     = this->private;
+        children = priv->children;
 
-	ALLOC_OR_GOTO (local, afr_local_t, out);
-	ret = AFR_LOCAL_INIT (local, priv);
-	if (ret < 0) {
-		op_errno = -ret;
-		goto out;
-	}
+        ALLOC_OR_GOTO (local, afr_local_t, out);
+        ret = AFR_LOCAL_INIT (local, priv);
+        if (ret < 0) {
+                op_errno = -ret;
+                goto out;
+        }
 
-	frame->local = local;
+        frame->local = local;
 
-	call_child = afr_first_up_child (priv);
-	if (call_child == -1) {
-		op_errno = ENOTCONN;
-		gf_log (this->name, GF_LOG_DEBUG,
-			"no child is up");
-		goto out;
-	}
+        call_child = afr_first_up_child (priv);
+        if (call_child == -1) {
+                op_errno = ENOTCONN;
+                gf_log (this->name, GF_LOG_DEBUG,
+                        "no child is up");
+                goto out;
+        }
 
         local->fd                  = fd_ref (fd);
         local->cont.readdir.size   = size;
 
-	if (priv->strict_readdir) {
-		ret = fd_ctx_get (fd, this, &ctx);
-		if (ret < 0) {
-			gf_log (this->name, GF_LOG_DEBUG,
-				"could not get fd ctx for fd=%p", fd);
-			op_errno = -ret;
-			goto out;
-		}
+        if (priv->strict_readdir) {
+                ret = fd_ctx_get (fd, this, &ctx);
+                if (ret < 0) {
+                        gf_log (this->name, GF_LOG_DEBUG,
+                                "could not get fd ctx for fd=%p", fd);
+                        op_errno = -ret;
+                        goto out;
+                }
 
-		fd_ctx = (afr_fd_ctx_t *)(long) ctx;
+                fd_ctx = (afr_fd_ctx_t *)(long) ctx;
 
-		if (fd_ctx->last_tried != call_child) {
-			gf_log (this->name, GF_LOG_TRACE,
-				"first up child has changed from %d to %d, restarting readdir from offset 0",
-				fd_ctx->last_tried, call_child);
+                if (fd_ctx->last_tried != call_child) {
+                        gf_log (this->name, GF_LOG_TRACE,
+                                "first up child has changed from %d to %d, restarting readdir from offset 0",
+                                fd_ctx->last_tried, call_child);
 
-			fd_ctx->failed_over = _gf_true;
-			offset = 0;
-		}
+                        fd_ctx->failed_over = _gf_true;
+                        offset = 0;
+                }
 
-		fd_ctx->last_tried = call_child;
-	}
+                fd_ctx->last_tried = call_child;
+        }
 
         if (whichop == GF_FOP_READDIR)
                 STACK_WIND_COOKIE (frame, afr_readdir_cbk,
@@ -716,12 +716,12 @@ afr_do_readdir (call_frame_t *frame, xlator_t *this,
                                    children[call_child]->fops->readdirp, fd,
                                    size, offset);
 
-	op_ret = 0;
+        op_ret = 0;
 out:
-	if (op_ret == -1) {
-		AFR_STACK_UNWIND (readdir, frame, op_ret, op_errno, NULL);
-	}
-	return 0;
+        if (op_ret == -1) {
+                AFR_STACK_UNWIND (readdir, frame, op_ret, op_errno, NULL);
+        }
+        return 0;
 }
 
 
@@ -746,8 +746,8 @@ afr_readdirp (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
 int32_t
 afr_releasedir (xlator_t *this, fd_t *fd)
 {
-	afr_forget_entries (fd);
+        afr_forget_entries (fd);
         afr_cleanup_fd_ctx (this, fd);
 
-	return 0;
+        return 0;
 }