libgfapi: Fixed few memory leaks in glfs_h_getxattr, glfs_h_setxattr calls.

          Also replaced the tabs with spaces in that entire file.

Change-Id: Iee6dc031d27fe8d26caf90736d4b2ac7bc8c5206
BUG: 1089414
Signed-off-by: Soumya Koduri <skoduri@redhat.com>
Reviewed-on: http://review.gluster.org/7841
Reviewed-by: Raghavendra G <rgowdapp@redhat.com>
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Meghana M <mmadhusu@redhat.com>
Reviewed-by: Vijay Bellur <vbellur@redhat.com>

1 files changed, 1187 insertions, 1182 deletions

diff --git a/api/src/glfs-handleops.c b/api/src/glfs-handleops.c
index 247b8aebf8b..e3df8c00b1a 100644
--- a/api/src/glfs-handleops.c
+++ b/api/src/glfs-handleops.c
@@ -17,932 +17,937 @@
 
 static void
 glfs_iatt_from_stat (struct stat *stat, int valid, struct iatt *iatt,
-		     int *glvalid)
+                     int *glvalid)
 {
-	/* validate in args */
-	if ((stat == NULL) || (iatt == NULL) || (glvalid == NULL)) {
-		errno = EINVAL;
-		return;
-	}
-
-	*glvalid = 0;
-
-	if (valid & GFAPI_SET_ATTR_MODE) {
-		iatt->ia_prot = ia_prot_from_st_mode (stat->st_mode);
-		*glvalid |= GF_SET_ATTR_MODE;
-	}
-
-	if (valid & GFAPI_SET_ATTR_UID) {
-		iatt->ia_uid = stat->st_uid;
-		*glvalid |= GF_SET_ATTR_UID;
-	}
-
-	if (valid & GFAPI_SET_ATTR_GID) {
-		iatt->ia_gid = stat->st_gid;
-		*glvalid |= GF_SET_ATTR_GID;
-	}
-
-	if (valid & GFAPI_SET_ATTR_ATIME) {
-		iatt->ia_atime = stat->st_atime;
-		iatt->ia_atime_nsec = ST_ATIM_NSEC (stat);
-		*glvalid |= GF_SET_ATTR_ATIME;
-	}
-
-	if (valid & GFAPI_SET_ATTR_MTIME) {
-		iatt->ia_mtime = stat->st_mtime;
-		iatt->ia_mtime_nsec = ST_MTIM_NSEC (stat);
-		*glvalid |= GF_SET_ATTR_MTIME;
-	}
-
-	return;
+        /* validate in args */
+        if ((stat == NULL) || (iatt == NULL) || (glvalid == NULL)) {
+                errno = EINVAL;
+                return;
+        }
+
+        *glvalid = 0;
+
+        if (valid & GFAPI_SET_ATTR_MODE) {
+                iatt->ia_prot = ia_prot_from_st_mode (stat->st_mode);
+                *glvalid |= GF_SET_ATTR_MODE;
+        }
+
+        if (valid & GFAPI_SET_ATTR_UID) {
+                iatt->ia_uid = stat->st_uid;
+                *glvalid |= GF_SET_ATTR_UID;
+        }
+
+        if (valid & GFAPI_SET_ATTR_GID) {
+                iatt->ia_gid = stat->st_gid;
+                *glvalid |= GF_SET_ATTR_GID;
+        }
+
+        if (valid & GFAPI_SET_ATTR_ATIME) {
+                iatt->ia_atime = stat->st_atime;
+                iatt->ia_atime_nsec = ST_ATIM_NSEC (stat);
+                *glvalid |= GF_SET_ATTR_ATIME;
+        }
+
+        if (valid & GFAPI_SET_ATTR_MTIME) {
+                iatt->ia_mtime = stat->st_mtime;
+                iatt->ia_mtime_nsec = ST_MTIM_NSEC (stat);
+                *glvalid |= GF_SET_ATTR_MTIME;
+        }
+
+        return;
 }
 
 struct glfs_object *
 glfs_h_lookupat (struct glfs *fs, struct glfs_object *parent,
-		 const char *path, struct stat *stat)
+                 const char *path, struct stat *stat)
 {
-	int                      ret = 0;
-	xlator_t                *subvol = NULL;
-	inode_t                 *inode = NULL;
-	struct iatt              iatt = {0, };
-	struct glfs_object      *object = NULL;
-	loc_t                    loc = {0, };
-
-	/* validate in args */
-	if ((fs == NULL) || (path == NULL)) {
-		errno = EINVAL;
-		return NULL;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	if (parent) {
-		inode = glfs_resolve_inode (fs, subvol, parent);
-		if (!inode) {
-			errno = ESTALE;
-			goto out;
-		}
-	}
-
-	/* fop/op */
-	ret = glfs_resolve_at (fs, subvol, inode, path, &loc, &iatt,
-			       0 /*TODO: links? */, 0);
-
-	/* populate out args */
-	if (!ret) {
-		if (stat)
-			glfs_iatt_to_stat (fs, &iatt, stat);
-
-		ret = glfs_create_object (&loc, &object);
-	}
+        int                      ret = 0;
+        xlator_t                *subvol = NULL;
+        inode_t                 *inode = NULL;
+        struct iatt              iatt = {0, };
+        struct glfs_object      *object = NULL;
+        loc_t                    loc = {0, };
+
+        /* validate in args */
+        if ((fs == NULL) || (path == NULL)) {
+                errno = EINVAL;
+                return NULL;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        if (parent) {
+                inode = glfs_resolve_inode (fs, subvol, parent);
+                if (!inode) {
+                        errno = ESTALE;
+                        goto out;
+                }
+        }
+
+        /* fop/op */
+        ret = glfs_resolve_at (fs, subvol, inode, path, &loc, &iatt,
+                               0 /*TODO: links? */, 0);
+
+        /* populate out args */
+        if (!ret) {
+                if (stat)
+                        glfs_iatt_to_stat (fs, &iatt, stat);
+
+                ret = glfs_create_object (&loc, &object);
+        }
 
 out:
-	loc_wipe (&loc);
+        loc_wipe (&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return object;
+        return object;
 }
 
 int
 glfs_h_stat (struct glfs *fs, struct glfs_object *object, struct stat *stat)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	inode_t         *inode = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-
-	/* validate in args */
-	if ((fs == NULL) || (object == NULL)) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, object);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	/* populate loc */
-	GLFS_LOC_FILL_INODE (inode, loc, out);
-
-	/* fop/op */
-	ret = syncop_stat (subvol, &loc, &iatt);
+        int              ret = -1;
+        xlator_t        *subvol = NULL;
+        inode_t         *inode = NULL;
+        loc_t            loc = {0, };
+        struct iatt      iatt = {0, };
+
+        /* validate in args */
+        if ((fs == NULL) || (object == NULL)) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, object);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        /* populate loc */
+        GLFS_LOC_FILL_INODE (inode, loc, out);
+
+        /* fop/op */
+        ret = syncop_stat (subvol, &loc, &iatt);
         DECODE_SYNCOP_ERR (ret);
 
-	/* populate out args */
-	if (!ret && stat) {
-		glfs_iatt_to_stat (fs, &iatt, stat);
-	}
+        /* populate out args */
+        if (!ret && stat) {
+                glfs_iatt_to_stat (fs, &iatt, stat);
+        }
 out:
-	loc_wipe (&loc);
+        loc_wipe (&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return ret;
+        return ret;
 }
 
 int
 glfs_h_getattrs (struct glfs *fs, struct glfs_object *object, struct stat *stat)
 {
-	int                      ret = 0;
-	xlator_t                *subvol = NULL;
-	inode_t                 *inode = NULL;
-	struct iatt              iatt = {0, };
-
-	/* validate in args */
-	if ((fs == NULL) || (object == NULL)) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, object);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	/* fop/op */
-	ret = glfs_resolve_base (fs, subvol, inode, &iatt);
-
-	/* populate out args */
-	if (!ret && stat) {
-		glfs_iatt_to_stat (fs, &iatt, stat);
-	}
+        int                      ret = 0;
+        xlator_t                *subvol = NULL;
+        inode_t                 *inode = NULL;
+        struct iatt              iatt = {0, };
+
+        /* validate in args */
+        if ((fs == NULL) || (object == NULL)) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, object);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        /* fop/op */
+        ret = glfs_resolve_base (fs, subvol, inode, &iatt);
+
+        /* populate out args */
+        if (!ret && stat) {
+                glfs_iatt_to_stat (fs, &iatt, stat);
+        }
 
 out:
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return ret;
+        return ret;
 }
 
 int
 glfs_h_getxattrs (struct glfs *fs, struct glfs_object *object, const char *name,
-		  void *value, size_t size)
+                  void *value, size_t size)
 {
-	int		 ret = 0;
-	xlator_t        *subvol = NULL;
-	inode_t         *inode = NULL;
-	loc_t            loc = {0, };
-	dict_t		*xattr = NULL;
-
-	/* validate in args */
-	if ((fs == NULL) || (object == NULL)) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, object);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	/* populate loc */
-	GLFS_LOC_FILL_INODE (inode, loc, out);
-
-	ret = syncop_getxattr (subvol, &loc, &xattr, name);
+        int                 ret = 0;
+        xlator_t        *subvol = NULL;
+        inode_t         *inode = NULL;
+        loc_t            loc = {0, };
+        dict_t                *xattr = NULL;
+
+        /* validate in args */
+        if ((fs == NULL) || (object == NULL)) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, object);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        /* populate loc */
+        GLFS_LOC_FILL_INODE (inode, loc, out);
+
+        ret = syncop_getxattr (subvol, &loc, &xattr, name);
         DECODE_SYNCOP_ERR (ret);
 
