1 files changed, 98 insertions, 80 deletions

diff --git a/api/src/glfs-resolve.c b/api/src/glfs-resolve.c
index 155d3dc538f..8a393ecb464 100644
--- a/api/src/glfs-resolve.c
+++ b/api/src/glfs-resolve.c
@@ -15,16 +15,16 @@
 #include <inttypes.h>
 #include <limits.h>
 
-#include "glusterfs.h"
-#include "logging.h"
-#include "stack.h"
-#include "gf-event.h"
+#include <glusterfs/glusterfs.h>
+#include <glusterfs/logging.h>
+#include <glusterfs/stack.h>
+#include <glusterfs/gf-event.h>
 #include "glfs-mem-types.h"
-#include "common-utils.h"
-#include "syncop.h"
-#include "call-stub.h"
+#include <glusterfs/common-utils.h>
+#include <glusterfs/syncop.h>
+#include <glusterfs/call-stub.h>
 #include "gfapi-messages.h"
-#include "inode.h"
+#include <glusterfs/inode.h>
 #include "glfs-internal.h"
 
 #define graphid_str(subvol)                                                    \
@@ -65,6 +65,9 @@ __glfs_first_lookup(struct glfs *fs, xlator_t *subvol)
     fs->migration_in_progress = 0;
     pthread_cond_broadcast(&fs->cond);
 
+    /* wake up other waiting tasks */
+    __GLFS_SYNCTASK_WAKE(fs);
+
     return ret;
 }
 
@@ -116,9 +119,9 @@ glfs_refresh_inode_safe(xlator_t *subvol, inode_t *oldinode,
     DECODE_SYNCOP_ERR(ret);
 
     if (ret) {
-        gf_msg(subvol->name, GF_LOG_WARNING, errno,
-               API_MSG_INODE_REFRESH_FAILED, "inode refresh of %s failed: %s",
-               uuid_utoa(oldinode->gfid), strerror(errno));
+        gf_smsg(subvol->name, GF_LOG_WARNING, errno,
+                API_MSG_INODE_REFRESH_FAILED, "gfid=%s",
+                uuid_utoa(oldinode->gfid), "err=%s", strerror(errno), NULL);
         loc_wipe(&loc);
         return NULL;
     }
@@ -129,9 +132,8 @@ glfs_refresh_inode_safe(xlator_t *subvol, inode_t *oldinode,
             inode_ctx_set(newinode, THIS, &ctx_value);
         inode_lookup(newinode);
     } else {
-        gf_msg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
-               "inode linking of %s failed",
-               uuid_utoa((unsigned char *)&iatt.ia_gfid));
+        gf_smsg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
+                "gfid=%s", uuid_utoa((unsigned char *)&iatt.ia_gfid), NULL);
     }
 
     loc_wipe(&loc);
@@ -154,9 +156,13 @@ __glfs_refresh_inode(struct glfs *fs, xlator_t *subvol, inode_t *inode,
     fs->migration_in_progress = 0;
     pthread_cond_broadcast(&fs->cond);
 
+    /* wake up other waiting tasks */
+    __GLFS_SYNCTASK_WAKE(fs);
+
     return newinode;
 }
 
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_loc_touchup, 3.4.0)
 int
 priv_glfs_loc_touchup(loc_t *loc)
 {
@@ -171,8 +177,6 @@ priv_glfs_loc_touchup(loc_t *loc)
     return ret;
 }
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_loc_touchup, 3.4.0);
-
 int
 glfs_resolve_symlink(struct glfs *fs, xlator_t *subvol, inode_t *inode,
                      char **lpath)
