nfs: changes for using nameless lookup and anonymous FDs

- Use gfid to create filehandle instead of encoding path components
- Utilize nameless lookups of GFID for deep resolution instead of
  crawling the namespace with component hints
- Use anonymous FDs for file based operations
- Do away with fdcaching code for files and dirs

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

9 files changed, 1927 insertions, 1004 deletions

diff --git a/xlators/nfs/server/src/mount3.c b/xlators/nfs/server/src/mount3.c
index b1e5639870f..41698058e48 100644
--- a/xlators/nfs/server/src/mount3.c
+++ b/xlators/nfs/server/src/mount3.c
@@ -350,7 +350,7 @@ mnt3svc_mount_inode (rpcsvc_request_t *req, struct mount3_state *ms,
         if ((!req) || (!xl) || (!ms) || (!exportinode))
                 return ret;
 
-        ret = nfs_inode_loc_fill (exportinode, &exportloc);
+        ret = nfs_inode_loc_fill (exportinode, &exportloc, NFS_RESOLVE_EXIST);
         if (ret < 0) {
                 gf_log (GF_MNT, GF_LOG_ERROR, "Loc fill failed for export inode"
                         ": gfid %s, volume: %s",
diff --git a/xlators/nfs/server/src/nfs-common.c b/xlators/nfs/server/src/nfs-common.c
index 61dfeacf122..b5c56d03df6 100644
--- a/xlators/nfs/server/src/nfs-common.c
+++ b/xlators/nfs/server/src/nfs-common.c
@@ -131,7 +131,7 @@ nfs_zero_filled_stat (struct iatt *buf)
          * we've already mapped the root ino to 1 so it is not guaranteed to be
          * 0.
          */
-        if ((buf->ia_nlink == 0) && (buf->ia_type == 0))
+        if ((buf->ia_nlink == 0) && (buf->ia_ctime == 0))
                 return 1;
 
         return 0;
@@ -141,59 +141,18 @@ nfs_zero_filled_stat (struct iatt *buf)
 void
 nfs_loc_wipe (loc_t *loc)
 {
-        if (!loc)
-                return;
-
-        if (loc->path) {
-                GF_FREE ((char *)loc->path);
-                loc->path = NULL;
-        }
-
-        if (loc->parent) {
-                inode_unref (loc->parent);
-                loc->parent = NULL;
-	}
-
-        if (loc->inode) {
-                inode_unref (loc->inode);
-                loc->inode = NULL;
-        }
+        loc_wipe (loc);
 }
 
 
 int
 nfs_loc_copy (loc_t *dst, loc_t *src)
 {
-	int ret = -1;
-
-	if (src->inode)
-		dst->inode = inode_ref (src->inode);
+        int  ret = -1;
 
-	if (src->parent)
-		dst->parent = inode_ref (src->parent);
+        ret = loc_copy (dst, src);
 
-	dst->path = gf_strdup (src->path);
-
-	if (!dst->path) {
-                gf_log (GF_NFS, GF_LOG_ERROR, "strdup failed");
-		goto out;
-        }
-
-	dst->name = strrchr (dst->path, '/');
-	if (dst->name)
-		dst->name++;
-
-	ret = 0;
-out:
-        if (ret == -1) {
-                if (dst->inode)
-                        inode_unref (dst->inode);
-
-                if (dst->parent)
-                        inode_unref (dst->parent);
-        }
-
-	return ret;
+        return ret;
 }
 
 
@@ -207,23 +166,22 @@ nfs_loc_fill (loc_t *loc, inode_t *inode, inode_t *parent, char *path)
 
         if (inode) {
                 loc->inode = inode_ref (inode);
+                if (!uuid_is_null (inode->gfid))
+                        uuid_copy (loc->gfid, inode->gfid);
         }
 
         if (parent)
                 loc->parent = inode_ref (parent);
 
-        loc->path = gf_strdup (path);
-        if (!loc->path) {
-                gf_log (GF_NFS, GF_LOG_ERROR, "strdup failed");
-                goto loc_wipe;
-        }
-
-        loc->name = strrchr (loc->path, '/');
-        if (loc->name)
-                loc->name++;
-        else {
-                gf_log (GF_NFS, GF_LOG_ERROR, "No / in path %s", loc->path);
-                goto loc_wipe;
+        if (path) {
+                loc->path = gf_strdup (path);
+                if (!loc->path) {
+                        gf_log (GF_NFS, GF_LOG_ERROR, "strdup failed");
+                        goto loc_wipe;
+                }
+                loc->name = strrchr (loc->path, '/');
+                if (loc->name)
+                        loc->name++;
         }
 
         ret = 0;
@@ -236,7 +194,7 @@ loc_wipe:
 
 
 int
-nfs_inode_loc_fill (inode_t *inode, loc_t *loc)
+nfs_inode_loc_fill (inode_t *inode, loc_t *loc, int how)
 {
         char            *resolvedpath = NULL;
         inode_t         *parent = NULL;
@@ -245,14 +203,6 @@ nfs_inode_loc_fill (inode_t *inode, loc_t *loc)
         if ((!inode) || (!loc))
                 return ret;
 
-        if ((inode) && __is_root_gfid (inode->gfid))
-                goto ignore_parent;
-
-        parent = inode_parent (inode, 0, NULL);
-        if (!parent)
-                goto err;
-
-ignore_parent:
         ret = inode_path (inode, NULL, &resolvedpath);
         if (ret < 0) {
                 gf_log (GF_NFS, GF_LOG_ERROR, "path resolution failed %s",
@@ -267,6 +217,7 @@ ignore_parent:
                 goto err;
         }
 
+        ret = 0;
 err:
         if (parent)
                 inode_unref (parent);
@@ -278,7 +229,7 @@ err:
 }
 
 int
-nfs_gfid_loc_fill (inode_table_t *itable, uuid_t gfid, loc_t *loc)
+nfs_gfid_loc_fill (inode_table_t *itable, uuid_t gfid, loc_t *loc, int how)
 {
         int             ret = -EFAULT;
         inode_t         *inode = NULL;
@@ -288,11 +239,33 @@ nfs_gfid_loc_fill (inode_table_t *itable, uuid_t gfid, loc_t *loc)
 
         inode = inode_find (itable, gfid);
         if (!inode) {
-                ret = -ENOENT;
-                goto err;
-        }
+		gf_log (GF_NFS, GF_LOG_TRACE, "Inode not found in itable, will try to create one.");
+                if (how == NFS_RESOLVE_CREATE) {
+			gf_log (GF_NFS, GF_LOG_TRACE, "Inode needs to be created.");
+                        inode = inode_new (itable);
+                        if (!inode) {
+                                gf_log (GF_NFS, GF_LOG_ERROR, "Failed to "
+                                        "allocate memory");
+                                ret = -ENOMEM;
+                                goto err;
+                        }
+
+                } else {
+			gf_log (GF_NFS, GF_LOG_ERROR, "Inode not found in itable and no creation was requested.");
+                        ret = -ENOENT;
+                        goto err;
+                }
+        } else {
+		gf_log (GF_NFS, GF_LOG_TRACE, "Inode was found in the itable.");
+	}
+
+        uuid_copy (loc->gfid, gfid);
 
-        ret = nfs_inode_loc_fill (inode, loc);
+        ret = nfs_inode_loc_fill (inode, loc, how);
+	if (ret < 0) {
+		gf_log (GF_NFS, GF_LOG_ERROR, "Inode loc filling failed.: %s", strerror (-ret));
+		goto err;
+	}
 
 err:
         if (inode)
@@ -307,7 +280,7 @@ nfs_root_loc_fill (inode_table_t *itable, loc_t *loc)
         uuid_t  rootgfid = {0, };
 
         rootgfid[15] = 1;
-        return nfs_gfid_loc_fill (itable, rootgfid, loc);
+        return nfs_gfid_loc_fill (itable, rootgfid, loc, NFS_RESOLVE_EXIST);
 }
 
 
@@ -362,6 +335,8 @@ nfs_entry_loc_fill (inode_table_t *itable, uuid_t pargfid, char *entry,
         if (!parent)
                 goto err;
 
+        uuid_copy (loc->pargfid, pargfid);
+
         ret = -2;
         entryinode = inode_grep (itable, parent, entry);
         if (!entryinode) {
diff --git a/xlators/nfs/server/src/nfs-common.h b/xlators/nfs/server/src/nfs-common.h
index 2e0f47986b7..58dea70d0c7 100644
--- a/xlators/nfs/server/src/nfs-common.h
+++ b/xlators/nfs/server/src/nfs-common.h
@@ -67,7 +67,7 @@ nfs_loc_fill (loc_t *loc, inode_t *inode, inode_t *parent, char *path);
 #define NFS_RESOLVE_CREATE      2
 
 extern int
-nfs_inode_loc_fill (inode_t *inode, loc_t *loc);
+nfs_inode_loc_fill (inode_t *inode, loc_t *loc, int how);
 
 extern int
 nfs_ino_loc_fill (inode_table_t *itable, uuid_t gfid, loc_t *l);
@@ -81,4 +81,7 @@ nfs_root_loc_fill (inode_table_t *itable, loc_t *loc);
 
 extern uint32_t
 nfs_hash_gfid (uuid_t gfid);
+
+extern int
+nfs_gfid_loc_fill (inode_table_t *itable, uuid_t gfid, loc_t *loc, int how);
 #endif
diff --git a/xlators/nfs/server/src/nfs.c b/xlators/nfs/server/src/nfs.c
index 2bc7f02fcd1..0862f0017f9 100644
--- a/xlators/nfs/server/src/nfs.c
+++ b/xlators/nfs/server/src/nfs.c
@@ -274,7 +274,7 @@ nfs_startup_subvolume (xlator_t *nfsx, xlator_t *xl)
                 goto err;
         }
 
-        ret = nfs_inode_loc_fill (xl->itable->root, &rootloc);
+        ret = nfs_root_loc_fill (xl->itable, &rootloc);
         if (ret == -1) {
                 gf_log (GF_NFS, GF_LOG_CRITICAL, "Failed to init root loc");
                 goto err;
@@ -455,6 +455,23 @@ nfs_request_user_init (nfs_user_t *nfu, rpcsvc_request_t *req)
         return;
 }
 
+void
+nfs_request_primary_user_init (nfs_user_t *nfu, rpcsvc_request_t *req,
+                               uid_t uid, gid_t gid)
+{
+        gid_t           *gidarr = NULL;
+        int             gids = 0;
+
+        if ((!req) || (!nfu))
+                return;
+
+        gidarr = rpcsvc_auth_unix_auxgids (req, &gids);
+        nfs_user_create (nfu, uid, gid, gidarr, gids);
+
+        return;
+}
+
+
 int32_t
 mem_acct_init (xlator_t *this)
 {
@@ -792,22 +809,6 @@ fini (xlator_t *this)
 int32_t
 nfs_forget (xlator_t *this, inode_t *inode)
 {
-        int32_t                 ret = -1;
-        uint64_t                ctx = 0;
-        struct inode_op_queue  *inode_q = NULL;
-
-        if (!inode || !this)
-                return 0;
-        ret = inode_ctx_del (inode, this, &ctx);
-        if (!ret && ctx && !(IA_ISDIR (inode->ia_type))) {
-                inode_q = (struct inode_op_queue *) (long) ctx;
-                pthread_mutex_lock (&inode_q->qlock);
-                {
-                        nfs3_flush_inode_queue (inode_q, NULL, 0);
-                }
-                pthread_mutex_unlock (&inode_q->qlock);
-        }
-
         return 0;
 }
 
diff --git a/xlators/nfs/server/src/nfs.h b/xlators/nfs/server/src/nfs.h
index 11f4b677f1a..a77e772a3e3 100644
--- a/xlators/nfs/server/src/nfs.h
+++ b/xlators/nfs/server/src/nfs.h
@@ -108,6 +108,9 @@ nfs_user_create (nfs_user_t *newnfu, uid_t uid, gid_t gid, gid_t *auxgids,
 extern void
 nfs_request_user_init (nfs_user_t *nfu, rpcsvc_request_t *req);
 
+extern void
+nfs_request_primary_user_init (nfs_user_t *nfu, rpcsvc_request_t *req,
+                               uid_t uid, gid_t gid);
 extern int
 nfs_subvolume_started (struct nfs_state *nfs, xlator_t *xl);
 #endif
diff --git a/xlators/nfs/server/src/nfs3-helpers.c b/xlators/nfs/server/src/nfs3-helpers.c
index 2070d196add..5b0daed8253 100644
--- a/xlators/nfs/server/src/nfs3-helpers.c
+++ b/xlators/nfs/server/src/nfs3-helpers.c
@@ -1617,700 +1617,1804 @@ err:
 }
 
 
-/* When remove a file, we need to unref the cached fd for an inode but this
- * needs to happen only when the file was in fact opened. However, it is
- * possible that fd_lookup on a file returns an fd because the file was in
- * process of being created(which also returns an fd) but since this fd was not
- * opened through this path, in the NFS3 remove path, we'll end up removing the
- * reference that belongs to someone else. That means, nfs3 remove path should
- * not unref unless it is sure that the file was cached open also. If it was,
- * only then perform the fd_unref, else not.
- *
- * We determine that using a flag in the inode context.
- */
-int
-nfs3_set_inode_opened (xlator_t *nfsxl, inode_t *inode)
+void
+nfs3_stat_to_errstr (uint32_t xid, char *op, nfsstat3 stat, int pstat,
+                     char *errstr)
 {
-        if ((!nfsxl) || (!inode))
-                return -1;
+        if ((!op) || (!errstr))
+                return;
+
+        sprintf (errstr, "XID: %x, %s: NFS: %d(%s), POSIX: %d(%s)", xid, op,
+                 stat, nfsstat3_strerror (stat), pstat, strerror (pstat));
+}
 
-        inode_ctx_put (inode, nfsxl, GF_NFS3_FD_CACHED);
+void
+nfs3_log_common_call (uint32_t xid, char *op, struct nfs3_fh *fh)
+{
+        char    fhstr[1024];
 
-        return 0;
+	if (gf_log_loglevel < GF_LOG_DEBUG)
+		return;
+
+        nfs3_fh_to_str (fh, fhstr);
+        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, %s: args: %s", xid, op,
+                fhstr);
 }
 
 
-/* Returns 1 if inode was cached open, otherwise 0 */
-int
-nfs3_cached_inode_opened (xlator_t *nfsxl, inode_t *inode)
+void
+nfs3_log_fh_entry_call (uint32_t xid, char *op, struct nfs3_fh *fh,
+                        char *name)
 {
-        int             ret = -1;
-        uint64_t        cflag = 0;
+        char    fhstr[1024];
 
-        if ((!nfsxl) || (!inode))
-                return -1;
+	if (gf_log_loglevel < GF_LOG_DEBUG)
+		return;
+        nfs3_fh_to_str (fh, fhstr);
+        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, %s: args: %s, name: %s", xid,
+                op, fhstr, name);
+}
 
-        ret = inode_ctx_get (inode, nfsxl, &cflag);
-        if (ret == -1)
-                ret = 0;
-        else if (cflag == GF_NFS3_FD_CACHED)
-                ret = 1;
 
-        return ret;
+void
+nfs3_log_rename_call (uint32_t xid, struct nfs3_fh *src, char *sname,
+                      struct nfs3_fh *dst, char *dname)
+{
+        char    sfhstr[1024];
+        char    dfhstr[1024];
+
+	if (gf_log_loglevel < GF_LOG_DEBUG)
+		return;
+        nfs3_fh_to_str (src, sfhstr);
+        nfs3_fh_to_str (dst, dfhstr);
+        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, RENAME: args: Src: %s, "
+                "name: %s, Dst: %s, name: %s", xid, sfhstr, sname, dfhstr,
+                dname);
 }
 
 
-int32_t
-nfs3_dir_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                   int32_t op_ret, int32_t op_errno, fd_t *fd)
+
+void
+nfs3_log_create_call (uint32_t xid, struct nfs3_fh *fh, char *name,
+                      createmode3 mode)
 {
-        nfs3_call_state_t       *cs = NULL;
+        char    fhstr[1024];
+        char    *modestr = NULL;
+        char    exclmode[] = "EXCLUSIVE";
+        char    unchkd[] = "UNCHECKED";
+        char    guarded[] = "GUARDED";
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                gf_log (GF_NFS3, GF_LOG_ERROR, "Dir open failed path %s err %s"
-                                , cs->resolvedloc.path, strerror (op_errno));
-                cs->resolve_ret = -1;
-                cs->resolve_errno = op_errno;
-                nfs3_call_resume (cs);
-                goto err;
-        }
+	if (gf_log_loglevel < GF_LOG_DEBUG)
+		return;
+        nfs3_fh_to_str (fh, fhstr);
+        if (mode == EXCLUSIVE)
+                modestr = exclmode;
+        else if (mode == GUARDED)
+                modestr = guarded;
+        else
+                modestr = unchkd;
 
-        cs->fd = fd;     /* Gets unrefd when the call state is wiped. */
-        nfs3_set_inode_opened (cs->nfsx, cs->resolvedloc.inode);
-        gf_log (GF_NFS3, GF_LOG_TRACE, "FD_REF: %d", fd->refcount);
-        nfs3_call_resume (cs);
-err:
-        return 0;
+        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, CREATE: args: %s, name: %s,"
+                " mode: %s", xid, fhstr, name, modestr);
 }
 
 