-	if (ret)
-		goto out;
+        if (ret)
+                goto out;
 
-	ret = glfs_getxattr_process (value, size, xattr, name);
+        ret = glfs_getxattr_process (value, size, xattr, name);
 
 out:
-	if (inode)
-		inode_unref (inode);
+        loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+        if (inode)
+                inode_unref (inode);
 
-	return ret;
+        glfs_subvol_done (fs, subvol);
+
+        return ret;
 }
 
 int
 glfs_h_setattrs (struct glfs *fs, struct glfs_object *object, struct stat *stat,
-		 int valid)
+                 int valid)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	inode_t         *inode = NULL;
-	loc_t            loc = {0, };
-	struct iatt      iatt = {0, };
-	int              glvalid = 0;
-
-	/* validate in args */
-	if ((fs == NULL) || (object == NULL) || (stat == NULL)) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, object);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	/* map valid masks from in args */
-	glfs_iatt_from_stat (stat, valid, &iatt, &glvalid);
-
-	/* populate loc */
-	GLFS_LOC_FILL_INODE (inode, loc, out);
-
-	/* fop/op */
-	ret = syncop_setattr (subvol, &loc, &iatt, glvalid, 0, 0);
+        int              ret = -1;
+        xlator_t        *subvol = NULL;
+        inode_t         *inode = NULL;
+        loc_t            loc = {0, };
+        struct iatt      iatt = {0, };
+        int              glvalid = 0;
+
+        /* validate in args */
+        if ((fs == NULL) || (object == NULL) || (stat == NULL)) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, object);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        /* map valid masks from in args */
+        glfs_iatt_from_stat (stat, valid, &iatt, &glvalid);
+
+        /* populate loc */
+        GLFS_LOC_FILL_INODE (inode, loc, out);
+
+        /* fop/op */
+        ret = syncop_setattr (subvol, &loc, &iatt, glvalid, 0, 0);
         DECODE_SYNCOP_ERR (ret);
 out:
-	loc_wipe (&loc);
+        loc_wipe (&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return ret;
+        return ret;
 }
 
 int
 glfs_h_setxattrs (struct glfs *fs, struct glfs_object *object, const char *name,
-		 const void *value, size_t size, int flags)
+                 const void *value, size_t size, int flags)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	inode_t         *inode = NULL;
-	loc_t            loc = {0, };
-	dict_t          *xattr = NULL;
-
-	/* validate in args */
-	if ((fs == NULL) || (object == NULL) ||
-		 (name == NULL) || (value == NULL)) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, object);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	xattr = dict_for_key_value (name, value, size);
-	if (!xattr) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	/* populate loc */
-	GLFS_LOC_FILL_INODE (inode, loc, out);
-
-	/* fop/op */
-	ret = syncop_setxattr (subvol, &loc, xattr, flags);
+        int              ret = -1;
+        xlator_t        *subvol = NULL;
+        inode_t         *inode = NULL;
+        loc_t            loc = {0, };
+        dict_t          *xattr = NULL;
+
+        /* validate in args */
+        if ((fs == NULL) || (object == NULL) ||
+                 (name == NULL) || (value == NULL)) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, object);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        xattr = dict_for_key_value (name, value, size);
+        if (!xattr) {
+                ret = -1;
+                errno = ENOMEM;
+                goto out;
+        }
+
+        /* populate loc */
+        GLFS_LOC_FILL_INODE (inode, loc, out);
+
+        /* fop/op */
+        ret = syncop_setxattr (subvol, &loc, xattr, flags);
         DECODE_SYNCOP_ERR (ret);
 
 out:
-	loc_wipe (&loc);
+        loc_wipe (&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	glfs_subvol_done (fs, subvol);
+        if (xattr)
+                dict_unref (xattr);
 
-	return ret;
+        glfs_subvol_done (fs, subvol);
+
+        return ret;
 }
 
 int
 glfs_h_removexattrs (struct glfs *fs, struct glfs_object *object, const char *name)
 {
-	int              ret = -1;
-	xlator_t        *subvol = NULL;
-	inode_t         *inode = NULL;
-	loc_t            loc = {0, };
-
-	/* validate in args */
-	if ((fs == NULL) || (object == NULL) || (name == NULL)) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, object);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	/* populate loc */
-	GLFS_LOC_FILL_INODE (inode, loc, out);
-
-	/* fop/op */
-	ret = syncop_removexattr (subvol, &loc, name, 0);
+        int              ret = -1;
+        xlator_t        *subvol = NULL;
+        inode_t         *inode = NULL;
+        loc_t            loc = {0, };
+
+        /* validate in args */
+        if ((fs == NULL) || (object == NULL) || (name == NULL)) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, object);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        /* populate loc */
+        GLFS_LOC_FILL_INODE (inode, loc, out);
+
+        /* fop/op */
+        ret = syncop_removexattr (subvol, &loc, name, 0);
         DECODE_SYNCOP_ERR (ret);
 
 out:
-	loc_wipe (&loc);
+        loc_wipe (&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return ret;
+        return ret;
 }
 
 struct glfs_fd *
 glfs_h_open (struct glfs *fs, struct glfs_object *object, int flags)
 {
-	int              ret = -1;
-	struct glfs_fd  *glfd = NULL;
-	xlator_t        *subvol = NULL;
-	inode_t         *inode = NULL;
-	loc_t            loc = {0, };
-
-	/* validate in args */
-	if ((fs == NULL) || (object == NULL)) {
-		errno = EINVAL;
-		return NULL;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, object);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	/* check types to open */
-	if (IA_ISDIR (inode->ia_type)) {
-		ret = -1;
-		errno = EISDIR;
-		goto out;
-	}
-
-	if (!IA_ISREG (inode->ia_type)) {
-		ret = -1;
-		errno = EINVAL;
-		goto out;
-	}
-
-	glfd = glfs_fd_new (fs);
-	if (!glfd) {
-		errno = ENOMEM;
-		goto out;
-	}
-
-	glfd->fd = fd_create (inode, getpid());
-	if (!glfd->fd) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	/* populate loc */
-	GLFS_LOC_FILL_INODE (inode, loc, out);
-
-	/* fop/op */
-	ret = syncop_open (subvol, &loc, flags, glfd->fd);
+        int              ret = -1;
+        struct glfs_fd  *glfd = NULL;
+        xlator_t        *subvol = NULL;
+        inode_t         *inode = NULL;
+        loc_t            loc = {0, };
+
+        /* validate in args */
+        if ((fs == NULL) || (object == NULL)) {
+                errno = EINVAL;
+                return NULL;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, object);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        /* check types to open */
+        if (IA_ISDIR (inode->ia_type)) {
+                ret = -1;
+                errno = EISDIR;
+                goto out;
+        }
+
+        if (!IA_ISREG (inode->ia_type)) {
+                ret = -1;
+                errno = EINVAL;
+                goto out;
+        }
+
+        glfd = glfs_fd_new (fs);
+        if (!glfd) {
+                errno = ENOMEM;
+                goto out;
+        }
+
+        glfd->fd = fd_create (inode, getpid());
+        if (!glfd->fd) {
+                ret = -1;
+                errno = ENOMEM;
+                goto out;
+        }
+
+        /* populate loc */
+        GLFS_LOC_FILL_INODE (inode, loc, out);
+
+        /* fop/op */
+        ret = syncop_open (subvol, &loc, flags, glfd->fd);
         DECODE_SYNCOP_ERR (ret);
 
 out:
-	loc_wipe (&loc);
+        loc_wipe (&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	if (ret && glfd) {
-		glfs_fd_destroy (glfd);
-		glfd = NULL;
-	} else {
-		glfd->fd->flags = flags;
-		fd_bind (glfd->fd);
-		glfs_fd_bind (glfd);
-	}
+        if (ret && glfd) {
+                glfs_fd_destroy (glfd);
+                glfd = NULL;
+        } else {
+                glfd->fd->flags = flags;
+                fd_bind (glfd->fd);
+                glfs_fd_bind (glfd);
+        }
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return glfd;
+        return glfd;
 }
 
 struct glfs_object *
 glfs_h_creat (struct glfs *fs, struct glfs_object *parent, const char *path,
-	      int flags, mode_t mode, struct stat *stat)
+              int flags, mode_t mode, struct stat *stat)
 {
-	int                 ret = -1;
-	struct glfs_fd     *glfd = NULL;
-	xlator_t           *subvol = NULL;
-	inode_t            *inode = NULL;
-	loc_t               loc = {0, };
-	struct iatt         iatt = {0, };
-	uuid_t              gfid;
-	dict_t             *xattr_req = NULL;
-	struct glfs_object *object = NULL;
-
-	/* validate in args */
-	if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
-		errno = EINVAL;
-		return NULL;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, parent);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	xattr_req = dict_new ();
-	if (!xattr_req) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	uuid_generate (gfid);
-	ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-	if (ret) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path);
-
-	glfd = glfs_fd_new (fs);
-	if (!glfd)
-		goto out;
+        int                 ret = -1;
+        struct glfs_fd     *glfd = NULL;
+        xlator_t           *subvol = NULL;
+        inode_t            *inode = NULL;
+        loc_t               loc = {0, };
+        struct iatt         iatt = {0, };
+        uuid_t              gfid;
+        dict_t             *xattr_req = NULL;
+        struct glfs_object *object = NULL;
+
+        /* validate in args */
+        if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
+                errno = EINVAL;
+                return NULL;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, parent);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        xattr_req = dict_new ();
+        if (!xattr_req) {
+                ret = -1;
+                errno = ENOMEM;
+                goto out;
+        }
+
+        uuid_generate (gfid);
+        ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
+        if (ret) {
+                ret = -1;
+                errno = ENOMEM;
+                goto out;
+        }
+
+        GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path);
+
+        glfd = glfs_fd_new (fs);
+        if (!glfd)
+                goto out;
+
+        glfd->fd = fd_create (loc.inode, getpid());
+        if (!glfd->fd) {
+                ret = -1;
+                errno = ENOMEM;
+                goto out;
+        }
+
+        /* fop/op */
+        ret = syncop_create (subvol, &loc, flags, mode, glfd->fd,
+                             xattr_req, &iatt);
+        DECODE_SYNCOP_ERR (ret);
 