@@ -335,6 +339,7 @@ glfs_resolve_component(struct glfs *fs, xlator_t *subvol, inode_t *parent,
         if (temp_parent) {
             inode_unref(loc.parent);
             loc.parent = temp_parent;
+            gf_uuid_copy(loc.pargfid, temp_parent->gfid);
             inode_find_directory_name(loc.inode, &loc.name);
         }
 
@@ -345,10 +350,12 @@ glfs_resolve_component(struct glfs *fs, xlator_t *subvol, inode_t *parent,
             if (temp_parent) {
                 inode_unref(loc.parent);
                 loc.parent = temp_parent;
+                gf_uuid_copy(loc.pargfid, temp_parent->gfid);
                 inode_find_directory_name(loc.inode, &loc.name);
             } else if (__is_root_gfid(loc.inode->gfid)) {
                 inode_unref(loc.parent);
                 loc.parent = inode_ref(loc.inode);
+                gf_uuid_copy(loc.pargfid, loc.inode->gfid);
                 loc.name = ".";
             } else {
                 inode_unref(loc.inode);
@@ -439,9 +446,8 @@ glfs_resolve_component(struct glfs *fs, xlator_t *subvol, inode_t *parent,
     inode = inode_link(loc.inode, loc.parent, component, &ciatt);
 
     if (!inode) {
-        gf_msg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
-               "inode linking of %s failed",
-               uuid_utoa((unsigned char *)&ciatt.ia_gfid));
+        gf_smsg(subvol->name, GF_LOG_WARNING, errno, API_MSG_INODE_LINK_FAILED,
+                "gfid=%s", uuid_utoa((unsigned char *)&ciatt.ia_gfid), NULL);
         goto out;
     } else if (inode == loc.inode)
         inode_ctx_set(inode, THIS, &ctx_value);
@@ -460,6 +466,7 @@ out:
     return inode;
 }
 
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_resolve_at, 3.4.0)
 int
 priv_glfs_resolve_at(struct glfs *fs, xlator_t *subvol, inode_t *at,
                      const char *origpath, loc_t *loc, struct iatt *iatt,
@@ -610,8 +617,6 @@ invalid_fs:
     return ret;
 }
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_resolve_at, 3.4.0);
-
 int
 glfs_resolve_path(struct glfs *fs, xlator_t *subvol, const char *origpath,
                   loc_t *loc, struct iatt *iatt, int follow, int reval)
@@ -625,8 +630,8 @@ glfs_resolve_path(struct glfs *fs, xlator_t *subvol, const char *origpath,
 
     cwd = glfs_cwd_get(fs);
     if (NULL == cwd) {
-        gf_msg(subvol->name, GF_LOG_WARNING, EIO, API_MSG_GET_CWD_FAILED,
-               "Failed to get cwd");
+        gf_smsg(subvol->name, GF_LOG_WARNING, EIO, API_MSG_GET_CWD_FAILED,
+                NULL);
         errno = EIO;
         goto out;
     }
@@ -640,6 +645,7 @@ out:
     return ret;
 }
 
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_resolve, 3.7.0)
 int
 priv_glfs_resolve(struct glfs *fs, xlator_t *subvol, const char *origpath,
                   loc_t *loc, struct iatt *iatt, int reval)
