libglusterfsclient: Enhance logging

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

BUG: 210 (libglusterfsclient: Enhance logging)
URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=210

1 files changed, 318 insertions, 43 deletions

diff --git a/libglusterfsclient/src/libglusterfsclient.c b/libglusterfsclient/src/libglusterfsclient.c
index a5b3c414229..1dfe33327b8 100755
--- a/libglusterfsclient/src/libglusterfsclient.c
+++ b/libglusterfsclient/src/libglusterfsclient.c
@@ -243,12 +243,15 @@ libgf_dcache_invalidate (fd_t *fd)
 
         fd_ctx = libgf_get_fd_ctx (fd);
         if (!fd_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 errno = EBADF;
                 return;
         }
 
-        if (!fd_ctx->dcache)
+        if (!fd_ctx->dcache) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No dcache present");
                 return;
+        }
 
         if (!list_empty (&fd_ctx->dcache->entries.list))
                 gf_dirent_free (&fd_ctx->dcache->entries);
@@ -278,12 +281,14 @@ libgf_dcache_update (libglusterfs_client_ctx_t *ctx, fd_t *fd,
 
         fd_ctx = libgf_get_fd_ctx (fd);
         if (!fd_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 errno = EBADF;
 		goto out;
         }
 
         /* dcache is not enabled. */
         if (!fd_ctx->dcache) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No dcache present");
                 op_ret = 0;
                 goto out;
         }
@@ -321,18 +326,23 @@ libgf_dcache_readdir (libglusterfs_client_ctx_t *ctx, fd_t *fd,
 
         fd_ctx = libgf_get_fd_ctx (fd);
         if (!fd_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 errno = EBADF;
                 goto out;
         }
 
-        if (!fd_ctx->dcache)
+        if (!fd_ctx->dcache) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No dcache present");
                 goto out;
+        }
 
         /* We've either run out of entries in the cache
          * or the cache is empty.
          */
-        if (!fd_ctx->dcache->next)
+        if (!fd_ctx->dcache->next) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "No entries present");
                 goto out;
+        }
 
         /* The dirent list is created as a circular linked list
          * so this check is needed to ensure, we dont start
@@ -340,8 +350,10 @@ libgf_dcache_readdir (libglusterfs_client_ctx_t *ctx, fd_t *fd,
          * If we're reached this situation, the cache is exhausted
          * and we'll need to pre-fetch more entries to continue serving.
          */
-        if (fd_ctx->dcache->next == &fd_ctx->dcache->entries)
+        if (fd_ctx->dcache->next == &fd_ctx->dcache->entries) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Entries exhausted");
                 goto out;
+        }
 
         /* During sequential reading we generally expect that the offset
          * requested is the same as the offset we served in the previous call
@@ -359,8 +371,13 @@ libgf_dcache_readdir (libglusterfs_client_ctx_t *ctx, fd_t *fd,
                  * zero because that is what we returned for the last dirent
                  * of the previous readdir block.
                  */
-                if ((*offset != 0) && (fd_ctx->dcache->prev_off == 0))
+                if ((*offset != 0) && (fd_ctx->dcache->prev_off == 0)) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Entries"
+                                " exhausted");
                         cachevalid = 1;
+                } else
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Dcache"
+                                " invalidated previously");
         } else
                 cachevalid = 1;
 
@@ -481,6 +498,8 @@ libgf_update_iattr_cache (inode_t *inode, int flags, struct stat *buf)
 
         inode_ctx = libgf_get_inode_ctx (inode);
         if (!inode_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No inode context"
+                        " present");
                 errno = EINVAL;
                 op_ret = -1;
                 goto out;
@@ -492,10 +511,13 @@ libgf_update_iattr_cache (inode_t *inode, int flags, struct stat *buf)
                  * lock.
                  */
                 current = time (NULL);
-                if (flags & LIBGF_UPDATE_LOOKUP)
+                if (flags & LIBGF_UPDATE_LOOKUP) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Updating lookup");
                         inode_ctx->previous_lookup_time = current;
+                }
 
                 if (flags & LIBGF_UPDATE_STAT) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Updating stat");
 
                         /* Update the cached stat struct only if a new
                          * stat buf is given.
@@ -524,16 +546,25 @@ libgf_invalidate_iattr_cache (inode_t *inode, int flags)
                 return -1;
 
         ictx = libgf_get_inode_ctx (inode);
-        if (!ictx)
+        if (!ictx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No inode context"
+                        " present");
                 return -1;
+        }
 
         pthread_mutex_lock (&ictx->lock);
         {
-                if (flags & LIBGF_INVALIDATE_LOOKUP)
+                if (flags & LIBGF_INVALIDATE_LOOKUP) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Invalidating"
+                                " lookup");
                         ictx->previous_lookup_time = 0;
+                }
 
-                if (flags & LIBGF_INVALIDATE_STAT)
+                if (flags & LIBGF_INVALIDATE_STAT) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Invalidating"
+                                " stat");
                         ictx->previous_stat_time = 0;
+                }
 
         }
         pthread_mutex_unlock (&ictx->lock);
@@ -560,9 +591,11 @@ libgf_is_iattr_cache_valid (libglusterfs_client_ctx_t *ctx, inode_t *inode,
         {
                 current = time (NULL);
                 if (flags & LIBGF_VALIDATE_LOOKUP) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Checking lookup");
                         prev = inode_ctx->previous_lookup_time;
                         timeout = ctx->lookup_timeout;
                 } else {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Checking stat");
                         prev = inode_ctx->previous_stat_time;
                         timeout = ctx->stat_timeout;
                 }
@@ -576,23 +609,29 @@ libgf_is_iattr_cache_valid (libglusterfs_client_ctx_t *ctx, inode_t *inode,
                  */
                 if (prev == 0) {
                         cache_valid = 0;
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Cache Invalid");
                         goto iattr_unlock_out;
                 }
 
                 /* Cache infinitely */
                 if (timeout == (time_t)-1) {
                         cache_valid = 1;
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Caching On and "
+                                "valid");
                         goto iattr_unlock_out;
                 }
 
                 /* Disable caching completely */
                 if (timeout == 0) {
                         cache_valid = 0;
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Cache disabled");
                         goto iattr_unlock_out;
                 }
 