-	glfd->fd = fd_create (loc.inode, getpid());
-	if (!glfd->fd) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+        /* populate out args */
+        if (ret == 0) {
+                /* TODO: If the inode existed in the cache (say file already
+                   exists), then the glfs_loc_link will not update the
+                   loc.inode, as a result we will have a 0000 GFID that we
+                   would copy out to the object, this needs to be fixed.
+                */
+                ret = glfs_loc_link (&loc, &iatt);
+                if (ret != 0) {
+                        goto out;
+                }
 
-	/* fop/op */
-	ret = syncop_create (subvol, &loc, flags, mode, glfd->fd,
-			     xattr_req, &iatt);
-        DECODE_SYNCOP_ERR (ret);
+                if (stat)
+                        glfs_iatt_to_stat (fs, &iatt, stat);
 
-	/* populate out args */
-	if (ret == 0) {
-		/* TODO: If the inode existed in the cache (say file already
-		   exists), then the glfs_loc_link will not update the
-		   loc.inode, as a result we will have a 0000 GFID that we
-		   would copy out to the object, this needs to be fixed.
-		*/
-		ret = glfs_loc_link (&loc, &iatt);
-		if (ret != 0) {
-			goto out;
-		}
-
-		if (stat)
-			glfs_iatt_to_stat (fs, &iatt, stat);
-
-		ret = glfs_create_object (&loc, &object);
-	}
+                ret = glfs_create_object (&loc, &object);
+        }
 
 out:
-	if (ret && object != NULL) {
-		glfs_h_close (object);
-		object = NULL;
-	}
+        if (ret && object != NULL) {
+                glfs_h_close (object);
+                object = NULL;
+        }
 
-	loc_wipe(&loc);
+        loc_wipe(&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	if (xattr_req)
-		dict_unref (xattr_req);
+        if (xattr_req)
+                dict_unref (xattr_req);
 
-	if (glfd) {
-		glfs_fd_destroy (glfd);
-		glfd = NULL;
-	}
+        if (glfd) {
+                glfs_fd_destroy (glfd);
+                glfd = NULL;
+        }
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return object;
+        return object;
 }
 
 struct glfs_object *
 glfs_h_mkdir (struct glfs *fs, struct glfs_object *parent, const char *path,
-	      mode_t mode, struct stat *stat)
+              mode_t mode, struct stat *stat)
 {
-	int                 ret = -1;
-	xlator_t           *subvol = NULL;
-	inode_t            *inode = NULL;
-	loc_t               loc = {0, };
-	struct iatt         iatt = {0, };
-	uuid_t              gfid;
-	dict_t             *xattr_req = NULL;
-	struct glfs_object *object = NULL;
-
-	/* validate in args */
-	if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
-		errno = EINVAL;
-		return NULL;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, parent);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	xattr_req = dict_new ();
-	if (!xattr_req) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	uuid_generate (gfid);
-	ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-	if (ret) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path);
-
-	/* fop/op */
-	ret = syncop_mkdir (subvol, &loc, mode, xattr_req, &iatt);
+        int                 ret = -1;
+        xlator_t           *subvol = NULL;
+        inode_t            *inode = NULL;
+        loc_t               loc = {0, };
+        struct iatt         iatt = {0, };
+        uuid_t              gfid;
+        dict_t             *xattr_req = NULL;
+        struct glfs_object *object = NULL;
+
+        /* validate in args */
+        if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
+                errno = EINVAL;
+                return NULL;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, parent);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        xattr_req = dict_new ();
+        if (!xattr_req) {
+                ret = -1;
+                errno = ENOMEM;
+                goto out;
+        }
+
+        uuid_generate (gfid);
+        ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
+        if (ret) {
+                ret = -1;
+                errno = ENOMEM;
+                goto out;
+        }
+
+        GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path);
+
+        /* fop/op */
+        ret = syncop_mkdir (subvol, &loc, mode, xattr_req, &iatt);
         DECODE_SYNCOP_ERR (ret);
 
-	/* populate out args */
-	if ( ret == 0 )  {
-		ret = glfs_loc_link (&loc, &iatt);
-		if (ret != 0) {
-			goto out;
-		}
+        /* populate out args */
+        if ( ret == 0 )  {
+                ret = glfs_loc_link (&loc, &iatt);
+                if (ret != 0) {
+                        goto out;
+                }
 
-		if (stat)
-			glfs_iatt_to_stat (fs, &iatt, stat);
+                if (stat)
+                        glfs_iatt_to_stat (fs, &iatt, stat);
 
-		ret = glfs_create_object (&loc, &object);
-	}
+                ret = glfs_create_object (&loc, &object);
+        }
 
 out:
-	if (ret && object != NULL) {
-		glfs_h_close (object);
-		object = NULL;
-	}
+        if (ret && object != NULL) {
+                glfs_h_close (object);
+                object = NULL;
+        }
 
-	loc_wipe(&loc);
+        loc_wipe(&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	if (xattr_req)
-		dict_unref (xattr_req);
+        if (xattr_req)
+                dict_unref (xattr_req);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return object;
+        return object;
 }
 
 struct glfs_object *
 glfs_h_mknod (struct glfs *fs, struct glfs_object *parent, const char *path,
-	      mode_t mode, dev_t dev, struct stat *stat)
+              mode_t mode, dev_t dev, struct stat *stat)
 {
-	int                 ret = -1;
-	xlator_t           *subvol = NULL;
-	inode_t            *inode = NULL;
-	loc_t               loc = {0, };
-	struct iatt         iatt = {0, };
-	uuid_t              gfid;
-	dict_t             *xattr_req = NULL;
-	struct glfs_object *object = NULL;
-
-	/* validate in args */
-	if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
-		errno = EINVAL;
-		return NULL;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, parent);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	xattr_req = dict_new ();
-	if (!xattr_req) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	uuid_generate (gfid);
-	ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-	if (ret) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path);
-
-	/* fop/op */
-	ret = syncop_mknod (subvol, &loc, mode, dev, xattr_req, &iatt);
+        int                 ret = -1;
+        xlator_t           *subvol = NULL;
+        inode_t            *inode = NULL;
+        loc_t               loc = {0, };
+        struct iatt         iatt = {0, };
+        uuid_t              gfid;
+        dict_t             *xattr_req = NULL;
+        struct glfs_object *object = NULL;
+
+        /* validate in args */
+        if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
+                errno = EINVAL;
+                return NULL;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, parent);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        xattr_req = dict_new ();
+        if (!xattr_req) {
+                ret = -1;
+                errno = ENOMEM;
+                goto out;
+        }
+
+        uuid_generate (gfid);
+        ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
+        if (ret) {
+                ret = -1;
+                errno = ENOMEM;
+                goto out;
+        }
+
+        GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, path);
+
+        /* fop/op */
+        ret = syncop_mknod (subvol, &loc, mode, dev, xattr_req, &iatt);
         DECODE_SYNCOP_ERR (ret);
 