-int
-__nfs3_dir_open_and_resume (nfs3_call_state_t *cs)
+void
+nfs3_log_mknod_call (uint32_t xid, struct nfs3_fh *fh, char *name, int type)
 {
-        nfs_user_t      nfu = {0, };
-        int             ret = -EFAULT;
+        char    fhstr[1024];
+        char    *modestr = NULL;
+        char    chr[] = "CHAR";
+        char    blk[] = "BLK";
+        char    sock[] = "SOCK";
+        char    fifo[] = "FIFO";
 
-        if (!cs)
-                return ret;
+	if (gf_log_loglevel < GF_LOG_DEBUG)
+		return;
+        nfs3_fh_to_str (fh, fhstr);
+        if (type == NF3CHR)
+                modestr = chr;
+        else if (type == NF3BLK)
+                modestr = blk;
+        else if (type == NF3SOCK)
+                modestr = sock;
+        else
+                modestr = fifo;
 
-        nfs_user_root_create (&nfu);
-        ret = nfs_opendir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                           nfs3_dir_open_cbk, cs);
-        return ret;
+        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, MKNOD: args: %s, name: %s,"
+                " type: %s", xid, fhstr, name, modestr);
 }
 
 
-int
-nfs3_dir_open_and_resume (nfs3_call_state_t *cs, nfs3_resume_fn_t resume)
+
+void
+nfs3_log_symlink_call (uint32_t xid, struct nfs3_fh *fh, char *name, char *tgt)
 {
-        fd_t    *fd = NULL;
-        int     ret = -EFAULT;
+        char    fhstr[1024];
 
-        if ((!cs))
-                return ret;
+	if (gf_log_loglevel < GF_LOG_DEBUG)
+		return;
+        nfs3_fh_to_str (fh, fhstr);
+        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, SYMLINK: args: %s, name: %s,"
+                " target: %s", xid, fhstr, name, tgt);
+}
 
-        cs->resume_fn = resume;
-        gf_log (GF_NFS3, GF_LOG_TRACE, "Opening: %s", cs->resolvedloc.path);
-        fd = fd_lookup (cs->resolvedloc.inode, 0);
-        if (fd) {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "fd found in state: ref: %d",
-                        fd->refcount);
-                cs->fd = fd;    /* Gets unrefd when the call state is wiped. */
-                cs->resolve_ret = 0;
-                nfs3_call_resume (cs);
-                ret = 0;
-                goto err;
-        }
 
-        ret = __nfs3_dir_open_and_resume (cs);
+void
+nfs3_log_link_call (uint32_t xid, struct nfs3_fh *fh, char *name,
+                    struct nfs3_fh *tgt)
+{
+        char    dfhstr[1024];
+        char    tfhstr[1024];
 
-err:
-        return ret;
+	if (gf_log_loglevel < GF_LOG_DEBUG)
+		return;
+        nfs3_fh_to_str (fh, dfhstr);
+        nfs3_fh_to_str (tgt, tfhstr);
+        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, LINK: args: %s, name: %s,"
+                " target: %s", xid, dfhstr, name, tfhstr);
 }
 
 
-int
-nfs3_flush_call_state (nfs3_call_state_t *cs, fd_t *openedfd,
-                       int32_t call_resume)
+void
+nfs3_log_rw_call (uint32_t xid, char *op, struct nfs3_fh *fh, offset3 offt,
+                  count3 count, int stablewrite)
 {
-        if ((!cs))
-                return -1;
+        char    fhstr[1024];
 
-        gf_log (GF_NFS3, GF_LOG_TRACE, "Calling resume");
-        if (openedfd) {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Opening uncached fd done: %d",
-                        openedfd->refcount);
-                cs->fd = fd_ref (openedfd);
-                /* Set resove_ret to 0 so that the error checking in the resume
-                 * callback results in a successful read reply when the fd was
-                 * opened. If the fd opening failed, the resolve_ret is already
-                 * set to -1 in nfs3_file_open_cbk, so that will result in an
-                 * error being returned to the nfs client' read request.
-                 */
-                cs->resolve_ret = 0;
-        }
-        list_del (&cs->openwait_q);
-        if (call_resume)
-                nfs3_call_resume (cs);
+	if (gf_log_loglevel < GF_LOG_DEBUG)
+		return;
+        nfs3_fh_to_str (fh, fhstr);
+        if (stablewrite == -1)
+                gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, %s: args: %s, offset:"
+                        " %"PRIu64",  count: %"PRIu32, xid, op, fhstr, offt,
+                        count);
+        else
+                gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, %s: args: %s, offset:"
+                        " %"PRIu64",  count: %"PRIu32", %s", xid, op, fhstr,
+                        offt, count,
+                        (stablewrite == UNSTABLE)?"UNSTABLE":"STABLE");
 
-        return 0;
 }
 
 
 int
