path: root/0152-storage-posix-changes-with-respect-to-cloudsync.patch

From 10e9f850017d58fcd813ccce253784280326f1d0 Mon Sep 17 00:00:00 2001
From: Anuradha Talur <atalur@commvault.com>
Date: Tue, 20 Nov 2018 13:15:26 -0800
Subject: [PATCH 152/169] storage/posix: changes with respect to cloudsync

Main changes include logic to update iatt buf
with file size from extended attributes in posix
rather than having this logic in cloudsync xlator.

backport of:https://review.gluster.org/#/c/glusterfs/+/21694/

> Change-Id: I44f5f8df7a01e496372557fe2f4eff368dbdaa33
> fixes: bz#1642168
> Signed-off-by: Anuradha Talur <atalur@commvault.com>

Change-Id: I34880d856fb3add4ce88d64021d08d95405fc1c1
Signed-off-by: Susant Palai <spalai@redhat.com>
Reviewed-on: https://code.engineering.redhat.com/gerrit/172191
Tested-by: RHGS Build Bot <nigelb@redhat.com>
Reviewed-by: Atin Mukherjee <amukherj@redhat.com>
---
 xlators/storage/posix/src/posix-entry-ops.c    |   1 +
 xlators/storage/posix/src/posix-helpers.c      |  50 +++++++++
 xlators/storage/posix/src/posix-inode-fd-ops.c | 139 ++++++++++++++++++++++---
 xlators/storage/posix/src/posix.h              |   2 +
 4 files changed, 177 insertions(+), 15 deletions(-)

diff --git a/xlators/storage/posix/src/posix-entry-ops.c b/xlators/storage/posix/src/posix-entry-ops.c
index fbd83c4..b24a052 100644
--- a/xlators/storage/posix/src/posix-entry-ops.c
+++ b/xlators/storage/posix/src/posix-entry-ops.c
@@ -272,6 +272,7 @@ posix_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
         }
     }
 