@@ -650,7 +656,6 @@ priv_glfs_resolve(struct glfs *fs, xlator_t *subvol, const char *origpath,
 
     return ret;
 }
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_resolve, 3.7.0);
 
 int
 glfs_lresolve(struct glfs *fs, xlator_t *subvol, const char *origpath,
@@ -680,28 +685,27 @@ glfs_migrate_fd_locks_safe(struct glfs *fs, xlator_t *oldsubvol, fd_t *oldfd,
                            NULL, NULL);
     DECODE_SYNCOP_ERR(ret);
     if (ret < 0) {
-        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FGETXATTR_FAILED,
-               "fgetxattr (%s) failed (%s) on graph %s (%d)",
-               uuid_utoa_r(oldfd->inode->gfid, uuid1), strerror(errno),
-               graphid_str(oldsubvol), oldsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FGETXATTR_FAILED,
+                "gfid=%s", uuid_utoa_r(oldfd->inode->gfid, uuid1), "err=%s",
+                strerror(errno), "subvol=%s", graphid_str(oldsubvol), "id=%d",
+                oldsubvol->graph->id, NULL);
         goto out;
     }
 
     if (!dict_get(lockinfo, GF_XATTR_LOCKINFO_KEY)) {
-        gf_msg(fs->volname, GF_LOG_WARNING, 0, API_MSG_LOCKINFO_KEY_MISSING,
-               "missing lockinfo key (%s) on graph %s (%d)",
-               uuid_utoa_r(oldfd->inode->gfid, uuid1), graphid_str(oldsubvol),
-               oldsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, 0, API_MSG_LOCKINFO_KEY_MISSING,
+                "gfid=%s", uuid_utoa_r(oldfd->inode->gfid, uuid1), "subvol=%s",
+                graphid_str(oldsubvol), "id=%d", oldsubvol->graph->id, NULL);
         goto out;
     }
 
     ret = syncop_fsetxattr(newsubvol, newfd, lockinfo, 0, NULL, NULL);
     DECODE_SYNCOP_ERR(ret);
     if (ret < 0) {
-        gf_msg(fs->volname, GF_LOG_WARNING, 0, API_MSG_FSETXATTR_FAILED,
-               "fsetxattr (%s) failed (%s) on graph %s (%d)",
-               uuid_utoa_r(newfd->inode->gfid, uuid1), strerror(errno),
-               graphid_str(newsubvol), newsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, 0, API_MSG_FSETXATTR_FAILED,
+                "gfid=%s", uuid_utoa_r(newfd->inode->gfid, uuid1), "err=%s",
+                strerror(errno), "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
         goto out;
     }
 out:
@@ -722,6 +726,7 @@ glfs_migrate_fd_safe(struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
         0,
     };
     char uuid1[64];
+    dict_t *xdata = NULL;
 
     oldinode = oldfd->inode;
     oldsubvol = oldinode->table->xl;
@@ -730,32 +735,43 @@ glfs_migrate_fd_safe(struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
         return fd_ref(oldfd);
 
     if (!oldsubvol->switched) {
-        ret = syncop_fsync(oldsubvol, oldfd, 0, NULL, NULL, NULL, NULL);
+        xdata = dict_new();
+        if (!xdata || dict_set_int8(xdata, "last-fsync", 1)) {
+            gf_smsg(fs->volname, GF_LOG_WARNING, ENOMEM, API_MSG_FSYNC_FAILED,
+                    "err=%s", "last-fsync set failed", "gfid=%s",
+                    uuid_utoa_r(oldfd->inode->gfid, uuid1), "subvol=%s",
+                    graphid_str(oldsubvol), "id=%d", oldsubvol->graph->id,
+                    NULL);
+        }
+
+        ret = syncop_fsync(oldsubvol, oldfd, 0, NULL, NULL, xdata, NULL);
         DECODE_SYNCOP_ERR(ret);
         if (ret) {
-            gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FSYNC_FAILED,
-                   "fsync() failed "
-                   "(%s) on %s graph %s (%d)",
-                   strerror(errno), uuid_utoa_r(oldfd->inode->gfid, uuid1),
-                   graphid_str(oldsubvol), oldsubvol->graph->id);
+            gf_smsg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FSYNC_FAILED,
+                    "err=%s", strerror(errno), "gfid=%s",
+                    uuid_utoa_r(oldfd->inode->gfid, uuid1), "subvol=%s",
+                    graphid_str(oldsubvol), "id=%d", oldsubvol->graph->id,
+                    NULL);
         }
     }
 
     newinode = glfs_refresh_inode_safe(newsubvol, oldinode, _gf_false);
     if (!newinode) {
-        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_INODE_REFRESH_FAILED,
-               "inode (%s) refresh failed (%s) on graph %s (%d)",
-               uuid_utoa_r(oldinode->gfid, uuid1), strerror(errno),
-               graphid_str(newsubvol), newsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno,
+                API_MSG_INODE_REFRESH_FAILED, "gfid=%s",
+                uuid_utoa_r(oldinode->gfid, uuid1), "err=%s", strerror(errno),
+                "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
         goto out;
     }
 
     newfd = fd_create(newinode, getpid());
     if (!newfd) {
-        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_FDCREATE_FAILED,
-               "fd_create (%s) failed (%s) on graph %s (%d)",
-               uuid_utoa_r(newinode->gfid, uuid1), strerror(errno),
-               graphid_str(newsubvol), newsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno,
+                API_MSG_FDCREATE_FAILED_ON_GRAPH, "gfid=%s",
+                uuid_utoa_r(newinode->gfid, uuid1), "err=%s", strerror(errno),
+                "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
         goto out;
     }
 