-nfs3_flush_inode_queue (struct inode_op_queue *inode_q, fd_t *openedfd,
-                        int32_t call_resume)
-{
-        nfs3_call_state_t       *cstmp = NULL;
-        nfs3_call_state_t       *cs = NULL;
+nfs3_getattr_loglevel (nfsstat3 stat) {
 
-        if (!inode_q)
-                return -1;
+	int ll = GF_LOG_DEBUG;
 
-        list_for_each_entry_safe (cs, cstmp, &inode_q->opq, openwait_q)
-                nfs3_flush_call_state (cs, openedfd, call_resume);
+	switch (stat) {
 
-        return 0;
+        case NFS3ERR_PERM:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOENT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ACCES:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_EXIST:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOSPC:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ROFS:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NAMETOOLONG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
+        }
+
+        return ll;
 }
 
 
 int
-nfs3_flush_open_wait_call_states (nfs3_call_state_t *cs, fd_t *openedfd)
-{
-        struct inode_op_queue   *inode_q = NULL;
-        uint64_t                ctxaddr = 0;
-        int                     ret = 0;
+nfs3_setattr_loglevel (nfsstat3 stat) {
 
-        if (!cs)
-                return -1;
+	int ll = GF_LOG_DEBUG;
 
-        gf_log (GF_NFS3, GF_LOG_TRACE, "Flushing call state");
-        ret = inode_ctx_get (cs->resolvedloc.inode, cs->nfsx, &ctxaddr);
-        if (ret == -1) {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "No inode queue present");
-                goto out;
-        }
+	switch (stat) {
 
-        inode_q = (struct inode_op_queue *)(long)ctxaddr;
-        if (!inode_q)
-                goto out;
+        case NFS3ERR_NOENT:
+		ll = GF_LOG_WARNING;
+                break;
 
-        pthread_mutex_lock (&inode_q->qlock);
-        {
-                nfs3_flush_inode_queue (inode_q, openedfd, 1);
+        case NFS3ERR_EXIST:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOSPC:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ROFS:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NAMETOOLONG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
         }
-        pthread_mutex_unlock (&inode_q->qlock);
 
-out:
-        return 0;
+        return ll;
 }
 
 
 int
-__nfs3_fdcache_update_entry (struct nfs3_state *nfs3, fd_t *fd)
-{
-        uint64_t                ctxaddr = 0;
-        struct nfs3_fd_entry    *fde = NULL;
+nfs3_lookup_loglevel (nfsstat3 stat) {
 
-        if ((!nfs3) || (!fd))
-                return -1;
+	int ll = GF_LOG_DEBUG;
+
+	switch (stat) {
+
+        case NFS3ERR_PERM:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ACCES:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_EXIST:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOSPC:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ROFS:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NAMETOOLONG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
 
-        gf_log (GF_NFS3, GF_LOG_TRACE, "Updating fd: 0x%lx", (long int)fd);
-        fd_ctx_get (fd, nfs3->nfsx, &ctxaddr);
-        fde = (struct nfs3_fd_entry *)(long)ctxaddr;
-        if (fde) {
-                list_del (&fde->list);
-                list_add_tail (&fde->list, &nfs3->fdlru);
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
         }
 
-        return 0;
+        return ll;
 }
 
 
 int
-nfs3_fdcache_update (struct nfs3_state *nfs3, fd_t *fd)
-{
-        if ((!nfs3) || (!fd))
-                return -1;
+nfs3_access_loglevel (nfsstat3 stat) {
+
+	int ll = GF_LOG_DEBUG;
+
+	switch (stat) {
+
+        case NFS3ERR_NOENT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_EXIST:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
 
-        LOCK (&nfs3->fdlrulock);
-        {
-                __nfs3_fdcache_update_entry (nfs3, fd);
+        case NFS3ERR_NOSPC:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ROFS:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NAMETOOLONG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
         }
-        UNLOCK (&nfs3->fdlrulock);
 
-        return 0;
+        return ll;
 }
 
 
 int
-__nfs3_fdcache_remove_entry (struct nfs3_state *nfs3, struct nfs3_fd_entry *fde)
-{
-        if ((!fde) || (!nfs3))
-                return 0;
+nfs3_readlink_loglevel (nfsstat3 stat) {
 
-        gf_log (GF_NFS3, GF_LOG_TRACE, "Removing fd: 0x%lx: %d",
-                (long int)fde->cachedfd, fde->cachedfd->refcount);
-        list_del (&fde->list);
-        fd_ctx_del (fde->cachedfd, nfs3->nfsx, NULL);
-        fd_unref (fde->cachedfd);
-        GF_FREE (fde);
-        --nfs3->fdcount;
+	int ll = GF_LOG_DEBUG;
 
-        return 0;
-}
+	switch (stat) {
 
+        case NFS3ERR_EXIST:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOSPC:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ROFS:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
+        }
+
+        return ll;
+}
 
 int
-nfs3_fdcache_remove (struct nfs3_state *nfs3, fd_t *fd)
-{
-        struct nfs3_fd_entry    *fde = NULL;
-        uint64_t                ctxaddr = 0;
+nfs3_read_loglevel (nfsstat3 stat) {
 
-        if ((!nfs3) || (!fd))
-                return -1;
+	int ll = GF_LOG_DEBUG;
+
+	switch (stat) {
+
+        case NFS3ERR_NOENT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_EXIST:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOSPC:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ROFS:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NAMETOOLONG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
 
-        LOCK (&nfs3->fdlrulock);
-        {
-                fd_ctx_get (fd, nfs3->nfsx, &ctxaddr);
-                fde = (struct nfs3_fd_entry *)(long)ctxaddr;
-                __nfs3_fdcache_remove_entry (nfs3, fde);
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
         }
-        UNLOCK (&nfs3->fdlrulock);
 
-        return 0;
+        return ll;
 }
 
 
 int
-__nfs3_fdcache_replace (struct nfs3_state *nfs3)
-{
-        struct nfs3_fd_entry    *fde = NULL;
-        struct nfs3_fd_entry    *tmp = NULL;
+nfs3_write_loglevel (nfsstat3 stat) {
 
-        if (!nfs3)
-                return -1;
+	int ll = GF_LOG_DEBUG;
 
-        if (nfs3->fdcount <= GF_NFS3_FDCACHE_SIZE)
-                return 0;
+	switch (stat) {
 
-        list_for_each_entry_safe (fde, tmp, &nfs3->fdlru, list)
+        case NFS3ERR_NOENT:
+		ll = GF_LOG_WARNING;
                 break;
 
-        __nfs3_fdcache_remove_entry (nfs3, fde);
+        case NFS3ERR_EXIST:
+		ll = GF_LOG_WARNING;
+                break;
 
-        return 0;
-}
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
 
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
 
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
 
-int
-nfs3_fdcache_add (struct nfs3_state *nfs3, fd_t *fd)
-{
-        struct nfs3_fd_entry    *fde = NULL;
-        int                     ret = -1;
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
 
-        if ((!nfs3) || (!fd))
-                return -1;
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
 
-        fde = GF_CALLOC (1, sizeof (*fd), gf_nfs_mt_nfs3_fd_entry);
-        if (!fde) {
-                gf_log (GF_NFS3, GF_LOG_ERROR, "fd entry allocation failed");
-                goto out;
-        }
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOSPC:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ROFS:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
 
-        /* Already refd by caller. */
-        fde->cachedfd = fd;
-        INIT_LIST_HEAD (&fde->list);
-
-        LOCK (&nfs3->fdlrulock);
-        {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Adding fd: 0x%lx",
-                        (long int) fd);
-                fd_ctx_set (fd, nfs3->nfsx, (uintptr_t)fde);
-                fd_bind (fd);
-                list_add_tail (&fde->list, &nfs3->fdlru);
-                ++nfs3->fdcount;
-                __nfs3_fdcache_replace (nfs3);
+        case NFS3ERR_NAMETOOLONG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
         }
-        UNLOCK (&nfs3->fdlrulock);
 
-out:
-        return ret;
+        return ll;
 }
 
 
-int32_t
-nfs3_file_open_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                    int32_t op_ret, int32_t op_errno, fd_t *fd)
-{
-        nfs3_call_state_t       *cs = NULL;
-        struct nfs3_state       *nfs3 = NULL;
+int
+nfs3_create_loglevel (nfsstat3 stat) {
 
-        cs = frame->local;
-        if (op_ret == -1) {
-                gf_log (GF_NFS3, GF_LOG_ERROR, "Opening uncached fd failed: "
-                        "%s", strerror(op_errno));
-                cs->resolve_ret = -1;
-                cs->resolve_errno = op_errno;
-                fd = NULL;
-        } else {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Opening uncached fd done: %d",
-                        fd->refcount);
+	int ll = GF_LOG_DEBUG;
+
+	switch (stat) {
+
+        case NFS3ERR_NOENT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_EXIST:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
         }
 
-        nfs3 = rpcsvc_request_program_private (cs->req);
-        /* Call states are flushed even when the opening of the file failed.
-         * This allows returning an error for each one of the file io requests
-         * that are currently queued waiting for the open to succeed.
-         */
-        nfs3_flush_open_wait_call_states (cs, fd);
-        if (fd)
-                nfs3_fdcache_add (nfs3, fd);
-        return 0;
+        return ll;
 }
 
 
-struct inode_op_queue *
-__nfs3_get_inode_queue (nfs3_call_state_t *cs)
-{
-        struct inode_op_queue   *inode_q = NULL;
-        int                     ret = -1;
-        uint64_t                ctxaddr = 0;
+int
+nfs3_mkdir_loglevel (nfsstat3 stat) {
 
-        ret = __inode_ctx_get (cs->resolvedloc.inode, cs->nfsx, &ctxaddr);
-        if (ret == 0) {
-                inode_q = (struct inode_op_queue *)(long)ctxaddr;
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Inode queue already inited");
-                goto err;
-        }
+	int ll = GF_LOG_DEBUG;
 
-        inode_q = GF_CALLOC (1, sizeof (*inode_q), gf_nfs_mt_inode_q);
-        if (!inode_q) {
-                gf_log (GF_NFS3, GF_LOG_ERROR, "Memory allocation failed");
-                goto err;
-        }
+	switch (stat) {
 
-        gf_log (GF_NFS3, GF_LOG_TRACE, "Initing inode queue");
-        INIT_LIST_HEAD (&inode_q->opq);
-        pthread_mutex_init (&inode_q->qlock, NULL);
-        __inode_ctx_put (cs->resolvedloc.inode, cs->nfsx, (uintptr_t)inode_q);
+        case NFS3ERR_NOENT:
+		ll = GF_LOG_WARNING;
+                break;
 
-err:
-        return inode_q;
-}
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
 
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
 
-struct inode_op_queue *
-nfs3_get_inode_queue (nfs3_call_state_t *cs)
-{
-        struct inode_op_queue   *inode_q = NULL;
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
 
-        LOCK (&cs->resolvedloc.inode->lock);
-        {
-                inode_q = __nfs3_get_inode_queue (cs);
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
         }
-        UNLOCK (&cs->resolvedloc.inode->lock);
 
-        return inode_q;
+        return ll;
 }
 
 
-#define GF_NFS3_FD_OPEN_INPROGRESS      1
-#define GF_NFS3_FD_NEEDS_OPEN           0
+int
+nfs3_symlink_loglevel (nfsstat3 stat) {
 
+	int ll = GF_LOG_DEBUG;
 
-int
-__nfs3_queue_call_state (struct inode_op_queue *inode_q, nfs3_call_state_t *cs)
-{
-        int     ret = -1;
+	switch (stat) {
 
-        if (!inode_q)
-                goto err;
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
 
-        pthread_mutex_lock (&inode_q->qlock);
-        {
-                if (list_empty (&inode_q->opq)) {
-                        gf_log (GF_NFS3, GF_LOG_TRACE, "First call in queue");
-                        ret = GF_NFS3_FD_NEEDS_OPEN;
-                } else
-                        ret = GF_NFS3_FD_OPEN_INPROGRESS;
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
 
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Queueing call state");
-                list_add_tail (&cs->openwait_q, &inode_q->opq);
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
         }
-        pthread_mutex_unlock (&inode_q->qlock);
 
-err:
-        return ret;
+        return ll;
 }
 
 
-/* Returns GF_NFS3_FD_NEEDS_OPEN if the current call is the first one to be
- * queued. If so, the caller will need to send the open fop. If this is a
- * non-first call to be queued, it means the fd opening is in progress and
- * GF_NFS3_FD_OPEN_INPROGRESS is returned.
- *
- * Returns -1 on error.
- */
 int
-nfs3_queue_call_state (nfs3_call_state_t *cs)
-{
-        struct inode_op_queue   *inode_q = NULL;
-        int                     ret = -1;
+nfs3_mknod_loglevel (nfsstat3 stat) {
 
-        inode_q = nfs3_get_inode_queue (cs);
-        if (!inode_q) {
-                gf_log (GF_NFS3, GF_LOG_ERROR, "Failed to get inode op queue");
-                goto err;
+	int ll = GF_LOG_DEBUG;
+
+	switch (stat) {
+
+        case NFS3ERR_NOENT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
         }
 
-        ret = __nfs3_queue_call_state (inode_q, cs);
+        return ll;
+}
 
-err:
-        return ret;
+int
+nfs3_remove_loglevel (nfsstat3 stat) {
+
+	int ll = GF_LOG_DEBUG;
+
+	switch (stat) {
+
+        case NFS3ERR_EXIST:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOSPC:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
+        }
+
+        return ll;
 }
 
 
 int
-__nfs3_file_open_and_resume (nfs3_call_state_t *cs)
-{
-        nfs_user_t      nfu = {0, };
-        int             ret = -EFAULT;
+nfs3_rmdir_loglevel (nfsstat3 stat) {
 
-        if (!cs)
-                return ret;
+	int ll = GF_LOG_DEBUG;
 
-        ret = nfs3_queue_call_state (cs);
-        if (ret == -1) {
-                gf_log (GF_NFS3, GF_LOG_ERROR, "Error queueing call state");
-                ret = -EFAULT;
-                goto out;
-        } else if (ret == GF_NFS3_FD_OPEN_INPROGRESS) {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Open in progress. Will wait.");
-                ret = 0;
-                goto out;
+	switch (stat) {
+
+        case NFS3ERR_EXIST:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOSPC:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
         }
 
-        nfs_user_root_create (&nfu);
-        gf_log (GF_NFS3, GF_LOG_TRACE, "Opening uncached fd");
-        ret = nfs_open (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc, O_RDWR,
-                        nfs3_file_open_cbk, cs);
-out:
-        return ret;
+        return ll;
 }
 
 
-fd_t *
-nfs3_fdcache_getfd (struct nfs3_state *nfs3, inode_t *inode)
-{
-        fd_t    *fd = NULL;
+int
+nfs3_rename_loglevel (nfsstat3 stat) {
 
-        if ((!nfs3) || (!inode))
-                return NULL;
+	int ll = GF_LOG_DEBUG;
 
-        fd = fd_lookup (inode, 0);
-        if (fd) {
-                /* Already refd by fd_lookup, so no need to ref again. */
-                gf_log (GF_NFS3, GF_LOG_TRACE, "fd found in state: %d",
-                        fd->refcount);
-                nfs3_fdcache_update (nfs3, fd);
-        } else
-                gf_log (GF_NFS3, GF_LOG_TRACE, "fd not found in state");
+	switch (stat) {
 
-        return fd;
-}
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
 
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
 
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
 
-int
-nfs3_file_open_and_resume (nfs3_call_state_t *cs, nfs3_resume_fn_t resume)
-{
-        fd_t    *fd = NULL;
-        int     ret = -EFAULT;
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
 
-        if (!cs)
-                return ret;
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
 
-        cs->resume_fn = resume;
-        gf_log (GF_NFS3, GF_LOG_TRACE, "Opening: %s", cs->resolvedloc.path);
-        fd = nfs3_fdcache_getfd (cs->nfs3state, cs->resolvedloc.inode);
-        if (fd) {
-                cs->fd = fd;    /* Gets unrefd when the call state is wiped. */
-                cs->resolve_ret = 0;
-                nfs3_call_resume (cs);
-                ret = 0;
-                goto err;
-        }
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
 
-        ret = __nfs3_file_open_and_resume (cs);
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
 
-err:
-        return ret;
-}
+        case NFS3ERR_NOSPC:
+		ll = GF_LOG_WARNING;
+                break;
 
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
 
-void
-nfs3_stat_to_errstr (uint32_t xid, char *op, nfsstat3 stat, int pstat,
-                     char *errstr)
-{
-        if ((!op) || (!errstr))
-                return;
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
 
-        sprintf (errstr, "XID: %x, %s: NFS: %d(%s), POSIX: %d(%s)", xid, op,
-                 stat, nfsstat3_strerror (stat), pstat, strerror (pstat));
-}
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
 
-void
-nfs3_log_common_call (uint32_t xid, char *op, struct nfs3_fh *fh)
-{
-        char    fhstr[1024];
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
 
-        nfs3_fh_to_str (fh, fhstr);
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, %s: args: %s", xid, op,
-                fhstr);
-}
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
 
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
 
-void
-nfs3_log_fh_entry_call (uint32_t xid, char *op, struct nfs3_fh *fh,
-                        char *name)
-{
-        char    fhstr[1024];
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
 
-        nfs3_fh_to_str (fh, fhstr);
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, %s: args: %s, name: %s", xid,
-                op, fhstr, name);
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
+        }
+
+        return ll;
 }
 
 
-void
-nfs3_log_rename_call (uint32_t xid, struct nfs3_fh *src, char *sname,
-                      struct nfs3_fh *dst, char *dname)
-{
-        char    sfhstr[1024];
-        char    dfhstr[1024];
+int
+nfs3_link_loglevel (nfsstat3 stat) {
 
-        nfs3_fh_to_str (src, sfhstr);
-        nfs3_fh_to_str (dst, dfhstr);
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, RENAME: args: Src: %s, "
-                "name: %s, Dst: %s, name: %s", xid, sfhstr, sname, dfhstr,
-                dname);
-}
+	int ll = GF_LOG_DEBUG;
 
+	switch (stat) {
 
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
 
-void
-nfs3_log_create_call (uint32_t xid, struct nfs3_fh *fh, char *name,
-                      createmode3 mode)
-{
-        char    fhstr[1024];
-        char    *modestr = NULL;
-        char    exclmode[] = "EXCLUSIVE";
-        char    unchkd[] = "UNCHECKED";
-        char    guarded[] = "GUARDED";
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
 
-        nfs3_fh_to_str (fh, fhstr);
-        if (mode == EXCLUSIVE)
-                modestr = exclmode;
-        else if (mode == GUARDED)
-                modestr = guarded;
-        else
-                modestr = unchkd;
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
 
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, CREATE: args: %s, name: %s,"
-                " mode: %s", xid, fhstr, name, modestr);
-}
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
 
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
 
-void
-nfs3_log_mknod_call (uint32_t xid, struct nfs3_fh *fh, char *name, int type)
-{
-        char    fhstr[1024];
-        char    *modestr = NULL;
-        char    chr[] = "CHAR";
-        char    blk[] = "BLK";
-        char    sock[] = "SOCK";
-        char    fifo[] = "FIFO";
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
 
-        nfs3_fh_to_str (fh, fhstr);
-        if (type == NF3CHR)
-                modestr = chr;
-        else if (type == NF3BLK)
-                modestr = blk;
-        else if (type == NF3SOCK)
-                modestr = sock;
-        else
-                modestr = fifo;
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
 
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, MKNOD: args: %s, name: %s,"
-                " type: %s", xid, fhstr, name, modestr);
-}
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
 
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
 
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
 
-void
-nfs3_log_symlink_call (uint32_t xid, struct nfs3_fh *fh, char *name, char *tgt)
-{
-        char    fhstr[1024];
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
 
-        nfs3_fh_to_str (fh, fhstr);
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, SYMLINK: args: %s, name: %s,"
-                " target: %s", xid, fhstr, name, tgt);
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
+        }
+
+        return ll;
 }
 
 
-void
-nfs3_log_link_call (uint32_t xid, struct nfs3_fh *fh, char *name,
-                    struct nfs3_fh *tgt)
-{
-        char    dfhstr[1024];
-        char    tfhstr[1024];
+int
+nfs3_readdir_loglevel (nfsstat3 stat) {
 
-        nfs3_fh_to_str (fh, dfhstr);
-        nfs3_fh_to_str (tgt, tfhstr);
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, LINK: args: %s, name: %s,"
-                " target: %s", xid, dfhstr, name, tfhstr);
+	int ll = GF_LOG_DEBUG;
+
+	switch (stat) {
+
+        case NFS3ERR_NOENT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_EXIST:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOSPC:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ROFS:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NAMETOOLONG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
+        }
+
+        return ll;
 }
 
 
-void
-nfs3_log_rw_call (uint32_t xid, char *op, struct nfs3_fh *fh, offset3 offt,
-                  count3 count, int stablewrite)
-{
-        char    fhstr[1024];
+int
+nfs3_fsstat_loglevel (nfsstat3 stat) {
 
-        nfs3_fh_to_str (fh, fhstr);
-        if (stablewrite == -1)
-                gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, %s: args: %s, offset:"
-                        " %"PRIu64",  count: %"PRIu32, xid, op, fhstr, offt,
-                        count);
-        else
-                gf_log (GF_NFS3, GF_LOG_DEBUG, "XID: %x, %s: args: %s, offset:"
-                        " %"PRIu64",  count: %"PRIu32", %s", xid, op, fhstr,
-                        offt, count,
-                        (stablewrite == UNSTABLE)?"UNSTABLE":"STABLE");
+	int ll = GF_LOG_DEBUG;
+
+	switch (stat) {
+
+        case NFS3ERR_PERM:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOENT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ACCES:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_EXIST:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_XDEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NODEV:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_IO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NXIO:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ISDIR:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_INVAL:
+		ll = GF_LOG_WARNING;
+                break;
 
+        case NFS3ERR_NOSPC:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_ROFS:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_FBIG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_MLINK:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NAMETOOLONG:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTEMPTY:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_SERVERFAULT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_NOTSUPP:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_BADHANDLE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_STALE:
+		ll = GF_LOG_WARNING;
+                break;
+
+        case NFS3ERR_DQUOT:
+		ll = GF_LOG_WARNING;
+                break;
+
+        default:
+		ll = GF_LOG_DEBUG;
+                break;
+        }
+
+        return ll;
 }
 
+struct nfs3op_str {
+	int	op;
+	char	str[100];
+};
+
+struct nfs3op_str nfs3op_strings[] = {
+	{ NFS3_NULL, "NULL"},
+	{ NFS3_GETATTR, "GETATTR"},
+	{ NFS3_SETATTR, "SETATTR"},
+	{ NFS3_LOOKUP, "LOOKUP"},
+	{ NFS3_ACCESS, "ACCESS"},
+	{ NFS3_READLINK, "READLINK"},
+	{ NFS3_READ, "READ"},
+	{ NFS3_WRITE, "WRITE"},
+	{ NFS3_CREATE, "CREATE"},
+	{ NFS3_MKDIR, "MKDIR"},
+	{ NFS3_SYMLINK, "SYMLINK"},
+	{ NFS3_MKNOD, "MKNOD"},
+	{ NFS3_REMOVE, "REMOVE"},
+	{ NFS3_RMDIR, "RMDIR"},
+	{ NFS3_RENAME, "RENAME"},
+	{ NFS3_LINK, "LINK"},
+	{ NFS3_READDIR, "READDIR"},
+	{ NFS3_READDIRP, "READDIRP"},
+	{ NFS3_FSSTAT, "FSSTAT"},
+	{ NFS3_FSINFO, "FSINFO"},
+	{ NFS3_PATHCONF, "PATHCONF"},
+	{ NFS3_COMMIT, "COMMIT"},
+};
+
+int
+nfs3_loglevel (int nfs_op, nfsstat3 stat) {
+
+	int	ll = GF_LOG_DEBUG;
+
+	switch (nfs_op) {
+	case NFS3_GETATTR:
+		ll = nfs3_getattr_loglevel (stat);
+		break;
+
+	case NFS3_SETATTR:
+		ll = nfs3_setattr_loglevel (stat);
+		break;
+
+	case NFS3_LOOKUP:
+		ll = nfs3_lookup_loglevel (stat);
+		break;
+
+	case NFS3_ACCESS:
+		ll = nfs3_access_loglevel (stat);
+		break;
+
+	case NFS3_READLINK:
+		ll = nfs3_readlink_loglevel (stat);
+		break;
+
+	case NFS3_READ:
+		ll = nfs3_read_loglevel (stat);
+		break;
+
+	case NFS3_WRITE:
+		ll = nfs3_write_loglevel (stat);
+		break;
+
+	case NFS3_CREATE:
+		ll = nfs3_create_loglevel (stat);
+		break;
+
+	case NFS3_MKDIR:
+		ll = nfs3_mkdir_loglevel (stat);
+		break;
+
+	case NFS3_SYMLINK:
+		ll = nfs3_symlink_loglevel (stat);
+		break;
+
+	case NFS3_MKNOD:
+		ll = nfs3_mknod_loglevel (stat);
+		break;
+
+	case NFS3_REMOVE:
+		ll = nfs3_remove_loglevel (stat);
+		break;
+
+	case NFS3_RMDIR:
+		ll = nfs3_rmdir_loglevel (stat);
+		break;
+
+	case NFS3_RENAME:
+		ll = nfs3_rename_loglevel (stat);
+		break;
+
+	case NFS3_LINK:
+		ll = nfs3_link_loglevel (stat);
+		break;
+
+	case NFS3_READDIR:
+		ll = nfs3_readdir_loglevel (stat);
+		break;
+
+	case NFS3_READDIRP:
+		ll = nfs3_readdir_loglevel (stat);
+		break;
+
+	case NFS3_FSSTAT:
+		ll = nfs3_fsstat_loglevel (stat);
+		break;
+
+	case NFS3_FSINFO:
+		ll = nfs3_fsstat_loglevel (stat);
+		break;
+
+	case NFS3_PATHCONF:
+		ll = nfs3_fsstat_loglevel (stat);
+		break;
+
+	case NFS3_COMMIT:
+		ll = nfs3_write_loglevel (stat);
+		break;
+
+	default:
+		ll = GF_LOG_DEBUG;
+		break;
+	}
+
+	return ll;
+}
 
 void
-nfs3_log_common_res (uint32_t xid, char *op, nfsstat3 stat, int pstat)
+nfs3_log_common_res (uint32_t xid, int op, nfsstat3 stat, int pstat)
 {
         char    errstr[1024];
+	int	ll = nfs3_loglevel (op, stat);
 
-        nfs3_stat_to_errstr (xid, op, stat, pstat, errstr);
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "%s", errstr);
+	if (gf_log_loglevel < ll)
+		return;
+        nfs3_stat_to_errstr (xid, nfs3op_strings[op].str, stat, pstat, errstr);
+        gf_log (GF_NFS3, ll, "%s", errstr);
 }
 
 void
 nfs3_log_readlink_res (uint32_t xid, nfsstat3 stat, int pstat, char *linkpath)
 {
         char    errstr[1024];
+	int	ll = nfs3_loglevel (NFS3_READLINK, stat);
+
+	if (gf_log_loglevel < ll)
+		return;
 
         nfs3_stat_to_errstr (xid, "READLINK", stat, pstat, errstr);
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "%s, target: %s", errstr, linkpath);
+        gf_log (GF_NFS3, ll, "%s, target: %s",
+		errstr, linkpath);
 
 }
 
@@ -2319,14 +3423,18 @@ nfs3_log_read_res (uint32_t xid, nfsstat3 stat, int pstat, count3 count,
                    int is_eof, struct iovec *vec, int32_t veccount)
 {
         char    errstr[1024];
+	int	ll = GF_LOG_DEBUG;
 
+	ll = nfs3_loglevel (NFS3_READ, stat);
+	if (gf_log_loglevel < ll)
+		return;
         nfs3_stat_to_errstr (xid, "READ", stat, pstat, errstr);
         if (vec)
-                gf_log (GF_NFS3, GF_LOG_DEBUG, "%s, count: %"PRIu32", is_eof:"
+                gf_log (GF_NFS3, ll, "%s, count: %"PRIu32", is_eof:"
                         " %d, vector: count: %d, len: %zd", errstr, count,
                         is_eof, veccount, vec->iov_len);
         else
-                gf_log (GF_NFS3, GF_LOG_DEBUG, "%s, count: %"PRIu32", is_eof:"
+                gf_log (GF_NFS3, ll, "%s, count: %"PRIu32", is_eof:"
                         " %d", errstr, count, is_eof);
 }
 
@@ -2336,25 +3444,32 @@ nfs3_log_write_res (uint32_t xid, nfsstat3 stat, int pstat, count3 count,
                     int stable, uint64_t wverf)
 {
         char    errstr[1024];
+	int	ll = nfs3_loglevel (NFS3_WRITE, stat);
+
+	if (gf_log_loglevel < ll)
+		return;
 
         nfs3_stat_to_errstr (xid, "WRITE", stat, pstat, errstr);
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "%s, count: %"PRIu32", %s,wverf: %"PRIu64
+        gf_log (GF_NFS3, ll, "%s, count: %"PRIu32", %s,wverf: %"PRIu64
                 , errstr, count, (stable == UNSTABLE)?"UNSTABLE":"STABLE",
                 wverf);
 }
 
 
 void
-nfs3_log_newfh_res (uint32_t xid, char *op, nfsstat3 stat, int pstat,
+nfs3_log_newfh_res (uint32_t xid, int op, nfsstat3 stat, int pstat,
                     struct nfs3_fh *newfh)
 {
         char    errstr[1024];
         char    fhstr[1024];
+	int	ll = nfs3_loglevel (op, stat);
 
-        nfs3_stat_to_errstr (xid, op, stat, pstat, errstr);
+	if (gf_log_loglevel < ll)
+		return;
+        nfs3_stat_to_errstr (xid, nfs3op_strings[op].str, stat, pstat, errstr);
         nfs3_fh_to_str (newfh, fhstr);
 
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "%s, %s", errstr, fhstr);
+        gf_log (GF_NFS3, nfs3_loglevel (op, stat), "%s, %s", errstr, fhstr);
 }
 
 
@@ -2363,9 +3478,12 @@ nfs3_log_readdir_res (uint32_t xid, nfsstat3 stat, int pstat, uint64_t cverf,
                       count3 count, int is_eof)
 {
         char    errstr[1024];
+	int	ll = nfs3_loglevel (NFS3_READDIR, stat);
 
+	if (gf_log_loglevel < ll)
+		return;
         nfs3_stat_to_errstr (xid, "READDIR", stat, pstat, errstr);
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "%s, count: %"PRIu32", cverf: %"PRIu64
+        gf_log (GF_NFS3, ll, "%s, count: %"PRIu32", cverf: %"PRIu64
                 ", is_eof: %d", errstr, count, cverf, is_eof);
 }
 
@@ -2375,9 +3493,12 @@ nfs3_log_readdirp_res (uint32_t xid, nfsstat3 stat, int pstat, uint64_t cverf,
                        count3 dircount, count3 maxcount, int is_eof)
 {
         char    errstr[1024];
+	int	ll = nfs3_loglevel (NFS3_READDIRP, stat);
 
+	if (gf_log_loglevel < ll)
+		return;
         nfs3_stat_to_errstr (xid, "READDIRPLUS", stat, pstat, errstr);
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "%s, dircount: %"PRIu32", maxcount: %"
+        gf_log (GF_NFS3, ll, "%s, dircount: %"PRIu32", maxcount: %"
                 PRIu32", cverf: %"PRIu64", is_eof: %d", errstr, dircount,
                 maxcount, cverf, is_eof);
 }
@@ -2387,9 +3508,12 @@ void
 nfs3_log_commit_res (uint32_t xid, nfsstat3 stat, int pstat, uint64_t wverf)
 {
         char    errstr[1024];
+	int	ll = nfs3_loglevel (NFS3_COMMIT, stat);
 
+	if (gf_log_loglevel < ll)
+		return;
         nfs3_stat_to_errstr (xid, "COMMIT", stat, pstat, errstr);
-        gf_log (GF_NFS3, GF_LOG_DEBUG, "%s, wverf: %"PRIu64, errstr, wverf);
+        gf_log (GF_NFS3, ll, "%s, wverf: %"PRIu64, errstr, wverf);
 }
 
 
@@ -2399,6 +3523,9 @@ nfs3_log_readdir_call (uint32_t xid, struct nfs3_fh *fh, count3 dircount,
 {
         char    fhstr[1024];
 
+	if (gf_log_loglevel < GF_LOG_DEBUG)
+		return;
+
         nfs3_fh_to_str (fh, fhstr);
 
         if (maxcount == 0)
@@ -2420,7 +3547,7 @@ nfs3_fh_resolve_inode_done (nfs3_call_state_t *cs, inode_t *inode)
                 return ret;
 
         gf_log (GF_NFS3, GF_LOG_TRACE, "FH inode resolved");
-        ret = nfs_inode_loc_fill (inode, &cs->resolvedloc);
+        ret = nfs_inode_loc_fill (inode, &cs->resolvedloc, NFS_RESOLVE_EXIST);
         if (ret < 0) {
                 gf_log (GF_NFS3, GF_LOG_ERROR, "inode loc fill failed");
                 goto err;
@@ -2505,6 +3632,8 @@ nfs3_fh_resolve_entry_lookup_cbk (call_frame_t *frame, void *cookie,
                 gf_log (GF_NFS3, GF_LOG_TRACE, "Entry looked up: %s",
                         cs->resolvedloc.path);
 
+	memcpy (&cs->stbuf, buf, sizeof (*buf));
+	memcpy (&cs->postparent, postparent, sizeof (*postparent));
         linked_inode = inode_link (inode, cs->resolvedloc.parent,
                                    cs->resolvedloc.name, buf);
         if (linked_inode) {
@@ -2517,12 +3646,6 @@ err:
 }
 
 
-
-int32_t
-nfs3_fh_resolve_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno,
-                             gf_dirent_t *entries);
-
 int
 nfs3_fh_resolve_found_entry (nfs3_call_state_t *cs, gf_dirent_t *candidate)
 {
@@ -2637,52 +3760,13 @@ nfs3_fh_resolve_found (nfs3_call_state_t *cs, gf_dirent_t *candidate)
 
 
 int32_t
-nfs3_fh_resolve_opendir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno, fd_t *fd)
-{
-        nfs3_call_state_t       *cs = NULL;
-        int                     ret = -EFAULT;
-        nfs_user_t              nfu = {0, };
-
-        cs = frame->local;
-        cs->resolve_ret = op_ret;
-        cs->resolve_errno = op_errno;
-
-        if (op_ret == -1) {
-                gf_log (GF_NFS3, GF_LOG_ERROR, "Dir open failed: %s: %s",
-                        cs->resolvedloc.path, strerror (op_errno));
-                nfs3_call_resume (cs);
-                goto err;
-        } else
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Reading directory: %s",
-                        cs->resolvedloc.path);
-
-        nfs_user_root_create (&nfu);
-        /* Keep this directory fd_t around till we have either:
-         * a. found the entry,
-         * b. exhausted all the entries,
-         * c. decide to step into a child directory.
-         *
-         * This decision is made in nfs3_fh_resolve_check_response.
-         */
-        cs->resolve_dir_fd = fd;
-        gf_log (GF_NFS3, GF_LOG_TRACE, "resolve new fd refed: 0x%lx, ref: %d",
-                (long)cs->resolve_dir_fd, cs->resolve_dir_fd->refcount);
-        ret = nfs_readdirp (cs->nfsx, cs->vol, &nfu, fd, GF_NFS3_DTPREF, 0,
-                            nfs3_fh_resolve_readdir_cbk, cs);
-
-err:
-        return ret;
-}
-
-int32_t
-nfs3_fh_resolve_dir_lookup_cbk (call_frame_t *frame, void *cookie,
-                                xlator_t *this, int32_t op_ret,int32_t op_errno,
-                                inode_t *inode, struct iatt *buf, dict_t *xattr,
-                                struct iatt *postparent)
+nfs3_fh_resolve_inode_lookup_cbk (call_frame_t *frame, void *cookie,
+                                  xlator_t *this, int32_t op_ret,
+                                  int32_t op_errno, inode_t *inode,
+                                  struct iatt *buf, dict_t *xattr,
+                                  struct iatt *postparent)
 {
         nfs3_call_state_t       *cs = NULL;
-        nfs_user_t              nfu = {0, };
         inode_t                 *linked_inode = NULL;
 
         cs = frame->local;
@@ -2695,21 +3779,27 @@ nfs3_fh_resolve_dir_lookup_cbk (call_frame_t *frame, void *cookie,
                         cs->resolvedloc.path, strerror (op_errno));
                 nfs3_call_resume (cs);
                 goto err;
-        } else
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Dir will be opened: %s",
-                        cs->resolvedloc.path);
+        }
 
-        nfs_user_root_create (&nfu);
+	memcpy (&cs->stbuf, buf, sizeof(*buf));
+	memcpy (&cs->postparent, buf, sizeof(*postparent));
         linked_inode = inode_link (inode, cs->resolvedloc.parent,
                                    cs->resolvedloc.name, buf);
         if (linked_inode) {
                 inode_lookup (linked_inode);
-                inode_unref (linked_inode);
+		inode_unref (cs->resolvedloc.inode);
+		cs->resolvedloc.inode = linked_inode;
         }
 
-        nfs_opendir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                     nfs3_fh_resolve_opendir_cbk, cs);
-
+        /* If it is an entry lookup and we landed in the callback for hard
+         * inode resolution, it means the parent inode was not available and
+         * had to be resolved first. Now that is done, lets head back into
+         * entry resolution.
+         */
+        if (cs->resolventry)
+                nfs3_fh_resolve_entry_hard (cs);
+	else
+		nfs3_call_resume (cs);
 err:
         return 0;
 }
@@ -2752,47 +3842,6 @@ out:
 }
 
 
-int
-nfs3_fh_resolve_dir_hard (nfs3_call_state_t *cs, uuid_t dirgfid, char *entry)
-{
-        int             ret = -EFAULT;
-        nfs_user_t      nfu = {0, };
-
-        if (!cs)
-                return ret;
-
-        cs->hashidx++;
-        nfs_loc_wipe (&cs->resolvedloc);
-        if (!nfs3_fh_resolve_validate_dirdepth (cs)) {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Dir depth validation failed");
-                nfs3_call_resume_estale (cs);
-                ret = 0;
-                goto out;
-        }
-
-        nfs_user_root_create (&nfu);
-        gf_log (GF_NFS3, GF_LOG_TRACE, "FH hard dir resolution: gfid: %s, "
-                "entry: %s, next hashcount: %d", uuid_utoa (dirgfid), entry,
-                cs->hashidx);
-        ret = nfs_entry_loc_fill (cs->vol->itable, dirgfid, entry,
-                                  &cs->resolvedloc, NFS_RESOLVE_CREATE);
-
-        if (ret == 0) {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Dir will be opened: %s",
-                        cs->resolvedloc.path);
-                ret = nfs_opendir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                   nfs3_fh_resolve_opendir_cbk, cs);
-        } else if (ret == -ENOENT) {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Dir needs lookup: %s",
-                        cs->resolvedloc.path);
-                ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                  nfs3_fh_resolve_dir_lookup_cbk, cs);
-        }
-out:
-        return ret;
-}
-
-
 /*
  * Called in a recursive code path, so if another
  * directory was opened in an earlier call during fh resolution, we must unref
@@ -2831,100 +3880,6 @@ nfs3_fh_resolve_determine_response (nfs3_call_state_t *cs) {
 }
 
 
-int
-nfs3_fh_resolve_check_response (nfs3_call_state_t *cs)
-{
-        int             ret = -EFAULT;
-        nfs_user_t      nfu = {0, };
-        int             response = GF_NFS3_FHRESOLVE_NOTFOUND;
-
-        if (!cs)
-                return ret;
-
-        response = nfs3_fh_resolve_determine_response (cs);
-        switch (response) {
-
-        case GF_NFS3_FHRESOLVE_DIRFOUND:
-                nfs3_fh_resolve_close_cwd (cs);
-                nfs3_fh_resolve_dir_hard (cs, cs->resolvedloc.inode->gfid,
-                                          cs->hashmatch->d_name);
-                break;
-
-        case GF_NFS3_FHRESOLVE_FOUND:
-                nfs3_fh_resolve_close_cwd (cs);
-                nfs3_fh_resolve_found (cs, cs->entrymatch);
-                break;
-
-        case GF_NFS3_FHRESOLVE_NOTFOUND:
-                nfs_user_root_create (&nfu);
-                nfs_readdirp (cs->nfsx, cs->vol, &nfu, cs->resolve_dir_fd,
-                              GF_NFS3_DTPREF, cs->lastentryoffset,
-                              nfs3_fh_resolve_readdir_cbk, cs);
-                break;
-        }
-
-        return 0;
-}
-
-int
-nfs3_fh_resolve_search_dir (nfs3_call_state_t *cs, gf_dirent_t *entries)
-{
-        gf_dirent_t     *candidate = NULL;
-        int             ret = GF_NFS3_FHRESOLVE_NOTFOUND;
-
-        if ((!cs) || (!entries))
-                return -EFAULT;
-
-        if (list_empty (&entries->list))
-                goto search_done;
-
-        list_for_each_entry (candidate, &entries->list, list) {
-                cs->lastentryoffset = candidate->d_off;
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Candidate: %s, gfid: %s",
-                        candidate->d_name,
-                        uuid_utoa (candidate->d_stat.ia_gfid));
-                ret = nfs3_fh_resolve_check_entry (&cs->resolvefh, candidate,
-                                                   cs->hashidx);
-                if (ret == GF_NFS3_FHRESOLVE_FOUND)
-                        cs->entrymatch = gf_dirent_for_name (candidate->d_name);
-                else if (ret == GF_NFS3_FHRESOLVE_DIRFOUND) {
-                        if (cs->hashmatch)
-                                gf_dirent_free (cs->hashmatch);
-                        cs->hashmatch = gf_dirent_for_name (candidate->d_name);
-                }
-        }
-
-search_done:
-        return ret;
-}
-
-
-int32_t
-nfs3_fh_resolve_readdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
-                             int32_t op_ret, int32_t op_errno,
-                             gf_dirent_t *entries)
-{
-        nfs3_call_state_t       *cs = NULL;
-        nfs_user_t              nfu = {0, };
-
-        cs = frame->local;
-        if (op_ret <= 0) {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Directory read done: %s: %s",
-                        cs->resolvedloc.path, strerror (op_ret));
-                nfs3_fh_resolve_check_response (cs);
-                goto err;
-        }
-
-        nfs3_fh_resolve_search_dir (cs, entries);
-        nfs_user_root_create (&nfu);
-        nfs_readdirp (cs->nfsx, cs->vol, &nfu, cs->resolve_dir_fd,
-                      GF_NFS3_DTPREF, cs->lastentryoffset,
-                      nfs3_fh_resolve_readdir_cbk, cs);
-
-err:
-        return 0;
-}
-
 /* Needs no extra argument since it knows that the fh to be resolved is in
  * resolvefh and that it needs to start looking from the root.
  */
@@ -2937,33 +3892,21 @@ nfs3_fh_resolve_inode_hard (nfs3_call_state_t *cs)
         if (!cs)
                 return ret;
 
-        cs->hashidx++;
+        gf_log (GF_NFS3, GF_LOG_TRACE, "FH hard resolution for: gfid 0x%s",
+                uuid_utoa (cs->resolvefh.gfid));
+	cs->hardresolved = 1;
         nfs_loc_wipe (&cs->resolvedloc);
-        if (!nfs3_fh_resolve_validate_dirdepth (cs)) {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Dir depth validation failed");
-                nfs3_call_resume_estale (cs);
-                ret = 0;
+        ret = nfs_gfid_loc_fill (cs->vol->itable, cs->resolvefh.gfid,
+                                 &cs->resolvedloc, NFS_RESOLVE_CREATE);
+        if (ret < 0) {
+                gf_log (GF_NFS3, GF_LOG_ERROR, "Failed to fill loc using gfid: "
+                        "%s", strerror (-ret));
                 goto out;
         }
 
         nfs_user_root_create (&nfu);
-        gf_log (GF_NFS3, GF_LOG_TRACE, "FH hard resolution for: gfid 0x%s"
-                ", hashcount: %d, current hashidx %d",
-                uuid_utoa (cs->resolvefh.gfid),
-                cs->resolvefh.hashcount, cs->hashidx);
-        ret = nfs_root_loc_fill (cs->vol->itable, &cs->resolvedloc);
-
-        if (ret == 0) {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Dir will be opened: %s",
-                        cs->resolvedloc.path);
-                ret = nfs_opendir (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                   nfs3_fh_resolve_opendir_cbk, cs);
-        } else if (ret == -ENOENT) {
-                gf_log (GF_NFS3, GF_LOG_TRACE, "Dir needs lookup: %s",
-                        cs->resolvedloc.path);
-                ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                  nfs3_fh_resolve_dir_lookup_cbk, cs);
-        }
+        ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                          nfs3_fh_resolve_inode_lookup_cbk, cs);
 
 out:
         return ret;
@@ -2982,8 +3925,8 @@ nfs3_fh_resolve_entry_hard (nfs3_call_state_t *cs)
         nfs_loc_wipe (&cs->resolvedloc);
         nfs_user_root_create (&nfu);
         gf_log (GF_NFS3, GF_LOG_TRACE, "FH hard resolution: gfid: %s "
-                ", entry: %s, hashidx: %d", uuid_utoa (cs->resolvefh.gfid),
-                cs->resolventry, cs->hashidx);
+                ", entry: %s", uuid_utoa (cs->resolvefh.gfid),
+                cs->resolventry);
 
         ret = nfs_entry_loc_fill (cs->vol->itable, cs->resolvefh.gfid,
                                   cs->resolventry, &cs->resolvedloc,
@@ -2992,13 +3935,22 @@ nfs3_fh_resolve_entry_hard (nfs3_call_state_t *cs)
         if (ret == -2) {
                 gf_log (GF_NFS3, GF_LOG_TRACE, "Entry needs lookup: %s",
                         cs->resolvedloc.path);
-                if (nfs3_lookup_op (cs)) {
+		/* If the NFS op is lookup, let the resume callback
+		 * handle the sending of the lookup fop. Similarly,
+		 * if the NFS op is create, let the create call
+		 * go ahead in the resume callback so that an EEXIST gets
+		 * handled at posix without an extra fop at this point.
+		 */
+                if (nfs3_lookup_op (cs) ||
+		    (nfs3_create_op (cs) && !nfs3_create_exclusive_op (cs))) {
                         cs->lookuptype = GF_NFS3_FRESH;
                         cs->resolve_ret = 0;
                         nfs3_call_resume (cs);
-                } else
+                } else {
+			cs->hardresolved = 1;
                         nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
                                     nfs3_fh_resolve_entry_lookup_cbk, cs);
+		}
                 ret = 0;
         } else if (ret == -1) {
                 gf_log (GF_NFS3, GF_LOG_TRACE, "Entry needs parent lookup: %s",
@@ -3022,6 +3974,7 @@ nfs3_fh_resolve_inode (nfs3_call_state_t *cs)
                 return ret;
 
         gf_log (GF_NFS3, GF_LOG_TRACE, "FH needs inode resolution");
+        uuid_copy (cs->resolvedloc.gfid, cs->resolvefh.gfid);
         inode = inode_find (cs->vol->itable, cs->resolvefh.gfid);
         if (!inode)
                 ret = nfs3_fh_resolve_inode_hard (cs);
@@ -3119,6 +4072,11 @@ nfs3_fh_resolve_root (nfs3_call_state_t *cs)
         nfs_user_root_create (&nfu);
         gf_log (GF_NFS3, GF_LOG_TRACE, "Root needs lookup");
         ret = nfs_root_loc_fill (cs->vol->itable, &cs->resolvedloc);
+	if (ret < 0) {
+		gf_log (GF_NFS3, GF_LOG_ERROR, "Failed to lookup root from itable: %s",
+			strerror (-ret));
+		goto out;
+	}
 
         ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
                           nfs3_fh_resolve_root_lookup_cbk, cs);
diff --git a/xlators/nfs/server/src/nfs3-helpers.h b/xlators/nfs/server/src/nfs3-helpers.h
index ebe3aa7dc82..67935d143e3 100644
--- a/xlators/nfs/server/src/nfs3-helpers.h
+++ b/xlators/nfs/server/src/nfs3-helpers.h
@@ -255,7 +255,7 @@ extern int
 nfs3_cached_inode_opened (xlator_t *nfsxl, inode_t *inode);
 
 extern void
-nfs3_log_common_res (uint32_t xid, char *op, nfsstat3 stat, int pstat);
+nfs3_log_common_res (uint32_t xid, int op, nfsstat3 stat, int pstat);
 
 extern void
 nfs3_log_readlink_res (uint32_t xid, nfsstat3 stat, int pstat, char *linkpath);
@@ -269,7 +269,7 @@ nfs3_log_write_res (uint32_t xid, nfsstat3 stat, int pstat, count3 count,
                     int stable, uint64_t wverf);
 
 extern void
-nfs3_log_newfh_res (uint32_t xid, char *op, nfsstat3 stat, int pstat,
+nfs3_log_newfh_res (uint32_t xid, int op, nfsstat3 stat, int pstat,
                     struct nfs3_fh *newfh);
 
 extern void
@@ -330,25 +330,13 @@ nfs3_fh_resolve_and_resume (nfs3_call_state_t *cs, struct nfs3_fh *fh,
                             char *entry, nfs3_resume_fn_t resum_fn);
 
 extern int
-nfs3_file_open_and_resume (nfs3_call_state_t *cs, nfs3_resume_fn_t resume);
-
-extern int
-nfs3_dir_open_and_resume (nfs3_call_state_t *cs, nfs3_resume_fn_t resume);
-
-extern int
 nfs3_verify_dircookie (struct nfs3_state *nfs3, fd_t *dirfd, cookie3 cookie,
                        uint64_t cverf, nfsstat3 *stat);
 
 extern int
-nfs3_fdcache_remove (struct nfs3_state *nfs3, fd_t *fd);
-
-extern int
 nfs3_is_parentdir_entry (char *entry);
 
 uint32_t
 nfs3_request_to_accessbits (int32_t accbits);
 
-int
-nfs3_flush_inode_queue (struct inode_op_queue *inode_q, fd_t *openedfd,
-                        int32_t call_resume);
 #endif
diff --git a/xlators/nfs/server/src/nfs3.c b/xlators/nfs/server/src/nfs3.c
index d78360502a1..3c540b36fe4 100644
--- a/xlators/nfs/server/src/nfs3.c
+++ b/xlators/nfs/server/src/nfs3.c
@@ -684,7 +684,7 @@ nfs3svc_getattr_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 status = nfs3_errno_to_nfsstat3 (op_errno);
         }
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req), "GETATTR",
+        nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_GETATTR,
                              status, op_errno);
 
         nfs3_getattr_reply (cs->req, status, buf);
@@ -710,7 +710,7 @@ nfs3svc_getattr_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 status = nfs3_errno_to_nfsstat3 (op_errno);
         }
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req), "GETATTR",
+        nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_GETATTR,
                              status, op_errno);
 
         nfs3_getattr_reply (cs->req, status, buf);