-	/* populate out args */
-	if (ret == 0) {
-		ret = glfs_loc_link (&loc, &iatt);
-		if (ret != 0) {
-			goto out;
-		}
+        /* populate out args */
+        if (ret == 0) {
+                ret = glfs_loc_link (&loc, &iatt);
+                if (ret != 0) {
+                        goto out;
+                }
 
-		if (stat)
-			glfs_iatt_to_stat (fs, &iatt, stat);
+                if (stat)
+                        glfs_iatt_to_stat (fs, &iatt, stat);
 
-		ret = glfs_create_object (&loc, &object);
-	}
+                ret = glfs_create_object (&loc, &object);
+        }
 out:
-	if (ret && object != NULL) {
-		glfs_h_close (object);
-		object = NULL;
-	}
+        if (ret && object != NULL) {
+                glfs_h_close (object);
+                object = NULL;
+        }
 
-	loc_wipe(&loc);
+        loc_wipe(&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	if (xattr_req)
-		dict_unref (xattr_req);
+        if (xattr_req)
+                dict_unref (xattr_req);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return object;
+        return object;
 }
 
 int
 glfs_h_unlink (struct glfs *fs, struct glfs_object *parent, const char *path)
 {
-	int                 ret = -1;
-	xlator_t           *subvol = NULL;
-	inode_t            *inode = NULL;
-	loc_t               loc = {0, };
-
-	/* validate in args */
-	if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if ( !subvol ) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, parent);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	ret = glfs_resolve_at (fs, subvol, inode, path, &loc, NULL, 0 , 0);
-	if (ret != 0) {
-		goto out;
-	}
-
-	if (!IA_ISDIR(loc.inode->ia_type)) {
-		ret = syncop_unlink (subvol, &loc);
+        int                 ret = -1;
+        xlator_t           *subvol = NULL;
+        inode_t            *inode = NULL;
+        loc_t               loc = {0, };
+
+        /* validate in args */
+        if ((fs == NULL) || (parent == NULL) || (path == NULL)) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if ( !subvol ) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, parent);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        ret = glfs_resolve_at (fs, subvol, inode, path, &loc, NULL, 0 , 0);
+        if (ret != 0) {
+                goto out;
+        }
+
+        if (!IA_ISDIR(loc.inode->ia_type)) {
+                ret = syncop_unlink (subvol, &loc);
                 DECODE_SYNCOP_ERR (ret);
-		if (ret != 0) {
-			goto out;
-		}
-	} else {
-		ret = syncop_rmdir (subvol, &loc, 0);
+                if (ret != 0) {
+                        goto out;
+                }
+        } else {
+                ret = syncop_rmdir (subvol, &loc, 0);
                 DECODE_SYNCOP_ERR (ret);
-		if (ret != 0) {
-			goto out;
-		}
-	}
+                if (ret != 0) {
+                        goto out;
+                }
+        }
 
-	if (ret == 0)
-		ret = glfs_loc_unlink (&loc);
+        if (ret == 0)
+                ret = glfs_loc_unlink (&loc);
 
 out:
-	loc_wipe (&loc);
+        loc_wipe (&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return ret;
+        return ret;
 }
 
 struct glfs_fd *
 glfs_h_opendir (struct glfs *fs, struct glfs_object *object)
 {
-	int              ret = -1;
-	struct glfs_fd  *glfd = NULL;
-	xlator_t        *subvol = NULL;
-	inode_t         *inode = NULL;
-	loc_t            loc = {0, };
-
-	/* validate in args */
-	if ((fs == NULL) || (object == NULL)) {
-		errno = EINVAL;
-		return NULL;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, object);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	if (!IA_ISDIR (inode->ia_type)) {
-		ret = -1;
-		errno = ENOTDIR;
-		goto out;
-	}
-
-	glfd = glfs_fd_new (fs);
-	if (!glfd)
-		goto out;
-
-	INIT_LIST_HEAD (&glfd->entries);
-
-	glfd->fd = fd_create (inode, getpid());
-	if (!glfd->fd) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	GLFS_LOC_FILL_INODE (inode, loc, out);
-
-	/* fop/op */
-	ret = syncop_opendir (subvol, &loc, glfd->fd);
+        int              ret = -1;
+        struct glfs_fd  *glfd = NULL;
+        xlator_t        *subvol = NULL;
+        inode_t         *inode = NULL;
+        loc_t            loc = {0, };
+
+        /* validate in args */
+        if ((fs == NULL) || (object == NULL)) {
+                errno = EINVAL;
+                return NULL;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, object);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        if (!IA_ISDIR (inode->ia_type)) {
+                ret = -1;
+                errno = ENOTDIR;
+                goto out;
+        }
+
+        glfd = glfs_fd_new (fs);
+        if (!glfd)
+                goto out;
+
+        INIT_LIST_HEAD (&glfd->entries);
+
+        glfd->fd = fd_create (inode, getpid());
+        if (!glfd->fd) {
+                ret = -1;
+                errno = ENOMEM;
+                goto out;
+        }
+
+        GLFS_LOC_FILL_INODE (inode, loc, out);
+
+        /* fop/op */
+        ret = syncop_opendir (subvol, &loc, glfd->fd);
         DECODE_SYNCOP_ERR (ret);
 
 out:
-	loc_wipe (&loc);
+        loc_wipe (&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	if (ret && glfd) {
-		glfs_fd_destroy (glfd);
-		glfd = NULL;
-	} else {
-		fd_bind (glfd->fd);
-		glfs_fd_bind (glfd);
-	}
+        if (ret && glfd) {
+                glfs_fd_destroy (glfd);
+                glfd = NULL;
+        } else {
+                fd_bind (glfd->fd);
+                glfs_fd_bind (glfd);
+        }
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return glfd;
+        return glfd;
 }
 
 int
@@ -998,508 +1003,508 @@ out:
 
 ssize_t
 glfs_h_extract_handle (struct glfs_object *object, unsigned char *handle,
-		       int len)
+                       int len)
 {
-	ssize_t ret = -1;
+        ssize_t ret = -1;
 
-	/* validate in args */
-	if (object == NULL) {
-		errno = EINVAL;
-		goto out;
-	}
+        /* validate in args */
+        if (object == NULL) {
+                errno = EINVAL;
+                goto out;
+        }
 
-	if (!handle || !len) {
-		ret = GFAPI_HANDLE_LENGTH;
-		goto out;
-	}
+        if (!handle || !len) {
+                ret = GFAPI_HANDLE_LENGTH;
+                goto out;
+        }
 
-	if (len < GFAPI_HANDLE_LENGTH)
-	{
-		errno = ERANGE;
-		goto out;
-	}
+        if (len < GFAPI_HANDLE_LENGTH)
+        {
+                errno = ERANGE;
+                goto out;
+        }
 
-	memcpy (handle, object->gfid, GFAPI_HANDLE_LENGTH);
+        memcpy (handle, object->gfid, GFAPI_HANDLE_LENGTH);
 
-	ret = GFAPI_HANDLE_LENGTH;
+        ret = GFAPI_HANDLE_LENGTH;
 
 out:
-	return ret;
+        return ret;
 }
 
 struct glfs_object *
 glfs_h_create_from_handle (struct glfs *fs, unsigned char *handle, int len,
-			   struct stat *stat)
+                           struct stat *stat)
 {
-	loc_t               loc = {0, };
-	int                 ret = -1;
-	struct iatt         iatt = {0, };
-	inode_t            *newinode = NULL;
-	xlator_t           *subvol = NULL;
-	struct glfs_object *object = NULL;
-
-	/* validate in args */
-	if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) {
-		errno = EINVAL;
-		return NULL;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		errno = EIO;
-		goto out;
-	}
-
-	memcpy (loc.gfid, handle, GFAPI_HANDLE_LENGTH);
-
-	newinode = inode_find (subvol->itable, loc.gfid);
-	if (newinode)
-		loc.inode = newinode;
-	else {
-		loc.inode = inode_new (subvol->itable);
-		if (!loc.inode) {
-			errno = ENOMEM;
-			goto out;
-		}
-	}
-
-	ret = syncop_lookup (subvol, &loc, 0, &iatt, 0, 0);
+        loc_t               loc = {0, };
+        int                 ret = -1;
+        struct iatt         iatt = {0, };
+        inode_t            *newinode = NULL;
+        xlator_t           *subvol = NULL;
+        struct glfs_object *object = NULL;
+
+        /* validate in args */
+        if ((fs == NULL) || (handle == NULL) || (len != GFAPI_HANDLE_LENGTH)) {
+                errno = EINVAL;
+                return NULL;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                errno = EIO;
+                goto out;
+        }
+
+        memcpy (loc.gfid, handle, GFAPI_HANDLE_LENGTH);
+
+        newinode = inode_find (subvol->itable, loc.gfid);
+        if (newinode)
+                loc.inode = newinode;
+        else {
+                loc.inode = inode_new (subvol->itable);
+                if (!loc.inode) {
+                        errno = ENOMEM;
+                        goto out;
+                }
+        }
+
+        ret = syncop_lookup (subvol, &loc, 0, &iatt, 0, 0);
         DECODE_SYNCOP_ERR (ret);