@@ -763,8 +779,7 @@ glfs_migrate_fd_safe(struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
 
     ret = inode_path(oldfd->inode, NULL, (char **)&loc.path);
     if (ret < 0) {
-        gf_msg(fs->volname, GF_LOG_INFO, 0, API_MSG_INODE_PATH_FAILED,
-               "inode_path failed");
+        gf_smsg(fs->volname, GF_LOG_INFO, 0, API_MSG_INODE_PATH_FAILED, NULL);
         goto out;
     }
 
@@ -780,21 +795,21 @@ glfs_migrate_fd_safe(struct glfs *fs, xlator_t *newsubvol, fd_t *oldfd)
     loc_wipe(&loc);
 
     if (ret) {
-        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_SYNCOP_OPEN_FAILED,
-               "syncop_open%s (%s) failed (%s) on graph %s (%d)",
-               IA_ISDIR(oldinode->ia_type) ? "dir" : "",
-               uuid_utoa_r(newinode->gfid, uuid1), strerror(errno),
-               graphid_str(newsubvol), newsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno, API_MSG_SYNCOP_OPEN_FAILED,
+                "type=%s", IA_ISDIR(oldinode->ia_type) ? "dir" : "", "gfid=%s",
+                uuid_utoa_r(newinode->gfid, uuid1), "err=%s", strerror(errno),
+                "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
         goto out;
     }
 
     ret = glfs_migrate_fd_locks_safe(fs, oldsubvol, oldfd, newsubvol, newfd);
 
     if (ret) {
-        gf_msg(fs->volname, GF_LOG_WARNING, errno, API_MSG_LOCK_MIGRATE_FAILED,
-               "lock migration (%s) failed (%s) on graph %s (%d)",
-               uuid_utoa_r(newinode->gfid, uuid1), strerror(errno),
-               graphid_str(newsubvol), newsubvol->graph->id);
+        gf_smsg(fs->volname, GF_LOG_WARNING, errno, API_MSG_LOCK_MIGRATE_FAILED,
+                "gfid=%s", uuid_utoa_r(newinode->gfid, uuid1), "err=%s",
+                strerror(errno), "subvol=%s", graphid_str(newsubvol), "id=%d",
+                newsubvol->graph->id, NULL);
         goto out;
     }
 
@@ -809,6 +824,9 @@ out:
         newfd = NULL;
     }
 
+    if (xdata)
+        dict_unref(xdata);
+
     return newfd;
 }
 
@@ -829,6 +847,9 @@ __glfs_migrate_fd(struct glfs *fs, xlator_t *newsubvol, struct glfs_fd *glfd)
     fs->migration_in_progress = 0;
     pthread_cond_broadcast(&fs->cond);
 
+    /* wake up other waiting tasks */
+    __GLFS_SYNCTASK_WAKE(fs);
+
     return newfd;
 }
 