@@ -739,13 +739,22 @@ nfs3_getattr_resume (void *carg)
          * for the root to have been looked up when the getattr on the root is
          * sent. AND, this causes a problem for stat-prefetch in that it
          * expects even the root inode to have been looked up.
-         */
+
         if (__is_root_gfid (cs->resolvedloc.inode->gfid))
                 ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
                                   nfs3svc_getattr_lookup_cbk, cs);
         else
                 ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                nfs3svc_getattr_stat_cbk, cs);
+        */
+
+	if (cs->hardresolved) {
+		ret = -EFAULT;
+		stat = NFS3_OK;
+		goto nfs3err;
+	}
+
+        ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                        nfs3svc_getattr_stat_cbk, cs);
 
         if (ret < 0) {
                 gf_log (GF_NFS3, GF_LOG_ERROR, "Stat fop failed: %s: %s",
@@ -756,8 +765,8 @@ nfs3_getattr_resume (void *carg)
 nfs3err:
         if (ret < 0) {
                 nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     "GETATTR", stat, -ret);
-                nfs3_getattr_reply (cs->req, stat, NULL);
+                                     NFS3_GETATTR, stat, -ret);
+                nfs3_getattr_reply (cs->req, stat, &cs->stbuf);
                 nfs3_call_state_wipe (cs);
                 ret = 0;
         }
