Blob Blame History Raw
From 08ba386864e244a08cc5f257ea5530aeb70e782f Mon Sep 17 00:00:00 2001
From: Krutika Dhananjay <kdhananj@redhat.com>
Date: Tue, 28 Feb 2017 15:52:49 +0530
Subject: [PATCH 471/473] storage/posix: Use granular mutex locks for pgfid
 update syscalls

        Backport of: https://review.gluster.org/16869

Change-Id: Ibfe94aeb99037c98d939ad3e0261078baa465d29
BUG: 1415178
Signed-off-by: Krutika Dhananjay <kdhananj@redhat.com>
Reviewed-on: https://code.engineering.redhat.com/gerrit/107026
Reviewed-by: Raghavendra Gowdappa <rgowdapp@redhat.com>
---
 xlators/storage/posix/src/posix-helpers.c |  2 +
 xlators/storage/posix/src/posix.c         | 62 +++++++++++++++++++++++++------
 xlators/storage/posix/src/posix.h         |  1 +
 3 files changed, 54 insertions(+), 11 deletions(-)

diff --git a/xlators/storage/posix/src/posix-helpers.c b/xlators/storage/posix/src/posix-helpers.c
index 46ac867..0c50967 100644
--- a/xlators/storage/posix/src/posix-helpers.c
+++ b/xlators/storage/posix/src/posix-helpers.c
@@ -2288,11 +2288,13 @@ __posix_inode_ctx_get (inode_t *inode, xlator_t *this)
 
         pthread_mutex_init (&ctx_p->xattrop_lock, NULL);
         pthread_mutex_init (&ctx_p->write_atomic_lock, NULL);
+        pthread_mutex_init (&ctx_p->pgfid_lock, NULL);
 
         ret = __inode_ctx_set (inode, this, (uint64_t *)&ctx_p);
         if (ret < 0) {
                 pthread_mutex_destroy (&ctx_p->xattrop_lock);
                 pthread_mutex_destroy (&ctx_p->write_atomic_lock);
+                pthread_mutex_destroy (&ctx_p->pgfid_lock);
                 GF_FREE (ctx_p);
                 return NULL;
         }
diff --git a/xlators/storage/posix/src/posix.c b/xlators/storage/posix/src/posix.c
index 7f5ece4..95eaf0c 100644
--- a/xlators/storage/posix/src/posix.c
+++ b/xlators/storage/posix/src/posix.c
@@ -138,6 +138,7 @@ posix_forget (xlator_t *this, inode_t *inode)
 out:
         pthread_mutex_destroy (&ctx->xattrop_lock);
         pthread_mutex_destroy (&ctx->write_atomic_lock);
+        pthread_mutex_destroy (&ctx->pgfid_lock);
         GF_FREE (ctx);
         return ret;
 }
@@ -160,6 +161,7 @@ posix_lookup (call_frame_t *frame, xlator_t *this,
         char        *pgfid_xattr_key   = NULL;
         int32_t     nlink_samepgfid    = 0;
         struct  posix_private *priv    = NULL;
+        posix_inode_ctx_t *ctx         = NULL;
 
         VALIDATE_OR_GOTO (frame, out);
         VALIDATE_OR_GOTO (this, out);
@@ -219,7 +221,14 @@ posix_lookup (call_frame_t *frame, xlator_t *this,
                                               PGFID_XATTR_KEY_PREFIX,
                                               loc->pargfid);
 
-                        LOCK (&loc->inode->lock);
+                        op_ret = posix_inode_ctx_get_all (loc->inode, this,
+                                                          &ctx);
+                        if (op_ret < 0) {
+                                op_errno = ENOMEM;
+                                goto out;
+                        }
+
+                        pthread_mutex_lock (&ctx->pgfid_lock);
                         {
                                 SET_PGFID_XATTR_IF_ABSENT (real_path,
                                                            pgfid_xattr_key,
@@ -228,7 +237,7 @@ posix_lookup (call_frame_t *frame, xlator_t *this,
                                                            this, unlock);
                         }
 unlock:
-                        UNLOCK (&loc->inode->lock);
+                        pthread_mutex_unlock (&ctx->pgfid_lock);
                 }
         }
 