@@ -875,9 +896,9 @@ __glfs_migrate_openfds(struct glfs *fs, xlator_t *subvol)
     list_for_each_entry(glfd, &fs->openfds, openfds)
     {
         if (gf_uuid_is_null(glfd->fd->inode->gfid)) {
-            gf_msg(fs->volname, GF_LOG_INFO, 0, API_MSG_OPENFD_SKIPPED,
-                   "skipping openfd %p/%p in graph %s (%d)", glfd, glfd->fd,
-                   graphid_str(subvol), subvol->graph->id);
+            gf_smsg(fs->volname, GF_LOG_INFO, 0, API_MSG_OPENFD_SKIPPED,
+                    "glfd=%p", glfd, "glfd->fd=%p", glfd->fd, "subvol=%s",
+                    graphid_str(subvol), "id=%d", subvol->graph->id, NULL);
             /* create in progress, defer */
             continue;
         }
@@ -912,10 +933,10 @@ __glfs_active_subvol(struct glfs *fs)
 
     ret = __glfs_first_lookup(fs, new_subvol);
     if (ret) {
-        gf_msg(fs->volname, GF_LOG_INFO, errno,
-               API_MSG_FIRST_LOOKUP_GRAPH_FAILED,
-               "first lookup on graph %s (%d) failed (%s)",
-               graphid_str(new_subvol), new_subvol->graph->id, strerror(errno));
+        gf_smsg(fs->volname, GF_LOG_INFO, errno,
+                API_MSG_FIRST_LOOKUP_GRAPH_FAILED, "subvol=%s",
+                graphid_str(new_subvol), "id=%d", new_subvol->graph->id,
+                "err=%s", strerror(errno), NULL);
         return NULL;
     }
 
@@ -924,11 +945,11 @@ __glfs_active_subvol(struct glfs *fs)
 
         if (!new_cwd) {
             char buf1[64];
-            gf_msg(fs->volname, GF_LOG_INFO, errno,
-                   API_MSG_CWD_GRAPH_REF_FAILED,
-                   "cwd refresh of %s graph %s (%d) failed (%s)",
-                   uuid_utoa_r(fs->cwd->gfid, buf1), graphid_str(new_subvol),
-                   new_subvol->graph->id, strerror(errno));
+            gf_smsg(fs->volname, GF_LOG_INFO, errno,
+                    API_MSG_CWD_GRAPH_REF_FAILED, "buf=%s",
+                    uuid_utoa_r(fs->cwd->gfid, buf1), "subvol=%s",
+                    graphid_str(new_subvol), "id=%d", new_subvol->graph->id,
+                    "err=%s", strerror(errno), NULL);
             return NULL;
         }
     }
@@ -949,13 +970,13 @@ __glfs_active_subvol(struct glfs *fs)
         inode_unref(new_cwd);
     }
 
-    gf_msg(fs->volname, GF_LOG_INFO, 0, API_MSG_SWITCHED_GRAPH,
-           "switched to graph %s (%d)", graphid_str(new_subvol),
-           new_subvol->graph->id);
+    gf_smsg(fs->volname, GF_LOG_INFO, 0, API_MSG_SWITCHED_GRAPH, "subvol=%s",
+            graphid_str(new_subvol), "id=%d", new_subvol->graph->id, NULL);
 
     return new_subvol;
 }
 
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_subvol_done, 3.4.0)
 void
 priv_glfs_subvol_done(struct glfs *fs, xlator_t *subvol)
 {
@@ -983,8 +1004,7 @@ priv_glfs_subvol_done(struct glfs *fs, xlator_t *subvol)
     }
 }
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_subvol_done, 3.4.0);
-
+GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_active_subvol, 3.4.0)
 xlator_t *
 priv_glfs_active_subvol(struct glfs *fs)
 {
@@ -1012,8 +1032,6 @@ priv_glfs_active_subvol(struct glfs *fs)
     return subvol;
 }
 
-GFAPI_SYMVER_PRIVATE_DEFAULT(glfs_active_subvol, 3.4.0);
-
 int
 __glfs_cwd_set(struct glfs *fs, inode_t *inode)
 {