-                if ((prev > 0) && (timeout >= (current - prev)))
+                if ((prev > 0) && (timeout >= (current - prev))) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Cache valid");
                         cache_valid = 1;
+                }
 
                 if (flags & LIBGF_VALIDATE_LOOKUP)
                         goto iattr_unlock_out;
@@ -764,8 +803,10 @@ libgf_resolve_path_light (char *path)
         mypath = strdup (path);
         len = strlen (mypath);
         respath = calloc (strlen(mypath) + 1, sizeof (char));
-        if (respath == NULL)
+        if (respath == NULL) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR,"Memory allocation failed");
                 goto out;
+        }
 
         /* The path only contains a / or a //, so simply add a /
          * and return.
@@ -800,6 +841,8 @@ libgf_resolve_path_light (char *path)
                 tok = strtok_r (NULL, "/", &saveptr);
         }
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Path: %s, Resolved Path: %s",
+                path, respath);
 out:
         if (mypath)
                 free (mypath);
@@ -1310,8 +1353,10 @@ libgf_init_vmpentry (char *vmp, glusterfs_handle_t *vmphandle)
         int                     appendslash = 0;
 
         entry = CALLOC (1, sizeof (struct vmp_entry));
-        if (!entry)
+        if (!entry) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR,"Memory allocation failed");
                 return NULL;
+        }
 
         vmplen = strlen (vmp);
         if (vmp[vmplen - 1] != '/') {
@@ -1326,6 +1371,7 @@ libgf_init_vmpentry (char *vmp, glusterfs_handle_t *vmphandle)
         entry->vmplen = vmplen;
         entry->handle = vmphandle;
         INIT_LIST_HEAD (&entry->list);
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "New VMP entry: %s", vmp);
         return entry;
 }
 
@@ -1427,6 +1473,8 @@ _libgf_vmp_search_entry (char *path, int searchtype)
         int                     maxcount = 0;
         int                     vmpcompcount = 0;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "VMP Search: path %s, type: %s",
+                path, (searchtype == LIBGF_VMP_EXACT)?"Exact":"LongestPrefix");
         if (vmplist.entries == 0) {
                 gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Virtual Mount Point "
                         "list is empty.");
@@ -1436,6 +1484,8 @@ _libgf_vmp_search_entry (char *path, int searchtype)
         list_for_each_entry(entry, &vmplist.list, list) {
                 vmpcompcount = libgf_count_path_components (entry->vmp);
                 matchcount = libgf_vmp_entry_match (entry, path);
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Candidate VMP:  %s,"
+                        " Matchcount: %d", entry->vmp, matchcount);
                 if ((matchcount > maxcount) && (matchcount == vmpcompcount)) {
                         maxcount = matchcount;
                         maxentry = entry;
@@ -1450,8 +1500,14 @@ _libgf_vmp_search_entry (char *path, int searchtype)
         if ((searchtype == LIBGF_VMP_EXACT) && (maxentry)) {
                 vmpcompcount = libgf_count_path_components (maxentry->vmp);
                 matchcount = libgf_count_path_components (path);
-                if (vmpcompcount != matchcount)
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Exact Check: VMP: %s,"
+                        " CompCount: %d, Path: %s, CompCount: %d",
+                        maxentry->vmp, vmpcompcount, path, matchcount);
+                if (vmpcompcount != matchcount) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "No Match");
                         maxentry = NULL;
+                } else
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Matches!");
         }
 
 out:        
@@ -1519,13 +1575,18 @@ libgf_vmp_map_ghandle (char *vmp, glusterfs_handle_t *vmphandle)
         int                     ret = -1;
         struct vmp_entry        *vmpentry = NULL;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "New Entry: %s", vmp);
         vmpentry = libgf_init_vmpentry (vmp, vmphandle);
-        if (!vmpentry)
+        if (!vmpentry) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Failed to create VMP"
+                        " entry");
                 goto out;
+        }
 
         pthread_mutex_lock (&vmplock);
         {
                 if (vmplist.entries == 0) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Empty list");
                         INIT_LIST_HEAD (&vmplist.list);
                 }
 
@@ -1566,14 +1627,17 @@ glusterfs_mount (char *vmp, glusterfs_init_params_t *ipars)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ipars, out);
 
         vmp_resolved = libgf_resolve_path_light (vmp);
-        if (!vmp_resolved)
+        if (!vmp_resolved) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         vmphash = (dev_t)ReallySimpleHash (vmp, strlen (vmp));
         pthread_mutex_lock (&mountlock);
         {
                 vmp_entry = libgf_vmp_search_exact_entry (vmp);
                 if (vmp_entry) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Entry exists");
                         ret = 0;
                         goto unlock;
                 }
@@ -1581,11 +1645,15 @@ glusterfs_mount (char *vmp, glusterfs_init_params_t *ipars)
                 vmphandle = glusterfs_init (ipars, vmphash);
                 if (!vmphandle) {
                         errno = EINVAL;
+                        gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "GlusterFS context"
+                                " init failed");
                         goto unlock;
                 }
 
                 ret = libgf_vmp_map_ghandle (vmp_resolved, vmphandle);
                 if (ret == -1) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Failed to map new"
+                                " handle: %s", vmp);
                         glusterfs_fini (vmphandle);
                 }
         }
@@ -1652,8 +1720,10 @@ glusterfs_umount (char *vmp)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, vmp, out);
 
         vmp_resolved = libgf_resolve_path_light (vmp);
-        if (!vmp_resolved)
+        if (!vmp_resolved) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         ret = libgf_umount (vmp_resolved);
 
@@ -1890,7 +1960,9 @@ glusterfs_glh_get (glusterfs_handle_t handle, const char *path, void *buf,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, size %ld", path, size);
         if (size < 0) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Invalid size");
                 errno = EINVAL;
                 goto out;
         }
@@ -1901,8 +1973,10 @@ glusterfs_glh_get (glusterfs_handle_t handle, const char *path, void *buf,
         }
 
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
 	op_ret = libgf_client_path_lookup (&loc, ctx, 0);
 	if (op_ret == -1) {
@@ -1978,6 +2052,7 @@ glusterfs_get (const char *path, void *buf, size_t size, struct stat *stbuf)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, buf, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, stbuf, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, size %ld", path, size);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -2290,8 +2365,12 @@ __glusterfs_glh_getxattr (glusterfs_handle_t handle, const char *path,
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, name, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, name %s, size %ld,"
+                " op %d", path, name, size, whichop);
         if (name[0] == '\0') {
 		errno = EINVAL;
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Invalid argument: Name"
+                        " not NULL terminated");
 		goto out;
 	}
 
@@ -2302,12 +2381,16 @@ __glusterfs_glh_getxattr (glusterfs_handle_t handle, const char *path,
 
         if (size < 0) {
                 errno = EINVAL;
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Invalid argument: size is"
+                        " less than zero");
                 goto out;
         }
 
         pathres = libgf_resolve_path_light ((char *)path);
-        if (!pathres)
+        if (!pathres) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         loc.path = strdup (pathres);
 	op_ret = libgf_client_path_lookup (&loc, ctx, 1);
@@ -2344,8 +2427,10 @@ __glusterfs_glh_getxattr (glusterfs_handle_t handle, const char *path,
 
         libgf_client_loc_wipe (&loc);
         op_ret = libgf_realpath_loc_fill (ctx, (char *)pathres, &loc);
-        if (op_ret == -1)
+        if (op_ret == -1) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "realpath failed");
                 goto out;
+        }
 
 do_getx:
 	op_ret = libgf_client_lookup (ctx, &loc, NULL, &dict, xattr_req);
@@ -2416,6 +2501,8 @@ glusterfs_getxattr (const char *path, const char *name, void *value,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, name, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, value, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, name %s, size %ld",
+                path, name, size);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -2444,6 +2531,8 @@ glusterfs_lgetxattr (const char *path, const char *name, void *value,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, name, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, value, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, name %s, size %ld",
+                path, name, size);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -2493,6 +2582,8 @@ libgf_client_open (libglusterfs_client_ctx_t *ctx,
         op_ret = stub->args.open_cbk.op_ret;
         errno = stub->args.open_cbk.op_errno;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "open: path %s, status: %d, errno"
+                " %d", loc->path, op_ret, errno);
         if (op_ret != -1)
                 fd_bind (fd);
 	call_stub_destroy (stub);
@@ -2534,6 +2625,8 @@ libgf_client_creat (libglusterfs_client_ctx_t *ctx,
   
         op_ret = stub->args.create_cbk.op_ret;
         errno = stub->args.create_cbk.op_errno;
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Create: path %s, status: %d,"
+                " errno: %d", loc->path, op_ret, errno);
         if (op_ret == -1)
                 goto out;
 
@@ -2588,6 +2681,8 @@ libgf_client_opendir (libglusterfs_client_ctx_t *ctx,
 
         op_ret = stub->args.opendir_cbk.op_ret;
         errno = stub->args.opendir_cbk.op_errno;
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "opendir: path %s, status %d,"
+                " errno %d", loc->path, op_ret, errno);
         if (op_ret != -1)
                 fd_bind (fd);
 
@@ -2614,8 +2709,10 @@ glusterfs_glh_open (glusterfs_handle_t handle, const char *path, int flags,...)
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
         pathres = libgf_resolve_path_light ((char *)path);
-        if (!pathres)
+        if (!pathres) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
 	loc.path = strdup (pathres);
 	op_ret = libgf_client_path_lookup (&loc, ctx, 1);
@@ -2694,6 +2791,8 @@ op_over:
 
         if (!libgf_get_fd_ctx (fd)) {
                 if (!libgf_alloc_fd_ctx (ctx, fd)) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Failed to"
+                                " allocate fd context");
                         errno = EINVAL;
                         op_ret = -1;
                         goto out;
@@ -2733,6 +2832,7 @@ glusterfs_open (const char *path, int flags, ...)
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -2756,6 +2856,7 @@ out:
 glusterfs_file_t 
 glusterfs_glh_creat (glusterfs_handle_t handle, const char *path, mode_t mode)
 {
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
 	return glusterfs_glh_open (handle, path,
 			       (O_CREAT | O_WRONLY | O_TRUNC), mode);
 }
@@ -2769,6 +2870,7 @@ glusterfs_creat (const char *path, mode_t mode)
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -2831,6 +2933,7 @@ glusterfs_close (glusterfs_file_t fd)
 
         fd_ctx = libgf_get_fd_ctx (fd);
         if (!fd_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 errno = EBADF;
                 goto out;
         }
@@ -2885,6 +2988,8 @@ libgf_client_setxattr (libglusterfs_client_ctx_t *ctx,
         op_ret = stub->args.setxattr_cbk.op_ret;
         errno = stub->args.setxattr_cbk.op_errno;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "path %s, name %s, status %d,"
+                "errno %d", loc->path, name, op_ret, errno);
         dict_unref (dict);
 	call_stub_destroy (stub);
         return op_ret;
@@ -2909,14 +3014,18 @@ __glusterfs_glh_setxattr (glusterfs_handle_t handle, const char *path,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "path %s, name %s, op %d", path
+                ,name, whichop);
         if (size <= 0) {
                 errno = EINVAL;
                 goto out;
         }
 
         pathres = libgf_resolve_path_light ((char *)path);
-        if (!pathres)
+        if (!pathres) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         loc.path = strdup (pathres);
 	op_ret = libgf_client_path_lookup (&loc, ctx, 1);
@@ -2993,6 +3102,7 @@ glusterfs_setxattr (const char *path, const char *name, const void *value,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, name, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, value, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "path %s, name %s", path, name);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -3021,6 +3131,7 @@ glusterfs_lsetxattr (glusterfs_handle_t handle, const char *path,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, name, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, value, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "path %s, name %s", path, name);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -3076,6 +3187,8 @@ libgf_client_fsetxattr (libglusterfs_client_ctx_t *ctx,
         op_ret = stub->args.fsetxattr_cbk.op_ret;
         errno = stub->args.fsetxattr_cbk.op_errno;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "name %s, status %d, errno %d",
+                name, op_ret, errno);
         dict_unref (dict);
 	call_stub_destroy (stub);
 
@@ -3104,6 +3217,8 @@ glusterfs_fsetxattr (glusterfs_file_t fd,
         }
 
         if (size <= 0) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Invalid argument: size is"
+                        " less than or equal to zero");
                 errno = EINVAL;
                 op_ret = -1;
                 goto out;
@@ -3111,6 +3226,7 @@ glusterfs_fsetxattr (glusterfs_file_t fd,
 
         fd_ctx = libgf_get_fd_ctx (fd);
         if (!fd_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 errno = EBADF;
 		op_ret = -1;
 		goto out;
@@ -3182,6 +3298,8 @@ libgf_client_fgetxattr (libglusterfs_client_ctx_t *ctx,
                 }
         }
 	
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "name %s, status %d, errno %d",
+                name, op_ret, errno);
 	call_stub_destroy (stub);
         return op_ret;
 }
@@ -3197,6 +3315,7 @@ glusterfs_fgetxattr (glusterfs_file_t fd,
         fd_t *__fd = (fd_t *)fd;
         libglusterfs_client_fd_ctx_t *fd_ctx = NULL;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "name %s", name);
         if (size < 0) {
                 errno = EINVAL;
                 op_ret = -1;
@@ -3208,6 +3327,7 @@ glusterfs_fgetxattr (glusterfs_file_t fd,
 
         fd_ctx = libgf_get_fd_ctx (fd);
         if (!fd_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 errno = EBADF;
 		op_ret = -1;
 		goto out;
@@ -3326,6 +3446,8 @@ libgf_client_read (libglusterfs_client_ctx_t *ctx,
                 libgf_invalidate_iattr_cache (fd->inode, LIBGF_INVALIDATE_STAT);
         }
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "size %ld, offset %ld", size,
+                offset);
 	call_stub_destroy (stub);
         return op_ret;
 }
@@ -3357,6 +3479,7 @@ glusterfs_read (glusterfs_file_t fd,
 
         fd_ctx = libgf_get_fd_ctx (fd);
         if (!fd_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 errno = EBADF;
 		goto out;
         }
@@ -3895,6 +4018,7 @@ glusterfs_readdir_r (glusterfs_dir_t dirfd, struct dirent *entry,
 
         fd_ctx = libgf_get_fd_ctx (dirfd);
         if (!fd_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "fd context not present");
                 errno = EBADF;
 		goto out;
         }
@@ -3905,10 +4029,13 @@ glusterfs_readdir_r (glusterfs_dir_t dirfd, struct dirent *entry,
                 offset = fd_ctx->offset;
                 dirp = &fd_ctx->dirp;
 
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "offset %ld", offset);
                 memset (dirp, 0, sizeof (struct dirent));
                 op_ret = libgf_client_readdir (ctx, (fd_t *)dirfd, dirp,
                                                &offset);
                 if (op_ret <= 0) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "readdir failed:"
+                                " %s", strerror (errno));
                         if (result && (op_ret == 0)) {
                                 *result = NULL;
                         } else if (op_ret < 0){
@@ -3925,6 +4052,8 @@ glusterfs_readdir_r (glusterfs_dir_t dirfd, struct dirent *entry,
                         memcpy (entry, dirp, sizeof (*entry));
                 }
 
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "new offset %ld, entry %s",
+                        offset, entry->d_name);
                 op_ret = 0;
         }
 unlock:
@@ -3946,6 +4075,7 @@ glusterfs_readdir (glusterfs_dir_t dirfd)
 
         fd_ctx = libgf_get_fd_ctx (dirfd);
         if (!fd_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "fd context not present");
                 errno = EBADF;
 		goto out;
         }
@@ -3958,10 +4088,13 @@ glusterfs_readdir (glusterfs_dir_t dirfd)
         }
         pthread_mutex_unlock (&fd_ctx->lock);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "offset %ld", offset);
         memset (dirp, 0, sizeof (struct dirent));
         op_ret = libgf_client_readdir (ctx, (fd_t *)dirfd, dirp, &offset);
 
         if (op_ret <= 0) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "readdir failed: %s",
+                        strerror (errno));
                 dirp = NULL;
                 goto out;
         }
@@ -3972,6 +4105,8 @@ glusterfs_readdir (glusterfs_dir_t dirfd)
         }
         pthread_mutex_unlock (&fd_ctx->lock);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "new offset %ld, entry %s",
+                offset, dirp->d_name);
 out:
         return dirp;
 }
@@ -4367,6 +4502,7 @@ libgf_client_stat (libglusterfs_client_ctx_t *ctx,
 
         if (libgf_is_iattr_cache_valid (ctx, loc->inode, &cachedbuf,
                                         LIBGF_VALIDATE_STAT)) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Cache will be used");
                 if (stbuf)
                         memcpy (stbuf, &cachedbuf, sizeof (struct stat));
                 goto out;
@@ -4380,6 +4516,8 @@ libgf_client_stat (libglusterfs_client_ctx_t *ctx,
         if (stbuf)
                 *stbuf = stub->args.stat_cbk.buf;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, status %d, errno %d",
+                loc->path, op_ret, errno);
         libgf_update_iattr_cache (loc->inode, LIBGF_UPDATE_STAT,
                                         &stub->args.stat_cbk.buf);
 	call_stub_destroy (stub);
@@ -4441,9 +4579,13 @@ __glusterfs_stat (glusterfs_handle_t handle, const char *path,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, op: %d", path,
+                whichstat);
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
 	op_ret = libgf_client_path_lookup (&loc, ctx, 1);
 	if (op_ret == -1) {
@@ -4516,6 +4658,7 @@ glusterfs_stat (const char *path, struct stat *buf)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, buf, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -4546,6 +4689,7 @@ glusterfs_lstat (const char *path, struct stat *buf)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, buf, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -4595,6 +4739,7 @@ libgf_client_fstat (libglusterfs_client_ctx_t *ctx,
                                         LIBGF_VALIDATE_STAT)) {
                 if (buf)
                         memcpy (buf, &cachedbuf, sizeof (struct stat));
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Cache will be used");
                 goto out;
         }
 
@@ -4606,6 +4751,8 @@ libgf_client_fstat (libglusterfs_client_ctx_t *ctx,
         if (buf)
                 *buf = stub->args.fstat_cbk.buf;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "status %d, errno %d", op_ret,
+                errno);
         libgf_update_iattr_cache (fd->inode, LIBGF_UPDATE_STAT,
                                         &stub->args.fstat_cbk.buf);
 	call_stub_destroy (stub);
@@ -4624,6 +4771,7 @@ glusterfs_fstat (glusterfs_file_t fd, struct stat *buf)
 
         fd_ctx = libgf_get_fd_ctx (fd);
         if (!fd_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 errno = EBADF;
 		op_ret = -1;
 		goto out;
@@ -4671,6 +4819,8 @@ libgf_client_mkdir (libglusterfs_client_ctx_t *ctx,
         op_ret = stub->args.mkdir_cbk.op_ret;
         errno = stub->args.mkdir_cbk.op_errno;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, status %d, errno %d",
+                loc->path, op_ret, errno);
         if (op_ret == -1)
                 goto out;
 
@@ -4704,8 +4854,10 @@ glusterfs_glh_mkdir (glusterfs_handle_t handle, const char *path, mode_t mode)
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
 	op_ret = libgf_client_path_lookup (&loc, ctx, 1);
 	if (op_ret == 0) {
@@ -4757,6 +4909,7 @@ glusterfs_mkdir (const char *path, mode_t mode)
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -4795,6 +4948,8 @@ libgf_client_rmdir (libglusterfs_client_ctx_t *ctx, loc_t *loc)
         op_ret = stub->args.rmdir_cbk.op_ret;
         errno = stub->args.rmdir_cbk.op_errno;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, status %d, errno %d",
+                loc->path, op_ret, errno);
         if (stub->args.rmdir_cbk.op_ret != 0)
                 goto out;
 
@@ -4818,8 +4973,10 @@ glusterfs_glh_rmdir (glusterfs_handle_t handle, const char *path)
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
 	op_ret = libgf_client_path_lookup (&loc, ctx, 1);
 	if (op_ret == -1) {
@@ -4865,6 +5022,7 @@ glusterfs_rmdir (const char *path)
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -4904,6 +5062,8 @@ libgf_client_chmod (libglusterfs_client_ctx_t *ctx, loc_t * loc, mode_t mode)
         op_ret = stub->args.chmod_cbk.op_ret;
         errno = stub->args.chmod_cbk.op_errno;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, status %d, errno %d",
+                loc->path, op_ret, errno);
         if (op_ret == -1)
                 goto out;
 
@@ -4927,8 +5087,11 @@ glusterfs_glh_chmod (glusterfs_handle_t handle, const char *path, mode_t mode)
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
+
         op_ret = libgf_client_path_lookup (&loc, ctx, 1);
         if (op_ret == -1)
                 goto out;
@@ -4960,6 +5123,7 @@ glusterfs_chmod (const char *path, mode_t mode)
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -5000,6 +5164,8 @@ libgf_client_chown (libglusterfs_client_ctx_t *ctx, loc_t *loc, uid_t uid,
         op_ret = stub->args.chown_cbk.op_ret;
         errno = stub->args.chown_cbk.op_errno;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, status %d, errno %d",
+                loc->path, op_ret, errno);
         if (op_ret == -1)
                 goto out;
 
@@ -5028,9 +5194,12 @@ __glusterfs_chown (glusterfs_handle_t handle, const char *path, uid_t owner,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, op %d", path, whichop);
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         op_ret = libgf_client_path_lookup (&loc, ctx, 1);
         if (op_ret == -1)
@@ -5082,6 +5251,7 @@ glusterfs_chown (const char *path, uid_t owner, gid_t group)
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -5112,6 +5282,7 @@ glusterfs_lchown (const char *path, uid_t owner, gid_t group)
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -5138,9 +5309,12 @@ glusterfs_glh_opendir (glusterfs_handle_t handle, const char *path)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
         op_ret = libgf_client_path_lookup (&loc, ctx, 1);
 
         if (op_ret == -1)
@@ -5171,6 +5345,8 @@ glusterfs_glh_opendir (glusterfs_handle_t handle, const char *path)
 
         if (!libgf_get_fd_ctx (dirfd)) {
                 if (!(libgf_alloc_fd_ctx (ctx, dirfd))) {
+                        gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Context "
+                                "allocation failed");
                         op_ret = -1;
                         errno = EINVAL;
                         goto out;
@@ -5198,6 +5374,7 @@ glusterfs_opendir (const char *path)
         glusterfs_dir_t         dir = NULL;
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
 
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
@@ -5261,6 +5438,8 @@ libgf_client_fchmod (libglusterfs_client_ctx_t *ctx, fd_t *fd, mode_t mode)
         op_ret = stub->args.fchmod_cbk.op_ret;
         errno = stub->args.fchmod_cbk.op_errno;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "status %d, errno %d", op_ret,
+                errno);
         if (op_ret == -1)
                 goto out;
 
@@ -5282,6 +5461,7 @@ glusterfs_fchmod (glusterfs_file_t fd, mode_t mode)
         fdctx = libgf_get_fd_ctx (fd);
 
         if (!fdctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "No fd context present");
                 errno = EBADF;
                 goto out;
         }
@@ -5319,6 +5499,8 @@ libgf_client_fchown (libglusterfs_client_ctx_t *ctx, fd_t *fd, uid_t uid,
         op_ret = stub->args.fchown_cbk.op_ret;
         errno = stub->args.fchown_cbk.op_errno;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "status %d, errno %d", op_ret,
+                errno);
         if (op_ret == -1)
                 goto out;
 
@@ -5340,6 +5522,7 @@ glusterfs_fchown (glusterfs_file_t fd, uid_t uid, gid_t gid)
 
         fdctx = libgf_get_fd_ctx (fd);
         if (!fd) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 errno = EBADF;
                 goto out;
         }
@@ -5375,6 +5558,8 @@ libgf_client_fsync (libglusterfs_client_ctx_t *ctx, fd_t *fd)
         op_ret = stub->args.fsync_cbk.op_ret;
         errno = stub->args.fsync_cbk.op_errno;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "status %d, errno %d", op_ret,
+                errno);
         call_stub_destroy (stub);
 
         return op_ret;
@@ -5390,6 +5575,7 @@ glusterfs_fsync (glusterfs_file_t *fd)
 
         fdctx = libgf_get_fd_ctx ((fd_t *)fd);
         if (!fd) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 errno = EBADF;
                 goto out;
         }
@@ -5470,6 +5656,7 @@ glusterfs_ftruncate (glusterfs_file_t fd, off_t length)
 
         fdctx = libgf_get_fd_ctx (fd);
         if (!fdctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 errno = EBADF;
                 goto out;
         }
@@ -5509,6 +5696,8 @@ libgf_client_link (libglusterfs_client_ctx_t *ctx, loc_t *old, loc_t *new)
         op_ret = stub->args.link_cbk.op_ret;
         errno = stub->args.link_cbk.op_errno;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "old %s, new %s, status %d,"
+                " errno %d", old->path, new->path, op_ret, errno);
         if (op_ret == -1)
                 goto out;
 
@@ -5539,9 +5728,13 @@ glusterfs_glh_link (glusterfs_handle_t handle, const char *oldpath,
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, oldpath, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, newpath, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "old %s, new %s", oldpath,
+                newpath);
         old.path = libgf_resolve_path_light ((char *)oldpath);
-        if (!old.path)
+        if (!old.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         op_ret = libgf_client_path_lookup (&old, ctx, 1);
         if (op_ret == -1) {
@@ -5564,8 +5757,10 @@ glusterfs_glh_link (glusterfs_handle_t handle, const char *oldpath,
         }
 
         new.path = libgf_resolve_path_light ((char *)newpath);
-        if (!new.path)
+        if (!new.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         op_ret = libgf_client_path_lookup (&new, ctx, 1);
         if (op_ret == 0) {
@@ -5603,6 +5798,8 @@ glusterfs_link (const char *oldpath, const char *newpath)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, oldpath, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, newpath, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "old %s, new %s", oldpath,
+                newpath);
         oldentry = libgf_vmp_search_entry ((char *)oldpath);
         if (!oldentry) {
                 errno = ENODEV;
@@ -5662,6 +5859,8 @@ libgf_client_statvfs (libglusterfs_client_ctx_t *ctx, loc_t *loc,
 
         op_ret = stub->args.statfs_cbk.op_ret;
         errno = stub->args.statfs_cbk.op_errno;
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, status %d, errno %d",
+                loc->path, op_ret, errno);
         if (op_ret == -1)
                 goto out;
 
@@ -5685,9 +5884,12 @@ glusterfs_glh_statfs (glusterfs_handle_t handle, const char *path,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         op_ret = libgf_client_path_lookup (&loc, ctx, 1);
         if (op_ret == -1) {
@@ -5753,6 +5955,7 @@ glusterfs_statfs (const char *path, struct statfs *buf)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, buf, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -5779,9 +5982,12 @@ glusterfs_glh_statvfs (glusterfs_handle_t handle, const char *path,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
         op_ret = libgf_client_path_lookup (&loc, ctx, 1);
         if (op_ret == -1) {
                 gf_log ("libglusterfsclient", GF_LOG_ERROR,
@@ -5824,6 +6030,7 @@ glusterfs_statvfs (const char *path, struct statvfs *buf)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, buf, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -5865,6 +6072,8 @@ libgf_client_rename (libglusterfs_client_ctx_t *ctx, loc_t *oldloc,
         op_ret = stub->args.rename_cbk.op_ret;
         errno = stub->args.rename_cbk.op_errno;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "old %s, new %s, status %d, errno"
+                " %d", oldloc->path, newloc->path, op_ret, errno);
         if (op_ret == -1)
                 goto out;
 
@@ -5895,9 +6104,13 @@ glusterfs_glh_rename (glusterfs_handle_t handle, const char *oldpath,
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, oldpath, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, newpath, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "old %s, new %s", oldpath,
+                newpath);
         oldloc.path = libgf_resolve_path_light ((char *)oldpath);
-        if (!oldloc.path)
+        if (!oldloc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         op_ret = libgf_client_path_lookup (&oldloc, ctx, 1);
         if (op_ret == -1) {
@@ -5907,8 +6120,10 @@ glusterfs_glh_rename (glusterfs_handle_t handle, const char *oldpath,
         }
 
         newloc.path = libgf_resolve_path_light ((char *)newpath);
-        if (!newloc.path)
+        if (!newloc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Path compaction failed");
                 goto out;
+        }
 
         op_ret = libgf_client_path_lookup (&newloc, ctx, 1);
 
@@ -5959,6 +6174,8 @@ glusterfs_rename (const char *oldpath, const char *newpath)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, oldpath, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, newpath, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Old %s, new %s", oldpath,
+                newpath);
         old = libgf_vmp_search_entry ((char *)oldpath);
         if (!old) {
                 errno = ENODEV;
@@ -6018,6 +6235,8 @@ libgf_client_utimens (libglusterfs_client_ctx_t *ctx, loc_t *loc,
         errno = stub->args.utimens_cbk.op_errno;
         stbuf = &stub->args.utimens_cbk.buf;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, status %d, errno %d",
+                loc->path, op_ret, errno);
         if (op_ret == -1)
                 goto out;
 
@@ -6042,9 +6261,12 @@ glusterfs_glh_utimes (glusterfs_handle_t handle, const char *path,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         op_ret = libgf_client_path_lookup (&loc, ctx, 1);
         if (op_ret == -1) {
@@ -6086,6 +6308,7 @@ glusterfs_utimes (const char *path, const struct timeval times[2])
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -6113,9 +6336,12 @@ glusterfs_glh_utime (glusterfs_handle_t handle, const char *path,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         op_ret = libgf_client_path_lookup (&loc, ctx, 1);
         if (op_ret == -1) {
@@ -6159,6 +6385,7 @@ glusterfs_utime (const char *path, const struct utimbuf *buf)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, buf, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -6203,6 +6430,8 @@ libgf_client_mknod (libglusterfs_client_ctx_t *ctx, loc_t *loc, mode_t mode,
         if (op_ret == -1)
                 goto out;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, status %d, errno %d",
+                loc->path, op_ret, errno);
         inode = stub->args.mknod_cbk.inode;
         libgf_transform_devnum (ctx, &stub->args.mknod_cbk.buf);
         inode_link (inode, loc->parent, loc->name, &stub->args.mknod_cbk.buf);
@@ -6231,9 +6460,12 @@ glusterfs_glh_mknod(glusterfs_handle_t handle, const char *path, mode_t mode,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         op_ret = libgf_client_path_lookup (&loc, ctx, 1);
         if (op_ret == 0) {
@@ -6279,6 +6511,7 @@ glusterfs_mknod(const char *pathname, mode_t mode, dev_t dev)
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, pathname, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", pathname);
         entry = libgf_vmp_search_entry ((char *)pathname);
         if (!entry) {
                 errno = ENODEV;
@@ -6306,9 +6539,12 @@ glusterfs_glh_mkfifo (glusterfs_handle_t handle, const char *path, mode_t mode)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Failed to resolve name");
                 goto out;
+        }
 
         op_ret = libgf_client_path_lookup (&loc, ctx, 1);
         if (op_ret == 0) {
@@ -6354,6 +6590,7 @@ glusterfs_mkfifo (const char *path, mode_t mode)
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -6393,6 +6630,7 @@ libgf_client_unlink (libglusterfs_client_ctx_t *ctx, loc_t *loc)
         op_ret = stub->args.unlink_cbk.op_ret;
         errno = stub->args.unlink_cbk.op_errno;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", loc->path);
         if (op_ret == -1)
                 goto out;
 
@@ -6414,9 +6652,12 @@ glusterfs_glh_unlink (glusterfs_handle_t handle, const char *path)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         op_ret = libgf_client_path_lookup (&loc, ctx, 1);
         if (op_ret == -1) {
@@ -6454,6 +6695,7 @@ glusterfs_unlink (const char *path)
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -6498,6 +6740,8 @@ libgf_client_symlink (libglusterfs_client_ctx_t *ctx, const char *linkpath,
         if (op_ret == -1)
                 goto out;
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "target: %s, link: %s, status %d"
+                " errno %d", linkpath, loc->path, op_ret, errno);
         inode = stub->args.symlink_cbk.inode;
         libgf_transform_devnum (ctx, &stub->args.symlink_cbk.buf);
         inode_link (inode, loc->parent, loc->name,
@@ -6527,12 +6771,16 @@ glusterfs_glh_symlink (glusterfs_handle_t handle, const char *oldpath,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, newpath, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "target: %s, link: %s", oldpath,
+                newpath);
         /* Old path does not need to be interpreted or looked up */
         oldloc.path = strdup (oldpath);
 
 	newloc.path = libgf_resolve_path_light ((char *)newpath);