@@ -1924,6 +1933,7 @@ posix_unlink (call_frame_t *frame, xlator_t *this,
         char                   uuid_str[GF_UUID_BUF_SIZE] = {0};
         char                   gfid_str[GF_UUID_BUF_SIZE] = {0};
         gf_boolean_t           get_link_count     = _gf_false;
+        posix_inode_ctx_t     *ctx                = NULL;
 
         DECLARE_OLD_FS_ID_VAR;
 
@@ -2027,14 +2037,19 @@ posix_unlink (call_frame_t *frame, xlator_t *this,
         if (priv->update_pgfid_nlinks && (stbuf.ia_nlink > 1)) {
                 MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX,
                                       loc->pargfid);
-                LOCK (&loc->inode->lock);
+                op_ret = posix_inode_ctx_get_all (loc->inode, this, &ctx);
+                if (op_ret < 0) {
+                        op_errno = ENOMEM;
+                        goto out;
+                }
+                pthread_mutex_lock (&ctx->pgfid_lock);
                 {
                         UNLINK_MODIFY_PGFID_XATTR (real_path, pgfid_xattr_key,
                                                    nlink_samepgfid, 0, op_ret,
                                                    this, unlock);
                 }
         unlock:
-                UNLOCK (&loc->inode->lock);
+                pthread_mutex_unlock (&ctx->pgfid_lock);
 
                 if (op_ret < 0) {
                         gf_msg (this->name, GF_LOG_WARNING, 0,
@@ -2389,6 +2404,8 @@ posix_rename (call_frame_t *frame, xlator_t *this,
         dict_t               *unwind_dict     = NULL;
         gf_boolean_t          locked          = _gf_false;
         gf_boolean_t          get_link_count  = _gf_false;
+        posix_inode_ctx_t    *ctx_old         = NULL;
+        posix_inode_ctx_t    *ctx_new         = NULL;
 
         DECLARE_OLD_FS_ID_VAR;
 
@@ -2471,10 +2488,26 @@ posix_rename (call_frame_t *frame, xlator_t *this,
                 goto out;
         }
 
+        op_ret = posix_inode_ctx_get_all (oldloc->inode, this, &ctx_old);
+        if (op_ret < 0) {
+                op_ret = -1;
+                op_errno = ENOMEM;
+                goto out;
+        }
+
+        if (newloc->inode) {
+                op_ret = posix_inode_ctx_get_all (newloc->inode, this, &ctx_new);
+                if (op_ret < 0) {
+                        op_ret = -1;
+                        op_errno = ENOMEM;
+                        goto out;
+                }
+        }
+
         if (IA_ISDIR (oldloc->inode->ia_type))
                 posix_handle_unset (this, oldloc->inode->gfid, NULL);
 
-        LOCK (&oldloc->inode->lock);
+        pthread_mutex_lock (&ctx_old->pgfid_lock);
         {
                 if (!IA_ISDIR (oldloc->inode->ia_type)
                     && priv->update_pgfid_nlinks) {
@@ -2490,7 +2523,7 @@ posix_rename (call_frame_t *frame, xlator_t *this,
 
                 if ((xdata) && (dict_get (xdata, GET_LINK_COUNT))
                     && (real_newpath) && (was_present)) {
-                        LOCK (&newloc->inode->lock);
+                        pthread_mutex_lock (&ctx_new->pgfid_lock);
                         locked = _gf_true;
                         get_link_count = _gf_true;
                         op_ret = posix_pstat (this, newloc->gfid, real_newpath,
@@ -2532,7 +2565,7 @@ posix_rename (call_frame_t *frame, xlator_t *this,
                 }
 
                 if (locked) {
-                        UNLOCK (&newloc->inode->lock);
+                        pthread_mutex_unlock (&ctx_new->pgfid_lock);
                         locked = _gf_false;
                 }
 
@@ -2557,10 +2590,10 @@ posix_rename (call_frame_t *frame, xlator_t *this,
         }
 unlock:
         if (locked) {
-                UNLOCK (&newloc->inode->lock);
+                pthread_mutex_unlock (&ctx_new->pgfid_lock);
                 locked = _gf_false;
         }
-        UNLOCK (&oldloc->inode->lock);
+        pthread_mutex_unlock (&ctx_old->pgfid_lock);
 
         if (op_ret < 0) {
                 gf_msg (this->name, GF_LOG_WARNING, 0, P_MSG_XATTR_FAILED,
@@ -2641,6 +2674,7 @@ posix_link (call_frame_t *frame, xlator_t *this,
         int32_t               nlink_samepgfid = 0;
         char                 *pgfid_xattr_key = NULL;
         gf_boolean_t          entry_created   = _gf_false;
+        posix_inode_ctx_t    *ctx             = NULL;
 
         DECLARE_OLD_FS_ID_VAR;
 
@@ -2707,14 +2741,20 @@ posix_link (call_frame_t *frame, xlator_t *this,
                 MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX,
                                       newloc->pargfid);
 
-                LOCK (&newloc->inode->lock);
+                op_ret = posix_inode_ctx_get_all (newloc->inode, this, &ctx);
+                if (op_ret < 0) {
+                        op_errno = ENOMEM;
+                        goto out;
+                }
+
+                pthread_mutex_lock (&ctx->pgfid_lock);
                 {
                         LINK_MODIFY_PGFID_XATTR (real_newpath, pgfid_xattr_key,
                                                  nlink_samepgfid, 0, op_ret,
                                                  this, unlock);
                 }
         unlock:
-                UNLOCK (&newloc->inode->lock);
+                pthread_mutex_unlock (&ctx->pgfid_lock);
 
                 if (op_ret < 0) {
                         gf_msg (this->name, GF_LOG_WARNING, 0,
diff --git a/xlators/storage/posix/src/posix.h b/xlators/storage/posix/src/posix.h
index aac8d39..febd432 100644
--- a/xlators/storage/posix/src/posix.h
+++ b/xlators/storage/posix/src/posix.h
@@ -194,6 +194,7 @@ typedef struct {
         uint64_t unlink_flag;
         pthread_mutex_t xattrop_lock;
         pthread_mutex_t write_atomic_lock;
+        pthread_mutex_t pgfid_lock;
 } posix_inode_ctx_t;
 
 #define POSIX_BASE_PATH(this) (((struct posix_private *)this->private)->base_path)
-- 
1.8.3.1