+    posix_update_iatt_buf(&buf, -1, real_path, xdata);
     if (priv->update_pgfid_nlinks) {
         if (!gf_uuid_is_null(loc->pargfid) && !IA_ISDIR(buf.ia_type)) {
             MAKE_PGFID_XATTR_KEY(pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX,
diff --git a/xlators/storage/posix/src/posix-helpers.c b/xlators/storage/posix/src/posix-helpers.c
index 37e33a9..d0fd45a 100644
--- a/xlators/storage/posix/src/posix-helpers.c
+++ b/xlators/storage/posix/src/posix-helpers.c
@@ -3453,3 +3453,53 @@ posix_check_dev_file(xlator_t *this, inode_t *inode, char *fop, int *op_errno)
 out:
     return ret;
 }
+
+void
+posix_update_iatt_buf(struct iatt *buf, int fd, char *loc, dict_t *xattr_req)
+{
+    int ret = 0;
+    char val[4096] = {
+        0,
+    };
+
+    if (!xattr_req)
+        return;
+
+    if (!(dict_getn(xattr_req, GF_CS_OBJECT_STATUS,
+                    strlen(GF_CS_OBJECT_STATUS))))
+        return;
+
+    if (fd != -1) {
+        ret = sys_fgetxattr(fd, GF_CS_OBJECT_SIZE, &val, sizeof(val));
+        if (ret > 0) {
+            buf->ia_size = atoll(val);
+        } else {
+            /* Safe to assume that the other 2 xattrs are also not set*/
+            return;
+        }
+        ret = sys_fgetxattr(fd, GF_CS_BLOCK_SIZE, &val, sizeof(val));
+        if (ret > 0) {
+            buf->ia_blksize = atoll(val);
+        }
+        ret = sys_fgetxattr(fd, GF_CS_NUM_BLOCKS, &val, sizeof(val));
+        if (ret > 0) {
+            buf->ia_blocks = atoll(val);
+        }
+    } else {
+        ret = sys_lgetxattr(loc, GF_CS_OBJECT_SIZE, &val, sizeof(val));
+        if (ret > 0) {
+            buf->ia_size = atoll(val);
+        } else {
+            /* Safe to assume that the other 2 xattrs are also not set*/
+            return;
+        }
+        ret = sys_lgetxattr(loc, GF_CS_BLOCK_SIZE, &val, sizeof(val));
+        if (ret > 0) {
+            buf->ia_blksize = atoll(val);
+        }
+        ret = sys_lgetxattr(loc, GF_CS_NUM_BLOCKS, &val, sizeof(val));
+        if (ret > 0) {
+            buf->ia_blocks = atoll(val);
+        }
+    }
+}
diff --git a/xlators/storage/posix/src/posix-inode-fd-ops.c b/xlators/storage/posix/src/posix-inode-fd-ops.c
index 7dbbd3d..065fced 100644
--- a/xlators/storage/posix/src/posix-inode-fd-ops.c
+++ b/xlators/storage/posix/src/posix-inode-fd-ops.c
@@ -108,6 +108,63 @@ extern char *marker_xattrs[];
 static char *disallow_removexattrs[] = {GF_XATTR_VOL_ID_KEY, GFID_XATTR_KEY,
                                         NULL};
 
+void
+posix_cs_build_xattr_rsp(xlator_t *this, dict_t **rsp, dict_t *req, int fd,
+                         char *loc)
+{
+    int ret = 0;
+    uuid_t uuid;
+
+    if (!(dict_getn(req, GF_CS_OBJECT_STATUS, strlen(GF_CS_OBJECT_STATUS))))
+        return;
+
+    if (!(*rsp)) {
+        *rsp = dict_new();
+        if (!(*rsp)) {
+            return;
+        }
+    }
+
+    if (fd != -1) {
+        if (dict_getn(req, GF_CS_XATTR_ARCHIVE_UUID,
+                      strlen(GF_CS_XATTR_ARCHIVE_UUID))) {
+            ret = sys_fgetxattr(fd, GF_CS_XATTR_ARCHIVE_UUID, uuid, 16);
+            if (ret > 0) {
+                ret = dict_set_gfuuid(*rsp, GF_CS_XATTR_ARCHIVE_UUID, uuid,
+                                      true);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_DICT_SET_FAILED,
+                           "%s: Failed to set "
+                           "dictionary value for %s for fd %d",
+                           uuid_utoa(uuid), GF_CS_XATTR_ARCHIVE_UUID, fd);
+                }
+            } else {
+                gf_msg_debug(this->name, 0, "getxattr failed on %s for fd %d",
+                             GF_CS_XATTR_ARCHIVE_UUID, fd);
+            }
+        }
+    } else {
+        if (dict_getn(req, GF_CS_XATTR_ARCHIVE_UUID,
+                      strlen(GF_CS_XATTR_ARCHIVE_UUID))) {
+            ret = sys_lgetxattr(loc, GF_CS_XATTR_ARCHIVE_UUID, uuid, 16);
+            if (ret > 0) {
+                ret = dict_set_gfuuid(*rsp, GF_CS_XATTR_ARCHIVE_UUID, uuid,
+                                      true);
+                if (ret) {
+                    gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_DICT_SET_FAILED,
+                           "%s: Failed to set "
+                           "dictionary value for %s for loc %s",
+                           uuid_utoa(uuid), GF_CS_XATTR_ARCHIVE_UUID, loc);
+                }
+            } else {
+                gf_msg_debug(this->name, 0, "getxattr failed on %s for %s",
+                             GF_CS_XATTR_ARCHIVE_UUID, loc);
+            }
+        }
+    }
+    return;
+}
+
 int32_t
 posix_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 {
@@ -150,8 +207,11 @@ posix_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata)
 
         posix_cs_maintenance(this, NULL, loc, NULL, &buf, real_path, xdata,
                              &xattr_rsp, _gf_true);
+
+        posix_cs_build_xattr_rsp(this, &xattr_rsp, xdata, -1, real_path);
     }
 
+    posix_update_iatt_buf(&buf, -1, real_path, xdata);
     op_ret = 0;
 
 out:
@@ -422,6 +482,8 @@ posix_setattr(call_frame_t *frame, xlator_t *this, loc_t *loc,
     if (xdata)
         xattr_rsp = posix_xattr_fill(this, real_path, loc, NULL, -1, xdata,
                                      &statpost);
+    posix_update_iatt_buf(&statpre, -1, real_path, xdata);
+    posix_update_iatt_buf(&statpost, -1, real_path, xdata);
     op_ret = 0;
 
 out:
@@ -898,6 +960,7 @@ posix_do_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
         }
     }
 