-        if (!newloc.path)
+        if (!newloc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
 	op_ret = libgf_client_path_lookup (&newloc, ctx, 1);
 	if (op_ret == 0) {
@@ -6586,6 +6834,8 @@ glusterfs_symlink (const char *oldpath, const char *newpath)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, oldpath, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, newpath, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "target: %s, link: %s", oldpath,
+                newpath);
         entry = libgf_vmp_search_entry ((char *)newpath);
         if (!entry) {
                 errno = ENODEV;
@@ -6633,7 +6883,11 @@ libgf_client_readlink (libglusterfs_client_ctx_t *ctx, loc_t *loc, char *buf,
                 cpy_size = ((op_ret <= bufsize) ? op_ret : bufsize);
                 memcpy (buf, stub->args.readlink_cbk.buf, cpy_size);
                 op_ret = cpy_size;
-        }
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "link: %s, target: %s,"
+                        " status %d, errno %d", loc->path, buf, op_ret, errno);
+        } else
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "link: %s, status %d, "
+                        "errno %d", loc->path, op_ret, errno);
 
         call_stub_destroy (stub);
         return op_ret;
@@ -6651,6 +6905,7 @@ glusterfs_glh_readlink (glusterfs_handle_t handle, const char *path, char *buf,
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, ctx, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         if (bufsize < 0) {
                 errno = EINVAL;
                 goto out;
@@ -6662,8 +6917,10 @@ glusterfs_glh_readlink (glusterfs_handle_t handle, const char *path, char *buf,
         }
 
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         op_ret = libgf_client_path_lookup (&loc, ctx, 1);
         if (op_ret == -1) {
@@ -6703,6 +6960,7 @@ glusterfs_readlink (const char *path, char *buf, size_t bufsize)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, buf, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -6922,6 +7180,7 @@ glusterfs_realpath (const char *path, char *resolved_path)
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         entry = libgf_vmp_search_entry ((char *)path);
         if (!entry) {
                 errno = ENODEV;
@@ -6940,6 +7199,8 @@ glusterfs_realpath (const char *path, char *resolved_path)
         strncpy (realp, entry->vmp, entry->vmplen-1);
         strcat (realp, res);
         strcpy (resolved_path, realp);
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s, resolved %s", path,
+                resolved_path);
 out:
         if (vpath)
                 free (vpath);
@@ -6958,9 +7219,12 @@ glusterfs_glh_remove (glusterfs_handle_t handle, const char *path)
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, handle, out);
         GF_VALIDATE_ABSOLUTE_PATH_OR_GOTO (LIBGF_XL_NAME, path, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", path);
         loc.path = libgf_resolve_path_light ((char *)path);
-        if (!loc.path)
+        if (!loc.path) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "Path compaction failed");
                 goto out;
+        }
 
         op_ret = libgf_client_path_lookup (&loc, ctx, 1);
         if (op_ret == -1)
@@ -6993,6 +7257,7 @@ glusterfs_remove(const char *pathname)
 
         GF_VALIDATE_OR_GOTO (LIBGF_XL_NAME, pathname, out);
 
+        gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "path %s", pathname);
         entry = libgf_vmp_search_entry ((char *)pathname);
         if (!entry) {
                 errno = ENODEV;
@@ -7015,6 +7280,7 @@ glusterfs_rewinddir (glusterfs_dir_t dirfd)
 
         fd_ctx = libgf_get_fd_ctx ((fd_t *)dirfd);
         if (!fd_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 errno = EBADF;
                 goto out;
         }
@@ -7022,6 +7288,8 @@ glusterfs_rewinddir (glusterfs_dir_t dirfd)
         pthread_mutex_lock (&fd_ctx->lock);
         {
                 fd_ctx->offset = 0;
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Offset: %ld",
+                        fd_ctx->offset);
         }
         pthread_mutex_unlock (&fd_ctx->lock);
 