@@ -791,7 +800,7 @@ nfs3_getattr (rpcsvc_request_t *req, struct nfs3_fh *fh)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "GETATTR",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_GETATTR,
                                      stat, -ret);
                 nfs3_getattr_reply (req, stat, NULL);
                 ret = 0;
@@ -875,7 +884,7 @@ nfs3svc_truncate_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
         stat = NFS3_OK;
 nfs3err:
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req), "SETATTR", stat,
+        nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_SETATTR, stat,
                              op_errno);
         nfs3_setattr_reply (cs->req, stat, prestat, postbuf);
         nfs3_call_state_wipe (cs);
@@ -904,18 +913,11 @@ nfs3svc_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 goto nfs3err;
         }
 
-        /* If the first stat was got from the guarded setattr callback, then
-         * we'll need to use that stat instead of the preop returned here.
+        prebuf = preop;
+        /* Store the current preop in case we need to send a truncate,
+         * in which case the preop to be returned will be this one.
          */
-        if (cs->preparent.ia_ino != 0)
-                prebuf = &cs->preparent;
-        else {
-                prebuf = preop;
-                /* Store the current preop in case we need to send a truncate,
-                 * in which case the preop to be returned will be this one.
-                 */
-                cs->preparent = *preop;
-        }
+        cs->preparent = *preop;
 
         /* Only truncate if the size is not already same as the requested
          * truncation and also only if this is not a directory.
@@ -936,7 +938,7 @@ nfs3svc_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 nfs3err:
         if (ret < 0) {
                 nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     "SETATTR", stat, op_errno);
+                                     NFS3_SETATTR, stat, op_errno);
                 nfs3_setattr_reply (cs->req, stat, prebuf, postop);
                 nfs3_call_state_wipe (cs);
         }
@@ -982,7 +984,7 @@ nfs3svc_setattr_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 nfs3err:
         if (ret < 0) {
                 nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     "SETATTR", stat, op_errno);
+                                     NFS3_SETATTR, stat, op_errno);
                 nfs3_setattr_reply (cs->req, stat, NULL, NULL);
                 nfs3_call_state_wipe (cs);
         }
@@ -1005,14 +1007,9 @@ nfs3_setattr_resume (void *carg)
         cs = (nfs3_call_state_t *)carg;
         nfs3_check_fh_resolve_status (cs, stat, nfs3err);
         nfs_request_user_init (&nfu, cs->req);
-        /* If no ctime check is required, head straight to setting the attrs. */
-        if (cs->sattrguardcheck)
-                ret = nfs_stat (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                nfs3svc_setattr_stat_cbk, cs);
-        else
-                ret = nfs_setattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                   &cs->stbuf, cs->setattr_valid,
-                                   nfs3svc_setattr_cbk, cs);
+        ret = nfs_setattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
+                           &cs->stbuf, cs->setattr_valid,
+                           nfs3svc_setattr_cbk, cs);
 
         if (ret < 0)
                 stat = nfs3_errno_to_nfsstat3 (-ret);