+    posix_update_iatt_buf(statpre, pfd->fd, NULL, xdata);
     /* See if we can use FALLOC_FL_ZERO_RANGE to perform the zero fill.
      * If it fails, fall back to _posix_do_zerofill() and an optional fsync.
      */
@@ -1366,6 +1429,7 @@ posix_truncate(call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset,
         }
     }
 
+    posix_update_iatt_buf(&prebuf, -1, real_path, xdata);
     op_ret = sys_truncate(real_path, offset);
     if (op_ret == -1) {
         op_errno = errno;
@@ -1405,6 +1469,10 @@ posix_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
     int32_t _fd = -1;
     struct posix_fd *pfd = NULL;
     struct posix_private *priv = NULL;
+    struct iatt preop = {
+        0,
+    };
+    dict_t *rsp_xdata = NULL;
     struct iatt stbuf = {
         0,
     };
@@ -1471,6 +1539,18 @@ posix_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags,
     pfd->flags = flags;
     pfd->fd = _fd;
 
+    if (xdata) {
+        op_ret = posix_fdstat(this, fd->inode, pfd->fd, &preop);
+        if (op_ret == -1) {
+            gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_FSTAT_FAILED,
+                   "pre-operation fstat failed on fd=%p", fd);
+            goto out;
+        }
+
+        posix_cs_maintenance(this, fd, NULL, &pfd->fd, &preop, NULL, xdata,
+                             &rsp_xdata, _gf_true);
+    }
+
     op_ret = fd_ctx_set(fd, this, (uint64_t)(long)pfd);
     if (op_ret)
         gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_FD_PATH_SETTING_FAILED,
@@ -1488,7 +1568,7 @@ out:
 
     SET_TO_OLD_FS_ID();
 
-    STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, NULL);
+    STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, rsp_xdata);
 
     return 0;
 }
@@ -1573,6 +1653,7 @@ posix_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
         }
     }
 
+    posix_update_iatt_buf(&preop, _fd, NULL, xdata);
     op_ret = sys_pread(_fd, iobuf->ptr, size, offset);
     if (op_ret == -1) {
         op_errno = errno;
@@ -1878,6 +1959,7 @@ posix_writev(call_frame_t *frame, xlator_t *this, fd_t *fd,
         }
     }
 
+    posix_update_iatt_buf(&preop, _fd, NULL, xdata);
     if (locked && write_append) {
         if (preop.ia_size == offset || (fd->flags & O_APPEND))
             is_append = 1;
@@ -2531,10 +2613,8 @@ posix_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
         0,
     };
     data_t *tdata = NULL;
-    char stime[4096];
-    char sxattr[4096];
+    char *cs_var = NULL;
     gf_cs_obj_state state = -1;
-    char remotepath[4096] = {0};
     int i = 0;
     int len;
 
@@ -2588,10 +2668,11 @@ posix_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
                 goto unlock;
             }
 
-            sprintf(stime, "%" PRId64, tmp_stbuf.ia_mtime);
+            cs_var = alloca(4096);
+            sprintf(cs_var, "%" PRId64, tmp_stbuf.ia_mtime);
 
             /*TODO: may be should consider nano-second also */