@@ -7035,12 +7303,16 @@ glusterfs_seekdir (glusterfs_dir_t dirfd, off_t offset)
         libglusterfs_client_fd_ctx_t    *fd_ctx = NULL;
 
         fd_ctx = libgf_get_fd_ctx ((fd_t *)dirfd);
-        if (!fd_ctx)
+        if (!fd_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 goto out;
+        }
 
         pthread_mutex_lock (&fd_ctx->lock);
         {
                 fd_ctx->offset = offset;
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Offset: %ld",
+                        fd_ctx->offset);
         }
         pthread_mutex_unlock (&fd_ctx->lock);
 
@@ -7056,6 +7328,7 @@ glusterfs_telldir (glusterfs_dir_t dirfd)
 
         fd_ctx = libgf_get_fd_ctx ((fd_t *)dirfd);
         if (!fd_ctx) {
+                gf_log (LIBGF_XL_NAME, GF_LOG_ERROR, "No fd context present");
                 errno = EBADF;
                 goto out;
         }
@@ -7063,6 +7336,8 @@ glusterfs_telldir (glusterfs_dir_t dirfd)
         pthread_mutex_lock (&fd_ctx->lock);
         {
                 off = fd_ctx->offset;
+                gf_log (LIBGF_XL_NAME, GF_LOG_DEBUG, "Offset: %ld",
+                        fd_ctx->offset);
         }
         pthread_mutex_unlock (&fd_ctx->lock);