@@ -1020,7 +1017,7 @@ nfs3_setattr_resume (void *carg)
 nfs3err:
         if (ret < 0) {
                 nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     "SETATTR", stat, -ret);
+                                     NFS3_SETATTR, stat, -ret);
                 nfs3_setattr_reply (cs->req, stat, NULL, NULL);
                 nfs3_call_state_wipe (cs);
         }
@@ -1076,7 +1073,7 @@ nfs3_setattr (rpcsvc_request_t *req, struct nfs3_fh *fh, sattr3 *sattr,
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "SETATTR",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_SETATTR,
                                      stat, -ret);
                 nfs3_setattr_reply (req, stat, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -1194,7 +1191,7 @@ xmit_res:
                 goto out;
         }
 
-        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), "LOOKUP", status,
+        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), NFS3_LOOKUP, status,
                             op_errno, &newfh);
         nfs3_lookup_reply (cs->req, status, &newfh, buf, postparent);
         nfs3_call_state_wipe (cs);
@@ -1247,7 +1244,7 @@ nfs3svc_lookup_parentdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }
 
 xmit_res:
-        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), "LOOKUP", status,
+        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), NFS3_LOOKUP, status,
                             op_errno, &newfh);
         nfs3_lookup_reply (cs->req, status, &newfh, buf, postparent);
         nfs3_call_state_wipe (cs);
@@ -1297,7 +1294,8 @@ nfs3_lookup_parentdir_resume (void *carg)
         if (!nfs3_fh_is_root_fh (&cs->fh)) {
                 parent = inode_ref (cs->resolvedloc.parent);
                 nfs_loc_wipe (&cs->resolvedloc);
-                ret = nfs_inode_loc_fill (parent, &cs->resolvedloc);
+                ret = nfs_inode_loc_fill (parent, &cs->resolvedloc,
+                                          NFS_RESOLVE_CREATE);
 
                 if (ret < 0) {
                         gf_log (GF_NFS3, GF_LOG_ERROR, "nfs_inode_loc_fill"
@@ -1314,7 +1312,7 @@ errtostat:
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "LOOKUP",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_LOOKUP,
                                      stat, -ret);
                 nfs3_lookup_reply (cs->req, stat, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -1334,11 +1332,18 @@ nfs3_lookup_resume (void *carg)
         int                             ret = -EFAULT;
         nfs_user_t                      nfu = {0, };
         nfs3_call_state_t               *cs = NULL;
+        struct nfs3_fh                  newfh = {{0},};
 
         GF_VALIDATE_OR_GOTO (GF_NFS3, carg, nfs3err);
 
         cs = (nfs3_call_state_t *)carg;
         nfs3_check_fh_resolve_status (cs, stat, nfs3err);
+	if (cs->hardresolved) {
+		stat = NFS3_OK;
+		nfs3_fh_build_child_fh (&cs->parent, &cs->stbuf, &newfh);
+		goto nfs3err;
+	}
+
         nfs_request_user_init (&nfu, cs->req);
         cs->parent = cs->resolvefh;
         ret = nfs_lookup (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
@@ -1348,9 +1353,10 @@ nfs3_lookup_resume (void *carg)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "LOOKUP",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_LOOKUP,
                                      stat, -ret);
-                nfs3_lookup_reply (cs->req, stat, NULL, NULL, NULL);
+                nfs3_lookup_reply (cs->req, stat, &newfh, &cs->stbuf,
+				   &cs->postparent);
                 nfs3_call_state_wipe (cs);
         }
 
@@ -1398,7 +1404,7 @@ nfs3_lookup (rpcsvc_request_t *req, struct nfs3_fh *fh, int fhlen, char *name)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "LOOKUP",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_LOOKUP,
                                      stat,
                                      -ret);
                 nfs3_lookup_reply (req, stat, NULL, NULL, NULL);
@@ -1469,7 +1475,7 @@ nfs3svc_access_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                         cs->resolvedloc.path, strerror (op_errno));
                 status = nfs3_errno_to_nfsstat3 (op_errno);
         }
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req), "ACCESS", status,
+        nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_ACCESS, status,
                              op_errno);
         nfs3_access_reply (cs->req, status, op_errno);
         nfs3_call_state_wipe (cs);
@@ -1498,7 +1504,7 @@ nfs3_access_resume (void *carg)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "ACCESS",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_ACCESS,
                                      stat, -ret);
                 nfs3_access_reply (cs->req, stat, 0);
                 nfs3_call_state_wipe (cs);
@@ -1534,7 +1540,7 @@ nfs3_access (rpcsvc_request_t *req, struct nfs3_fh *fh, uint32_t accbits)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "ACCESS",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_ACCESS,
                                      stat, -ret);
                 nfs3_access_reply (req, stat, 0);
                 nfs3_call_state_wipe (cs);
@@ -1641,7 +1647,7 @@ nfs3_readlink_resume (void *carg)
 nfs3err:
         if (ret < 0) {
                 nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     "READLINK", stat, -ret);
+                                     NFS3_READLINK, stat, -ret);
                 nfs3_readlink_reply (cs->req, stat, NULL, NULL);
                 nfs3_call_state_wipe (cs);
         }
@@ -1677,7 +1683,7 @@ nfs3_readlink (rpcsvc_request_t *req, struct nfs3_fh *fh)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "READLINK",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_READLINK,
                                      stat, -ret);
                 nfs3_readlink_reply (req, stat, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -1808,7 +1814,7 @@ nfs3_read_fd_resume (void *carg)
                 stat = nfs3_errno_to_nfsstat3 (-ret);
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "READ",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_READ,
                                      stat, -ret);
                 nfs3_read_reply (cs->req, stat, 0, NULL, 0, NULL, NULL, 0);
                 nfs3_call_state_wipe (cs);