-            if (strncmp(stime, tdata->data, tdata->len) != 0) {
+            if (strncmp(cs_var, tdata->data, tdata->len) > 0) {
                 gf_msg(this->name, GF_LOG_ERROR, 0, 0,
                        "mtime "
                        "passed is different from seen by file now."
@@ -2601,31 +2682,54 @@ posix_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
                 goto unlock;
             }
 
-            len = sprintf(sxattr, "%" PRIu64, tmp_stbuf.ia_size);
+            len = sprintf(cs_var, "%" PRIu64, tmp_stbuf.ia_size);
 
-            ret = sys_lsetxattr(real_path, GF_CS_OBJECT_SIZE, sxattr, len,
+            ret = sys_lsetxattr(real_path, GF_CS_OBJECT_SIZE, cs_var, len,
                                 flags);
             if (ret) {
+                op_errno = errno;
                 gf_msg(this->name, GF_LOG_ERROR, 0, 0,
                        "setxattr failed. key %s err %d", GF_CS_OBJECT_SIZE,
                        ret);
+                goto unlock;
+            }
+
+            len = sprintf(cs_var, "%" PRIu64, tmp_stbuf.ia_blocks);
+
+            ret = sys_lsetxattr(real_path, GF_CS_NUM_BLOCKS, cs_var, len,
+                                flags);
+            if (ret) {
                 op_errno = errno;
+                gf_msg(this->name, GF_LOG_ERROR, 0, 0,
+                       "setxattr failed. key %s err %d", GF_CS_NUM_BLOCKS, ret);
                 goto unlock;
             }
 
+            len = sprintf(cs_var, "%" PRIu32, tmp_stbuf.ia_blksize);
+
+            ret = sys_lsetxattr(real_path, GF_CS_BLOCK_SIZE, cs_var, len,
+                                flags);
+            if (ret) {
+                op_errno = errno;
+                gf_msg(this->name, GF_LOG_ERROR, 0, 0,
+                       "setxattr failed. key %s err %d", GF_CS_BLOCK_SIZE, ret);
+                goto unlock;
+            }
+
+            memset(cs_var, 0, 4096);
             if (loc->path[0] == '/') {
                 for (i = 1; i < strlen(loc->path); i++) {
-                    remotepath[i - 1] = loc->path[i];
+                    cs_var[i - 1] = loc->path[i];
                 }
 
-                remotepath[i] = '\0';
-                gf_msg_debug(this->name, GF_LOG_ERROR, "remotepath %s",
-                             remotepath);
+                cs_var[i] = '\0';
+                gf_msg_debug(this->name, GF_LOG_ERROR, "remotepath %s", cs_var);
             }
 
-            ret = sys_lsetxattr(real_path, GF_CS_OBJECT_REMOTE, remotepath,
-                                strlen(loc->path), flags);
+            ret = sys_lsetxattr(real_path, GF_CS_OBJECT_REMOTE, cs_var,
+                                strlen(cs_var), flags);
             if (ret) {
+                op_errno = errno;
                 gf_log("POSIX", GF_LOG_ERROR,
                        "setxattr failed - %s"
                        " %d",
@@ -2635,13 +2739,14 @@ posix_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
 
             ret = sys_truncate(real_path, 0);
             if (ret) {
+                op_errno = errno;
                 gf_log("POSIX", GF_LOG_ERROR,
                        "truncate failed - %s"
                        " %d",
                        GF_CS_OBJECT_SIZE, ret);
-                op_errno = errno;
                 ret = sys_lremovexattr(real_path, GF_CS_OBJECT_REMOTE);
                 if (ret) {
+                    op_errno = errno;
                     gf_log("POSIX", GF_LOG_ERROR,
                            "removexattr "
                            "failed post processing- %s"
@@ -2659,6 +2764,7 @@ posix_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict,
         }
     unlock:
         UNLOCK(&loc->inode->lock);
+        op_ret = ret;
         goto out;
     }
 
@@ -4927,6 +5033,7 @@ posix_ftruncate(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
         }
     }
 
+    posix_update_iatt_buf(&preop, _fd, NULL, xdata);
     op_ret = sys_ftruncate(_fd, offset);
 
     if (op_ret == -1) {
@@ -5008,8 +5115,10 @@ posix_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata)
             gf_msg(this->name, GF_LOG_ERROR, 0, 0,
                    "file state check failed, fd %p", fd);
         }
+        posix_cs_build_xattr_rsp(this, &xattr_rsp, xdata, _fd, NULL);
     }
 
+    posix_update_iatt_buf(&buf, _fd, NULL, xdata);
     op_ret = 0;
 
 out:
diff --git a/xlators/storage/posix/src/posix.h b/xlators/storage/posix/src/posix.h
index d5ba08c..1da4d01 100644
--- a/xlators/storage/posix/src/posix.h
+++ b/xlators/storage/posix/src/posix.h
@@ -664,4 +664,6 @@ posix_check_dev_file(xlator_t *this, inode_t *inode, char *fop, int *op_errno);
 int
 posix_spawn_ctx_janitor_thread(xlator_t *this);
 
+void
+posix_update_iatt_buf(struct iatt *buf, int fd, char *loc, dict_t *xdata);
 #endif /* _POSIX_H */
-- 
1.8.3.1