-	if (ret) {
-		gf_log (subvol->name, GF_LOG_WARNING,
-			"inode refresh of %s failed: %s",
-			uuid_utoa (loc.gfid), strerror (errno));
-		goto out;
-	}
-
-	newinode = inode_link (loc.inode, 0, 0, &iatt);
-	if (newinode)
-		inode_lookup (newinode);
-	else {
-		gf_log (subvol->name, GF_LOG_WARNING,
-			"inode linking of %s failed: %s",
-			uuid_utoa (loc.gfid), strerror (errno));
-		errno = EINVAL;
-		goto out;
-	}
-
-	/* populate stat */
-	if (stat)
-		glfs_iatt_to_stat (fs, &iatt, stat);
-
-	object = GF_CALLOC (1, sizeof(struct glfs_object),
-			    glfs_mt_glfs_object_t);
-	if (object == NULL) {
-		errno = ENOMEM;
-		ret = -1;
-		goto out;
-	}
-
-	/* populate the return object */
-	object->inode = newinode;
-	uuid_copy (object->gfid, object->inode->gfid);
+        if (ret) {
+                gf_log (subvol->name, GF_LOG_WARNING,
+                        "inode refresh of %s failed: %s",
+                        uuid_utoa (loc.gfid), strerror (errno));
+                goto out;
+        }
+
+        newinode = inode_link (loc.inode, 0, 0, &iatt);
+        if (newinode)
+                inode_lookup (newinode);
+        else {
+                gf_log (subvol->name, GF_LOG_WARNING,
+                        "inode linking of %s failed: %s",
+                        uuid_utoa (loc.gfid), strerror (errno));
+                errno = EINVAL;
+                goto out;
+        }
+
+        /* populate stat */
+        if (stat)
+                glfs_iatt_to_stat (fs, &iatt, stat);
+
+        object = GF_CALLOC (1, sizeof(struct glfs_object),
+                            glfs_mt_glfs_object_t);
+        if (object == NULL) {
+                errno = ENOMEM;
+                ret = -1;
+                goto out;
+        }
+
+        /* populate the return object */
+        object->inode = newinode;
+        uuid_copy (object->gfid, object->inode->gfid);
 
 out:
-	/* TODO: Check where the inode ref is being held? */
-	loc_wipe (&loc);
+        /* TODO: Check where the inode ref is being held? */
+        loc_wipe (&loc);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return object;
+        return object;
 }
 
 int
 glfs_h_close (struct glfs_object *object)
 {
-	/* Release the held reference */
-	inode_unref (object->inode);
-	GF_FREE (object);
+        /* Release the held reference */
+        inode_unref (object->inode);
+        GF_FREE (object);
 
-	return 0;
+        return 0;
 }
 
 int
 glfs_h_truncate (struct glfs *fs, struct glfs_object *object, off_t offset)
 {
-	loc_t               loc = {0, };
-	int                 ret = -1;
-	xlator_t           *subvol = NULL;
-	inode_t            *inode = NULL;
-
-	/* validate in args */
-	if ((fs == NULL) || (object == NULL)) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, object);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	GLFS_LOC_FILL_INODE (inode, loc, out);
-
-	/* fop/op */
-	ret = syncop_truncate (subvol, &loc, (off_t)offset);
+        loc_t               loc = {0, };
+        int                 ret = -1;
+        xlator_t           *subvol = NULL;
+        inode_t            *inode = NULL;
+
+        /* validate in args */
+        if ((fs == NULL) || (object == NULL)) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, object);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        GLFS_LOC_FILL_INODE (inode, loc, out);
+
+        /* fop/op */
+        ret = syncop_truncate (subvol, &loc, (off_t)offset);
         DECODE_SYNCOP_ERR (ret);
 
-	/* populate out args */
-	if (ret == 0)
-		ret = glfs_loc_unlink (&loc);
+        /* populate out args */
+        if (ret == 0)
+                ret = glfs_loc_unlink (&loc);
 
 out:
-	loc_wipe (&loc);
+        loc_wipe (&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return ret;
+        return ret;
 }
 
 struct glfs_object *
 glfs_h_symlink (struct glfs *fs, struct glfs_object *parent, const char *name,
-		const char *data, struct stat *stat)
+                const char *data, struct stat *stat)
 {
-	int                 ret = -1;
-	xlator_t           *subvol = NULL;
-	inode_t            *inode = NULL;
-	loc_t               loc = {0, };
-	struct iatt         iatt = {0, };
-	uuid_t              gfid;
-	dict_t             *xattr_req = NULL;
-	struct glfs_object *object = NULL;
-
-	/* validate in args */
-	if ((fs == NULL) || (parent == NULL) || (name == NULL) ||
-		(data == NULL)) {
-		errno = EINVAL;
-		return NULL;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, parent);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	xattr_req = dict_new ();
-	if (!xattr_req) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
-
-	uuid_generate (gfid);
-	ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
-	if (ret) {
-		ret = -1;
-		errno = ENOMEM;
-		goto out;
-	}
+        int                 ret = -1;
+        xlator_t           *subvol = NULL;
+        inode_t            *inode = NULL;
+        loc_t               loc = {0, };
+        struct iatt         iatt = {0, };
+        uuid_t              gfid;
+        dict_t             *xattr_req = NULL;
+        struct glfs_object *object = NULL;
+
+        /* validate in args */
+        if ((fs == NULL) || (parent == NULL) || (name == NULL) ||
+                (data == NULL)) {
+                errno = EINVAL;
+                return NULL;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, parent);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        xattr_req = dict_new ();
+        if (!xattr_req) {
+                ret = -1;
+                errno = ENOMEM;
+                goto out;
+        }
+
+        uuid_generate (gfid);
+        ret = dict_set_static_bin (xattr_req, "gfid-req", gfid, 16);
+        if (ret) {
+                ret = -1;
+                errno = ENOMEM;
+                goto out;
+        }
+
+        GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, name);
+
+        /* fop/op */
+        ret = syncop_symlink (subvol, &loc, data, xattr_req, &iatt);
+        DECODE_SYNCOP_ERR (ret);
 
-	GLFS_LOC_FILL_PINODE (inode, loc, ret, errno, out, name);
+        /* populate out args */
+        if (ret == 0) {
+                /* TODO: If the inode existed in the cache (say file already
+                 * exists), then the glfs_loc_link will not update the
+                 * loc.inode, as a result we will have a 0000 GFID that we
+                 * would copy out to the object, this needs to be fixed.
+                 */
+                ret = glfs_loc_link (&loc, &iatt);
+                if (ret != 0) {
+                        goto out;
+                }
 
-	/* fop/op */
-	ret = syncop_symlink (subvol, &loc, data, xattr_req, &iatt);
-        DECODE_SYNCOP_ERR (ret);
+                if (stat)
+                        glfs_iatt_to_stat (fs, &iatt, stat);
 
-	/* populate out args */
-	if (ret == 0) {
-		/* TODO: If the inode existed in the cache (say file already
-		 * exists), then the glfs_loc_link will not update the
-		 * loc.inode, as a result we will have a 0000 GFID that we
-		 * would copy out to the object, this needs to be fixed.
-		 */
-		ret = glfs_loc_link (&loc, &iatt);
-		if (ret != 0) {
-			goto out;
-		}
-
-		if (stat)
-			glfs_iatt_to_stat (fs, &iatt, stat);
-
-		ret = glfs_create_object (&loc, &object);
-	}
+                ret = glfs_create_object (&loc, &object);
+        }
 
 out:
-	if (ret && object != NULL) {
-		glfs_h_close (object);
-		object = NULL;
-	}
+        if (ret && object != NULL) {
+                glfs_h_close (object);
+                object = NULL;
+        }
 
-	loc_wipe(&loc);
+        loc_wipe(&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	if (xattr_req)
-		dict_unref (xattr_req);
+        if (xattr_req)
+                dict_unref (xattr_req);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return object;
+        return object;
 }
 
 int
 glfs_h_readlink (struct glfs *fs, struct glfs_object *object, char *buf,
-		 size_t bufsiz)
+                 size_t bufsiz)
 {
-	loc_t               loc = {0, };
-	int                 ret = -1;
-	xlator_t           *subvol = NULL;
-	inode_t            *inode = NULL;
-	char               *linkval = NULL;
-
-	/* validate in args */
-	if ((fs == NULL) || (object == NULL) || (buf == NULL)) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, object);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	GLFS_LOC_FILL_INODE (inode, loc, out);
-
-	/* fop/op */
-	ret = syncop_readlink (subvol, &loc, &linkval, bufsiz);
+        loc_t               loc = {0, };
+        int                 ret = -1;
+        xlator_t           *subvol = NULL;
+        inode_t            *inode = NULL;
+        char               *linkval = NULL;
+
+        /* validate in args */
+        if ((fs == NULL) || (object == NULL) || (buf == NULL)) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, object);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        GLFS_LOC_FILL_INODE (inode, loc, out);
+
+        /* fop/op */
+        ret = syncop_readlink (subvol, &loc, &linkval, bufsiz);
         DECODE_SYNCOP_ERR (ret);
 
-	/* populate out args */
-	if (ret > 0)
-		memcpy (buf, linkval, ret);
+        /* populate out args */
+        if (ret > 0)
+                memcpy (buf, linkval, ret);
 
 out:
-	loc_wipe (&loc);
+        loc_wipe (&loc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	if (linkval)
-		GF_FREE (linkval);
+        if (linkval)
+                GF_FREE (linkval);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return ret;
+        return ret;
 }
 
 int
 glfs_h_link (struct glfs *fs, struct glfs_object *linksrc,
-	     struct glfs_object *parent, const char *name)
+             struct glfs_object *parent, const char *name)
 {
-	int                 ret = -1;
-	xlator_t           *subvol = NULL;
-	inode_t            *inode = NULL;
-	inode_t            *pinode = NULL;
-	loc_t               oldloc = {0, };
-	loc_t               newloc = {0, };
-
-	/* validate in args */
-	if ((fs == NULL) || (linksrc == NULL) || (parent == NULL) ||
-		(name == NULL)) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if (!subvol) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	inode = glfs_resolve_inode (fs, subvol, linksrc);
-	if (!inode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	if (inode->ia_type == IA_IFDIR) {
-		ret = -1;
-		errno = EISDIR;
-		goto out;
-	}
-
-	GLFS_LOC_FILL_INODE (inode, oldloc, out);
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	pinode = glfs_resolve_inode (fs, subvol, parent);
-	if (!pinode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	/* setup newloc based on parent */
-	newloc.parent = inode_ref (pinode);
-	newloc.name = name;
-	ret = glfs_loc_touchup (&newloc);
-	if (ret != 0) {
-		errno = EINVAL;
-		goto out;
-	}
-
-	/* Filling the inode of the hard link to be same as that of the
-	 * original file
-	 */
-	newloc.inode = inode_ref (inode);
-
-	/* fop/op */
-	ret = syncop_link (subvol, &oldloc, &newloc);
+        int                 ret = -1;
+        xlator_t           *subvol = NULL;
+        inode_t            *inode = NULL;
+        inode_t            *pinode = NULL;
+        loc_t               oldloc = {0, };
+        loc_t               newloc = {0, };
+
+        /* validate in args */
+        if ((fs == NULL) || (linksrc == NULL) || (parent == NULL) ||
+                (name == NULL)) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if (!subvol) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        inode = glfs_resolve_inode (fs, subvol, linksrc);
+        if (!inode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        if (inode->ia_type == IA_IFDIR) {
+                ret = -1;
+                errno = EISDIR;
+                goto out;
+        }
+
+        GLFS_LOC_FILL_INODE (inode, oldloc, out);
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        pinode = glfs_resolve_inode (fs, subvol, parent);
+        if (!pinode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        /* setup newloc based on parent */
+        newloc.parent = inode_ref (pinode);
+        newloc.name = name;
+        ret = glfs_loc_touchup (&newloc);
+        if (ret != 0) {
+                errno = EINVAL;
+                goto out;
+        }
+
+        /* Filling the inode of the hard link to be same as that of the
+         * original file
+         */
+        newloc.inode = inode_ref (inode);
+
+        /* fop/op */
+        ret = syncop_link (subvol, &oldloc, &newloc);
         DECODE_SYNCOP_ERR (ret);
 
-	if (ret == 0)
-		/* TODO: No iatt to pass as there has been no lookup */
-		ret = glfs_loc_link (&newloc, NULL);
+        if (ret == 0)
+                /* TODO: No iatt to pass as there has been no lookup */
+                ret = glfs_loc_link (&newloc, NULL);
 out:
-	loc_wipe (&oldloc);
-	loc_wipe (&newloc);
+        loc_wipe (&oldloc);
+        loc_wipe (&newloc);
 
-	if (inode)
-		inode_unref (inode);
+        if (inode)
+                inode_unref (inode);
 
-	if (pinode)
-		inode_unref (pinode);
+        if (pinode)
+                inode_unref (pinode);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return ret;
+        return ret;
 }
 
 int
 glfs_h_rename (struct glfs *fs, struct glfs_object *olddir, const char *oldname,
-	       struct glfs_object *newdir, const char *newname)
+               struct glfs_object *newdir, const char *newname)
 {
-	int                 ret = -1;
-	xlator_t           *subvol = NULL;
-	inode_t            *oldpinode = NULL;
-	inode_t            *newpinode = NULL;
-	loc_t               oldloc = {0, };
-	loc_t               newloc = {0, };
-	struct iatt         oldiatt = {0, };
-	struct iatt         newiatt = {0, };
-
-	/* validate in args */
-	if ((fs == NULL) || (olddir == NULL) || (oldname == NULL) ||
-		(newdir == NULL) || (newname == NULL)) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	__glfs_entry_fs (fs);
-
-	/* get the active volume */
-	subvol = glfs_active_subvol (fs);
-	if ( !subvol ) {
-		ret = -1;
-		errno = EIO;
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	oldpinode = glfs_resolve_inode (fs, subvol, olddir);
-	if (!oldpinode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	ret = glfs_resolve_at (fs, subvol, oldpinode, oldname, &oldloc,
-			       &oldiatt, 0 , 0);
-	if (ret != 0) {
-		goto out;
-	}
-
-	/* get/refresh the in arg objects inode in correlation to the xlator */
-	newpinode = glfs_resolve_inode (fs, subvol, newdir);
-	if (!newpinode) {
-		errno = ESTALE;
-		goto out;
-	}
-
-	ret = glfs_resolve_at (fs, subvol, newpinode, newname, &newloc,
-			       &newiatt, 0, 0);
-
-	if (ret && errno != ENOENT && newloc.parent)
-		goto out;
-
-	if (newiatt.ia_type != IA_INVAL) {
-		if ((oldiatt.ia_type == IA_IFDIR) !=
-			(newiatt.ia_type == IA_IFDIR)) {
-			/* Either both old and new must be dirs,
-			 * or both must be non-dirs. Else, fail.
-			 */
-			ret = -1;
-			errno = EEXIST;
-			goto out;
-		}
-	}
-
-	/* TODO: check if new or old is a prefix of the other, and fail EINVAL */
-
-	ret = syncop_rename (subvol, &oldloc, &newloc);
+        int                 ret = -1;
+        xlator_t           *subvol = NULL;
+        inode_t            *oldpinode = NULL;
+        inode_t            *newpinode = NULL;
+        loc_t               oldloc = {0, };
+        loc_t               newloc = {0, };
+        struct iatt         oldiatt = {0, };
+        struct iatt         newiatt = {0, };
+
+        /* validate in args */
+        if ((fs == NULL) || (olddir == NULL) || (oldname == NULL) ||
+                (newdir == NULL) || (newname == NULL)) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        __glfs_entry_fs (fs);
+
+        /* get the active volume */
+        subvol = glfs_active_subvol (fs);
+        if ( !subvol ) {
+                ret = -1;
+                errno = EIO;
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        oldpinode = glfs_resolve_inode (fs, subvol, olddir);
+        if (!oldpinode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        ret = glfs_resolve_at (fs, subvol, oldpinode, oldname, &oldloc,
+                               &oldiatt, 0 , 0);
+        if (ret != 0) {
+                goto out;
+        }
+
+        /* get/refresh the in arg objects inode in correlation to the xlator */
+        newpinode = glfs_resolve_inode (fs, subvol, newdir);
+        if (!newpinode) {
+                errno = ESTALE;
+                goto out;
+        }
+
+        ret = glfs_resolve_at (fs, subvol, newpinode, newname, &newloc,
+                               &newiatt, 0, 0);
+
+        if (ret && errno != ENOENT && newloc.parent)
+                goto out;
+
+        if (newiatt.ia_type != IA_INVAL) {
+                if ((oldiatt.ia_type == IA_IFDIR) !=
+                        (newiatt.ia_type == IA_IFDIR)) {
+                        /* Either both old and new must be dirs,
+                         * or both must be non-dirs. Else, fail.
+                         */
+                        ret = -1;
+                        errno = EEXIST;
+                        goto out;
+                }
+        }
+
+        /* TODO: check if new or old is a prefix of the other, and fail EINVAL */
+
+        ret = syncop_rename (subvol, &oldloc, &newloc);
         DECODE_SYNCOP_ERR (ret);
 
-	if (ret == 0)
-		inode_rename (oldloc.parent->table, oldloc.parent, oldloc.name,
-			      newloc.parent, newloc.name, oldloc.inode,
-			      &oldiatt);
+        if (ret == 0)
+                inode_rename (oldloc.parent->table, oldloc.parent, oldloc.name,
+                              newloc.parent, newloc.name, oldloc.inode,
+                              &oldiatt);
 
 out:
-	loc_wipe (&oldloc);
-	loc_wipe (&newloc);
+        loc_wipe (&oldloc);
+        loc_wipe (&newloc);
 
-	if (oldpinode)
-		inode_unref (oldpinode);
+        if (oldpinode)
+                inode_unref (oldpinode);
 
-	if (newpinode)
-		inode_unref (newpinode);
+        if (newpinode)
+                inode_unref (newpinode);
 
-	glfs_subvol_done (fs, subvol);
+        glfs_subvol_done (fs, subvol);
 
-	return ret;
+        return ret;
 }