@@ -1824,19 +1830,25 @@ nfs3_read_resume (void *carg)
         nfsstat3                        stat = NFS3ERR_SERVERFAULT;
         int                             ret = -EFAULT;
         nfs3_call_state_t               *cs = NULL;
+        fd_t                            *fd = NULL;
 
         if (!carg)
                 return ret;
 
         cs = (nfs3_call_state_t *)carg;
         nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        ret = nfs3_file_open_and_resume (cs, nfs3_read_fd_resume);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
+        fd = fd_anonymous (cs->resolvedloc.inode);
+        if (!fd) {
+                gf_log (GF_NFS3, GF_LOG_ERROR, "Failed to create anonymous fd");
+                goto nfs3err;
+        }
 
+        cs->fd = fd;
+        nfs3_read_fd_resume (cs);
+        ret = 0;
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "READ",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_READ,
                                      stat, -ret);
                 nfs3_read_reply (cs->req, stat, 0, NULL,0, NULL, NULL, 0);
                 nfs3_call_state_wipe (cs);
@@ -1876,7 +1888,7 @@ nfs3_read (rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset,
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "READ", stat,
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_READ, stat,
                                      -ret);
                 nfs3_read_reply (req, stat, 0, NULL,0, NULL, NULL, 0);
                 nfs3_call_state_wipe (cs);
@@ -2125,46 +2137,26 @@ nfs3_write_resume (void *carg)
         nfsstat3                stat = NFS3ERR_SERVERFAULT;
         int                     ret = -EFAULT;
         nfs3_call_state_t       *cs = NULL;
+        fd_t                    *fd = NULL;
 
         if (!carg)
                 return ret;
 
         cs = (nfs3_call_state_t *)carg;
         nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-
-        ret = __nfs3_write_resume (cs);
-        if (ret < 0)
-                stat = nfs3_errno_to_nfsstat3 (-ret);
-nfs3err:
-        if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "WRITE",
-                                     stat, -ret);
-                nfs3_write_reply (cs->req, stat, 0, cs->writetype, 0, NULL,
-                                  NULL);
-                nfs3_call_state_wipe (cs);
+        fd = fd_anonymous (cs->resolvedloc.inode);
+        if (!fd) {
+                gf_log (GF_NFS3, GF_LOG_ERROR, "Failed to create anonymous fd");
+                goto nfs3err;
         }
-        return ret;
-}
 
-
-int
-nfs3_write_open_resume (void *carg)
-{
-        nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        int                     ret = -EFAULT;
-        nfs3_call_state_t       *cs = NULL;
-
-        if (!carg)
-                return ret;
-
-        cs = (nfs3_call_state_t *)carg;
-        nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        ret = nfs3_file_open_and_resume (cs, nfs3_write_resume);
+        cs->fd = fd;    /* Gets unrefd when the call state is wiped. */
+        ret = __nfs3_write_resume (cs);
         if (ret < 0)
                 stat = nfs3_errno_to_nfsstat3 (-ret);
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "WRITE",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_WRITE,
                                      stat, -ret);
                 nfs3_write_reply (cs->req, stat, 0, cs->writetype, 0, NULL,
                                   NULL);
@@ -2174,7 +2166,6 @@ nfs3err:
 }
 
 
-
 int
 nfs3_write (rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset,
             count3 count, stable_how stable, struct iovec payload,
@@ -2206,13 +2197,13 @@ nfs3_write (rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset,
         cs->datavec = payload;
 
 
-        ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_write_open_resume);
+        ret = nfs3_fh_resolve_and_resume (cs, fh, NULL, nfs3_write_resume);
         if (ret < 0)
                 stat = nfs3_errno_to_nfsstat3 (-ret);
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "WRITE",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_WRITE,
                                      stat, -ret);
                 nfs3_write_reply (req, stat, 0, stable, 0, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -2334,7 +2325,7 @@ nfs3svc_create_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
         stat = NFS3_OK;
 nfs3err:
-        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), "CREATE", stat,
+        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), NFS3_CREATE, stat,
                             op_errno, &cs->fh);
         nfs3_create_reply (cs->req, stat, &cs->fh, postop, &cs->preparent,
                            &cs->postparent);
@@ -2354,6 +2345,7 @@ nfs3svc_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         int                     ret = -EFAULT;
         nfs_user_t              nfu = {0, };
         nfs3_call_state_t       *cs = NULL;
+	inode_t			*oldinode = NULL;
 
         cs = frame->local;
         if (op_ret == -1) {
@@ -2365,6 +2357,8 @@ nfs3svc_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }
 
         nfs3_fh_build_child_fh (&cs->parent, buf, &cs->fh);
+        oldinode = inode_link (inode, cs->resolvedloc.parent,
+                               cs->resolvedloc.name, buf);
 
         /* Means no attributes were required to be set. */
         if (!cs->setattr_valid) {
@@ -2376,14 +2370,20 @@ nfs3svc_create_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         cs->preparent = *preparent;
         cs->postparent = *postparent;
         nfs_request_user_init (&nfu, cs->req);
+        uuid_copy (cs->resolvedloc.gfid, inode->gfid);
         ret = nfs_setattr (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,&cs->stbuf,
                            cs->setattr_valid, nfs3svc_create_setattr_cbk, cs);
         if (ret < 0)
                 stat = nfs3_errno_to_nfsstat3 (-ret);
 
 nfs3err:
+        if (oldinode) {
+                inode_lookup (oldinode);
+                inode_unref (oldinode);
+        }
+
         if (ret < 0) {
-                nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), "CREATE",
+                nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), NFS3_CREATE,
                                     stat, op_errno, &cs->fh);
                 nfs3_create_reply (cs->req, stat, &cs->fh, buf, preparent,
                                    postparent);
@@ -2399,16 +2399,30 @@ nfs3_create_common (nfs3_call_state_t *cs)
         int                     ret = -EFAULT;
         int                     flags = 0;
         nfs_user_t              nfu = {0, };
+        uid_t                   uid = 0;
+        gid_t                   gid = 0;
 
         if (!cs)
                 return ret;
 
-        if (cs->createmode == UNCHECKED)
-                flags = O_RDWR;
-        else if (cs->createmode == GUARDED)
+        if (cs->createmode == GUARDED)
                 flags = (O_RDWR | O_EXCL);
+        else
+                flags = O_RDWR;
 
-        nfs_request_user_init (&nfu, cs->req);
+        if (gf_attr_uid_set (cs->setattr_valid)) {
+                uid = cs->stbuf.ia_uid;
+                cs->setattr_valid &= ~GF_SET_ATTR_UID;
+        } else
+                uid = rpcsvc_request_uid (cs->req);
+
+        if (gf_attr_gid_set (cs->setattr_valid)) {
+                gid = cs->stbuf.ia_gid;
+                cs->setattr_valid &= ~GF_SET_ATTR_GID;
+        } else
+                gid = rpcsvc_request_gid (cs->req);
+
+        nfs_request_primary_user_init (&nfu, cs->req, uid, gid);
         /* We can avoid sending the setattr call later if only the mode is
          * required to be set. This is possible because the create fop allows
          * us to specify a mode arg.
@@ -2464,7 +2478,7 @@ nfs3svc_create_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "CREATE",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_CREATE,
                                      stat, op_errno);
                 nfs3_create_reply (cs->req, stat, &cs->fh, buf, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -2505,16 +2519,7 @@ nfs3_create_exclusive (nfs3_call_state_t *cs)
                 goto nfs3err;
         }
 
-        if (cs->setattr_valid & GF_SET_ATTR_MODE) {
-                cs->setattr_valid &= ~GF_SET_ATTR_MODE;
-                ret = nfs_create (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                  O_RDWR, cs->mode, nfs3svc_create_cbk, cs);
-        } else
-                ret = nfs_create (cs->nfsx, cs->vol, &nfu, &cs->resolvedloc,
-                                  O_RDWR,
-                                  NFS_DEFAULT_CREATE_MODE, nfs3svc_create_cbk,
-                                  cs);
-
+        ret = nfs3_create_common (cs);
 nfs3err:
         return ret;
 }
@@ -2543,7 +2548,7 @@ nfs3_create_resume (void *carg)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "CREATE",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_CREATE,
                                      stat, -ret);
                 nfs3_create_reply (cs->req, stat, NULL, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -2590,7 +2595,7 @@ nfs3_create (rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name,
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "CREATE",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_CREATE,
                                      stat, -ret);
                 nfs3_create_reply (req, stat, NULL, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -2678,7 +2683,7 @@ nfs3svc_mkdir_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
         stat = NFS3_OK;
 nfs3err:
-        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), "MKDIR", stat,
+        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), NFS3_MKDIR, stat,
                             op_errno, &cs->fh);
         nfs3_mkdir_reply (cs->req, stat, &cs->fh, postop, &cs->preparent,
                           &cs->postparent);
@@ -2726,7 +2731,7 @@ nfs3svc_mkdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), "MKDIR",
+                nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), NFS3_MKDIR,
                                     stat, op_errno, &cs->fh);
                 nfs3_mkdir_reply (cs->req, stat, &cs->fh, buf, preparent,
                                   postparent);
@@ -2765,7 +2770,7 @@ nfs3_mkdir_resume (void *carg)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "MKDIR",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_MKDIR,
                                      stat, -ret);
                 nfs3_mkdir_reply (cs->req, stat, NULL, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -2810,7 +2815,7 @@ nfs3_mkdir (rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name,
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "MKDIR",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_MKDIR,
                                      stat, -ret);
                 nfs3_mkdir_reply (req, stat, NULL, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -2890,7 +2895,7 @@ nfs3svc_symlink_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         stat = NFS3_OK;
 
 nfs3err:
-        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), "SYMLINK", stat,
+        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), NFS3_SYMLINK, stat,
                             op_errno, &cs->fh);
         nfs3_symlink_reply (cs->req, stat, &cs->fh, buf, preparent,
                             postparent);
@@ -2921,7 +2926,7 @@ nfs3_symlink_resume (void *carg)
 nfs3err:
         if (ret < 0) {
                 nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     "SYMLINK", stat, -ret);
+                                     NFS3_SYMLINK, stat, -ret);
                 nfs3_symlink_reply (cs->req, stat, NULL, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
         }
@@ -2969,7 +2974,7 @@ nfs3_symlink (rpcsvc_request_t *req, struct nfs3_fh *dirfh, char *name,
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "SYMLINK",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_SYMLINK,
                                      stat, -ret);
                 nfs3_symlink_reply (req, stat, NULL, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -3050,7 +3055,7 @@ nfs3svc_mknod_setattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
         stat = NFS3_OK;
 nfs3err:
-        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), "MKNOD", stat,
+        nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), NFS3_MKNOD, stat,
                             op_errno, &cs->fh);
         nfs3_mknod_reply (cs->req, stat, &cs->fh, postop, &cs->preparent,
                           &cs->postparent);
@@ -3098,7 +3103,7 @@ nfs3svc_mknod_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 stat = nfs3_errno_to_nfsstat3 (-ret);
 nfs3err:
         if (ret < 0) {
-                nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), "MKNOD",
+                nfs3_log_newfh_res (rpcsvc_request_xid (cs->req), NFS3_MKNOD,
                                     stat,
                                     op_errno, &cs->fh);
                 nfs3_mknod_reply (cs->req, stat, &cs->fh, buf, preparent,
@@ -3197,7 +3202,7 @@ nfs3_mknod_resume (void *carg)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "MKNOD",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_MKNOD,
                                      stat, -ret);
                 nfs3_mknod_reply (cs->req, stat, NULL, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -3263,7 +3268,7 @@ nfs3_mknod (rpcsvc_request_t *req, struct nfs3_fh *fh, char *name,
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "MKNOD",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_MKNOD,
                                      stat, -ret);
                 nfs3_mknod_reply (req, stat, NULL, NULL, NULL, NULL);
                 /* Ret must be 0 after this so that the caller does not
@@ -3327,9 +3332,7 @@ nfs3svc_remove_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                     struct iatt *postparent)
 {
         nfsstat3                stat = NFS3ERR_SERVERFAULT;
-        fd_t                    *openfd = NULL;
         nfs3_call_state_t       *cs = NULL;
-        struct nfs3_state       *nfs3 = NULL;
 
         cs = frame->local;
         if (op_ret == -1) {
@@ -3337,21 +3340,12 @@ nfs3svc_remove_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                         "%x: %s => -1 (%s)", rpcsvc_request_xid (cs->req),
                         cs->resolvedloc.path, strerror (op_errno));
                 stat = nfs3_errno_to_nfsstat3 (op_errno);
-                goto do_not_unref_cached_fd;
         }
-        stat = NFS3_OK;
-        /* Close any cached fds so that when any currently active write
-         * finishes, the file is finally removed.
-         */
-         openfd = fd_lookup (cs->resolvedloc.inode, 0);
-         nfs3 = rpcsvc_request_program_private (cs->req);
-         if (openfd) {
-                fd_unref (openfd);
-                nfs3_fdcache_remove (nfs3, openfd);
-         }
-
-do_not_unref_cached_fd:
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req), "REMOVE", stat,
+
+        if (op_ret == 0)
+                stat = NFS3_OK;
+
+        nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_REMOVE, stat,
                              op_errno);
         nfs3_remove_reply (cs->req, stat, preparent, postparent);
         nfs3_call_state_wipe (cs);
@@ -3400,7 +3394,7 @@ nfs3_remove_resume (void *carg)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "REMOVE",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_REMOVE,
                                      stat, -ret);
                 nfs3_remove_reply (cs->req, stat, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -3440,7 +3434,7 @@ nfs3_remove (rpcsvc_request_t *req, struct nfs3_fh *fh, char *name)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "REMOVE",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_REMOVE,
                                      stat, -ret);
                 nfs3_remove_reply (req, stat, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -3516,7 +3510,7 @@ nfs3svc_rmdir_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 stat = NFS3_OK;
         }
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req), "RMDIR", stat,
+        nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_RMDIR, stat,
                              op_errno);
         nfs3_rmdir_reply (cs->req, stat, preparent, postparent);
         nfs3_call_state_wipe (cs);
@@ -3545,7 +3539,7 @@ nfs3_rmdir_resume (void *carg)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "RMDIR",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_RMDIR,
                                      stat, -ret);
                 nfs3_rmdir_reply (cs->req, stat, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -3586,7 +3580,7 @@ nfs3_rmdir (rpcsvc_request_t *req, struct nfs3_fh *fh, char *name)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "RMDIR",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_RMDIR,
                                      stat, -ret);
                 nfs3_rmdir_reply (req, stat, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -3658,7 +3652,6 @@ nfs3svc_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         int                     ret = -EFAULT;
         nfsstat3                stat = NFS3ERR_SERVERFAULT;
         nfs3_call_state_t       *cs = NULL;
-        fd_t                    *openfd = NULL;
 
         cs = frame->local;
         if (op_ret == -1) {
@@ -3671,20 +3664,8 @@ nfs3svc_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }
 
         stat = NFS3_OK;
-        /* Close any cached fds so that when any currently active writes to the
-         * dst finish, the file is finally removed.
-         *
-         * This logic works because we know resolvedloc contains dst, which is
-         * resolved after src
-         */
-        openfd = fd_lookup (cs->resolvedloc.inode, 0);
-        if (openfd) {
-                fd_unref (openfd);
-                nfs3_fdcache_remove (cs->nfs3state, openfd);
-        }
-
 nfs3err:
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req), "RENAME", stat,
+        nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_RENAME, stat,
                              -ret);
         nfs3_rename_reply (cs->req, stat, buf, preoldparent, postoldparent,
                            prenewparent, postnewparent);
@@ -3715,7 +3696,7 @@ nfs3_rename_resume_dst (void *carg)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "RENAME",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_RENAME,
                                      stat, -ret);
                 nfs3_rename_reply (cs->req, stat, NULL, NULL, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -3752,7 +3733,7 @@ nfs3_rename_resume_src (void *carg)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "RENAME",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_RENAME,
                                      stat, -ret);
                 nfs3_rename_reply (cs->req, stat, NULL, NULL, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -3807,7 +3788,7 @@ nfs3_rename (rpcsvc_request_t *req, struct nfs3_fh *olddirfh, char *oldname,
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "RENAME",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_RENAME,
                                      stat, -ret);
                 nfs3_rename_reply (req, stat, NULL, NULL, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -3887,7 +3868,7 @@ nfs3svc_link_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         } else
                 stat = NFS3_OK;
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req), "LINK", stat,
+        nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_LINK, stat,
                              op_errno);
         nfs3_link_reply (cs->req, stat, buf, preparent, postparent);
         nfs3_call_state_wipe (cs);
@@ -3918,7 +3899,7 @@ nfs3_link_resume_lnk (void *carg)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "LINK",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_LINK,
                                      stat, -ret);
                 nfs3_link_reply (cs->req, stat, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -3949,7 +3930,7 @@ nfs3_link_resume_tgt (void *carg)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "LINK",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_LINK,
                                      stat, -ret);
                 nfs3_link_reply (cs->req, stat, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -3998,7 +3979,7 @@ nfs3_link (rpcsvc_request_t *req, struct nfs3_fh *targetfh,
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "LINK", stat,
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_LINK, stat,
                                      -ret);
                 nfs3_link_reply (req, stat, NULL, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -4167,11 +4148,11 @@ err:
 
         if (cs->maxcount == 0) {
                 nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     "READDIR", stat, op_errno);
+                                     NFS3_READDIR, stat, op_errno);
                 nfs3_readdir_reply (cs->req, stat, NULL, 0, NULL, NULL, 0, 0);
         } else {
                 nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     "READDIRP", stat, op_errno);
+                                     NFS3_READDIRP, stat, op_errno);
                 nfs3_readdirp_reply (cs->req, stat, NULL, 0, NULL, NULL,
                                      0, 0, 0);
         }
@@ -4227,12 +4208,12 @@ nfs3err:
         if (ret < 0) {
                 if (cs->maxcount == 0) {
                         nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                             "READDIR", stat, -ret);
+                                             NFS3_READDIR, stat, -ret);
                         nfs3_readdir_reply (cs->req, stat, NULL, 0, NULL, NULL,
                                             0, 0);
                 } else {
                         nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                             "READDIRP", stat, -ret);
+                                             NFS3_READDIRP, stat, -ret);
                         nfs3_readdirp_reply (cs->req, stat, NULL, 0, NULL, NULL,
                                              0, 0, 0);
                 }
@@ -4255,7 +4236,13 @@ nfs3_readdir_open_resume (void *carg)
 
         cs = (nfs3_call_state_t *)carg;
         nfs3_check_fh_resolve_status (cs, stat, nfs3err);
-        ret = nfs3_dir_open_and_resume (cs, nfs3_readdir_read_resume);
+        cs->fd = fd_anonymous (cs->resolvedloc.inode);
+        if (!cs->fd) {
+                gf_log (GF_NFS3, GF_LOG_ERROR, "Faile to create anonymous fd");
+                goto nfs3err;
+        }
+
+        ret = nfs3_readdir_read_resume (cs);
         if (ret < 0)
                 stat = nfs3_errno_to_nfsstat3 (-ret);
 
@@ -4263,12 +4250,12 @@ nfs3err:
         if (ret < 0) {
                 if (cs->maxcount == 0) {
                         nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                             "READDIR", stat, -ret);
+                                             NFS3_READDIR, stat, -ret);
                         nfs3_readdir_reply (cs->req, stat, NULL, 0, NULL, NULL,
                                             0, 0);
                 } else {
                         nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                             "READDIRP", stat, -ret);
+                                             NFS3_READDIRP, stat, -ret);
                         nfs3_readdirp_reply (cs->req, stat, NULL, 0, NULL, NULL,
                                              0, 0, 0);
                 }
@@ -4317,12 +4304,12 @@ nfs3err:
         if (ret < 0) {
                 if (maxcount == 0) {
                         nfs3_log_common_res (rpcsvc_request_xid (req),
-                                             "READDIR", stat, -ret);
+                                             NFS3_READDIR, stat, -ret);
                         nfs3_readdir_reply (req, stat, NULL, 0, NULL, NULL, 0,
                                             0);
                 } else {
                         nfs3_log_common_res (rpcsvc_request_xid (req),
-                                             "READDIRP", stat, -ret);
+                                             NFS3_READDIRP, stat, -ret);
                         nfs3_readdirp_reply (req, stat, NULL, 0, NULL, NULL, 0,
                                              0, 0);
                 }
@@ -4449,7 +4436,7 @@ nfs3_fsstat_stat_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         } else
                 stat = NFS3_OK;
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req), "FSTAT", stat,
+        nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_FSSTAT, stat,
                              op_errno);
         nfs3_fsstat_reply (cs->req, stat, &cs->fsstat, buf);
         nfs3_call_state_wipe (cs);
@@ -4488,7 +4475,7 @@ nfs3_fsstat_statfs_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
 
 err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "FSTAT",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_FSSTAT,
                                      stat, -ret);
                 nfs3_fsstat_reply (cs->req, stat, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -4520,7 +4507,7 @@ nfs3_fsstat_resume (void *carg)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "FSTAT",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_FSSTAT,
                                      stat, -ret);
                 nfs3_fsstat_reply (cs->req, stat, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -4558,7 +4545,7 @@ nfs3_fsstat (rpcsvc_request_t *req, struct nfs3_fh *fh)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "FSTAT",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_FSSTAT,
                                      stat, -ret);
                 nfs3_fsstat_reply (req, stat, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -4634,7 +4621,7 @@ nfs3svc_fsinfo_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         }else
                 status = NFS3_OK;
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req), "FSINFO", status,
+        nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_FSINFO, status,
                              op_errno);
 
         nfs3_fsinfo_reply (cs->req, status, buf);
@@ -4667,7 +4654,7 @@ nfs3_fsinfo_resume (void *carg)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "FSINFO",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_FSINFO,
                                      stat, -ret);
                 nfs3_fsinfo_reply (cs->req, stat, NULL);
                 nfs3_call_state_wipe (cs);
@@ -4704,7 +4691,7 @@ nfs3_fsinfo (rpcsvc_request_t *req, struct nfs3_fh *fh)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "FSINFO",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_FSINFO,
                                      stat, -ret);
                 nfs3_fsinfo_reply (req, stat, NULL);
                 nfs3_call_state_wipe (cs);
@@ -4780,7 +4767,7 @@ nfs3svc_pathconf_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
                 stat = NFS3_OK;
         }
 
-        nfs3_log_common_res (rpcsvc_request_xid (cs->req), "PATHCONF", stat,
+        nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_PATHCONF, stat,
                              op_errno);
         nfs3_pathconf_reply (cs->req, stat, sbuf);
         nfs3_call_state_wipe (cs);
@@ -4810,7 +4797,7 @@ nfs3_pathconf_resume (void *carg)
 nfs3err:
         if (ret < 0) {
                 nfs3_log_common_res (rpcsvc_request_xid (cs->req),
-                                     "PATHCONF", stat, -ret);
+                                     NFS3_PATHCONF, stat, -ret);
                 nfs3_pathconf_reply (cs->req, stat, NULL);
                 nfs3_call_state_wipe (cs);
         }
@@ -4845,7 +4832,7 @@ nfs3_pathconf (rpcsvc_request_t *req, struct nfs3_fh *fh)
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "PATHCONF",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_PATHCONF,
                                      stat, -ret);
                 nfs3_pathconf_reply (req, stat, NULL);
                 nfs3_call_state_wipe (cs);
@@ -4904,8 +4891,7 @@ nfs3_commit_reply (rpcsvc_request_t *req, nfsstat3 stat, uint64_t wverf,
 
 int32_t
 nfs3svc_commit_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)
 {
         nfsstat3                stat = NFS3ERR_SERVERFAULT;
         nfs3_call_state_t       *cs = NULL;
@@ -4923,7 +4909,7 @@ nfs3svc_commit_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
         nfs3 = rpcsvc_request_program_private (cs->req);
         nfs3_log_commit_res (rpcsvc_request_xid (cs->req), stat, op_errno,
                              nfs3->serverstart);
-        nfs3_commit_reply (cs->req, stat, nfs3->serverstart, prebuf, postbuf);
+        nfs3_commit_reply (cs->req, stat, nfs3->serverstart, NULL, NULL);
         nfs3_call_state_wipe (cs);
 
         return 0;
@@ -4950,14 +4936,14 @@ nfs3_commit_resume (void *carg)
         }
 
         nfs_request_user_init (&nfu, cs->req);
-        ret = nfs_fsync (cs->nfsx, cs->vol, &nfu, cs->fd, 0,
+        ret = nfs_flush (cs->nfsx, cs->vol, &nfu, cs->fd,
                          nfs3svc_commit_cbk, cs);
         if (ret < 0)
                 stat = nfs3_errno_to_nfsstat3 (-ret);
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "COMMIT",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_COMMIT,
                                      stat, -ret);
                 nfs3_commit_reply (cs->req, stat, cs->nfs3state->serverstart,
                                    NULL, NULL);
@@ -4965,7 +4951,7 @@ nfs3err:
                 ret = 0;
         }
 
-        return ret;
+        return 0;
 }
 
 
@@ -4981,13 +4967,18 @@ nfs3_commit_open_resume (void *carg)
 
         cs = (nfs3_call_state_t *)carg;
         nfs3_check_fh_resolve_status (cs, stat, nfs3err);
+        cs->fd = fd_anonymous (cs->resolvedloc.inode);
+        if (!cs->fd) {
+                gf_log (GF_NFS3, GF_LOG_ERROR, "Failed to create anonymous fd.");
+                goto nfs3err;
+        }
 
-        ret = nfs3_file_open_and_resume (cs, nfs3_commit_resume);
+        ret = nfs3_commit_resume (cs);
         if (ret < 0)
                 stat = nfs3_errno_to_nfsstat3 (-ret);
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (cs->req), "COMMIT",
+                nfs3_log_common_res (rpcsvc_request_xid (cs->req), NFS3_COMMIT,
                                      stat, -ret);
                 nfs3_commit_reply (cs->req, stat, 0, NULL, NULL);
                 nfs3_call_state_wipe (cs);
@@ -5031,7 +5022,7 @@ nfs3_commit (rpcsvc_request_t *req, struct nfs3_fh *fh, offset3 offset,
 
 nfs3err:
         if (ret < 0) {
-                nfs3_log_common_res (rpcsvc_request_xid (req), "COMMIT",
+                nfs3_log_common_res (rpcsvc_request_xid (req), NFS3_COMMIT,
                                      stat, -ret);
                 nfs3_commit_reply (req, stat, 0, NULL, NULL);
                 nfs3_call_state_wipe (cs);
diff --git a/xlators/nfs/server/src/nfs3.h b/xlators/nfs/server/src/nfs3.h
index a2c67ee6e17..3e99184c7ad 100644
--- a/xlators/nfs/server/src/nfs3.h
+++ b/xlators/nfs/server/src/nfs3.h
@@ -196,6 +196,7 @@ struct nfs3_local {
         mode_t                  mode;
 
         /* NFSv3 FH resolver state */
+	int			hardresolved;
         struct nfs3_fh          resolvefh;
         loc_t                   resolvedloc;
         int                     resolve_ret;
@@ -211,6 +212,9 @@ struct nfs3_local {
 
 #define nfs3_is_revalidate_lookup(cst) ((cst)->lookuptype == GF_NFS3_REVALIDATE)
 #define nfs3_lookup_op(cst) (rpcsvc_request_procnum(cst->req) == NFS3_LOOKUP)
+#define nfs3_create_op(cst) (rpcsvc_request_procnum(cst->req) == NFS3_CREATE)
+#define nfs3_create_exclusive_op(cst) ((cst)->createmode == EXCLUSIVE)
+
 typedef struct nfs3_local nfs3_call_state_t;
 
 /* Queue of ops waiting for open fop to return. */