posix: Implement a janitor thread to close fd

Problem: In the commit fb20713b380e1df8d7f9e9df96563be2f9144fd6 we use
         syntask to close fd but we have found the patch is reducing the
         performance

Solution: Use janitor thread to close fd's and save the pfd ctx into
          ctx janitor list and also save the posix_xlator into pfd object to
          avoid the race condition during cleanup in brick_mux environment

Change-Id: Ifb3d18a854b267333a3a9e39845bfefb83fbc092
Fixes: #1396
Signed-off-by: Mohit Agrawal <moagrawa@redhat.com>

7 files changed, 160 insertions, 26 deletions

diff --git a/glusterfsd/src/glusterfsd.c b/glusterfsd/src/glusterfsd.c
index c4fa2e954c1..dae41f33fef 100644
--- a/glusterfsd/src/glusterfsd.c
+++ b/glusterfsd/src/glusterfsd.c
@@ -1687,6 +1687,10 @@ glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx)
 
     INIT_LIST_HEAD(&cmd_args->xlator_options);
     INIT_LIST_HEAD(&cmd_args->volfile_servers);
+    ctx->pxl_count = 0;
+    pthread_mutex_init(&ctx->fd_lock, NULL);
+    pthread_cond_init(&ctx->fd_cond, NULL);
+    INIT_LIST_HEAD(&ctx->janitor_fds);
 
     lim.rlim_cur = RLIM_INFINITY;
     lim.rlim_max = RLIM_INFINITY;
diff --git a/libglusterfs/src/glusterfs/glusterfs.h b/libglusterfs/src/glusterfs/glusterfs.h
index e4dfda8d01a..fc69ad0b749 100644
--- a/libglusterfs/src/glusterfs/glusterfs.h
+++ b/libglusterfs/src/glusterfs/glusterfs.h
@@ -730,6 +730,13 @@ struct _glusterfs_ctx {
     } stats;
 
     struct list_head volfile_list;
+    /* Add members to manage janitor threads for cleanup fd */
+    struct list_head janitor_fds;
+    pthread_cond_t fd_cond;
+    pthread_mutex_t fd_lock;
+    pthread_t janitor;
+    /* The variable is use to save total posix xlator count */
+    uint32_t pxl_count;
 
     char volume_id[GF_UUID_BUF_SIZE]; /* Used only in protocol/client */
 };
diff --git a/rpc/rpc-lib/src/rpcsvc.c b/rpc/rpc-lib/src/rpcsvc.c
index 4297af4609c..9e8c9af8a12 100644
--- a/rpc/rpc-lib/src/rpcsvc.c
+++ b/rpc/rpc-lib/src/rpcsvc.c
@@ -343,12 +343,6 @@ rpcsvc_program_actor(rpcsvc_request_t *req)
 
     req->ownthread = program->ownthread;
     req->synctask = program->synctask;
-    if (((req->procnum == GFS3_OP_RELEASE) ||
-         (req->procnum == GFS3_OP_RELEASEDIR)) &&
-        (program->prognum == GLUSTER_FOP_PROGRAM)) {
-        req->ownthread = _gf_false;
-        req->synctask = _gf_true;
-    }
 
     err = SUCCESS;
     gf_log(GF_RPCSVC, GF_LOG_TRACE, "Actor found: %s - %s for %s",
diff --git a/xlators/storage/posix/src/posix-common.c b/xlators/storage/posix/src/posix-common.c
index 609ddea2560..777ceaa3dc9 100644
--- a/xlators/storage/posix/src/posix-common.c
+++ b/xlators/storage/posix/src/posix-common.c
@@ -140,6 +140,7 @@ posix_notify(xlator_t *this, int32_t event, void *data, ...)
     struct timespec sleep_till = {
         0,
     };
+    glusterfs_ctx_t *ctx = this->ctx;
 
     switch (event) {
         case GF_EVENT_PARENT_UP: {
@@ -150,8 +151,6 @@ posix_notify(xlator_t *this, int32_t event, void *data, ...)
         case GF_EVENT_PARENT_DOWN: {
             if (!victim->cleanup_starting)
                 break;
-            gf_log(this->name, GF_LOG_INFO, "Sending CHILD_DOWN for brick %s",
-                   victim->name);
 
             if (priv->janitor) {
                 pthread_mutex_lock(&priv->janitor_mutex);
@@ -177,6 +176,16 @@ posix_notify(xlator_t *this, int32_t event, void *data, ...)
                 GF_FREE(priv->janitor);
             }
             priv->janitor = NULL;
+            pthread_mutex_lock(&ctx->fd_lock);
+            {
+                while (priv->rel_fdcount > 0) {
+                    pthread_cond_wait(&priv->fd_cond, &ctx->fd_lock);
+                }
+            }
+            pthread_mutex_unlock(&ctx->fd_lock);
+
+            gf_log(this->name, GF_LOG_INFO, "Sending CHILD_DOWN for brick %s",
+                   victim->name);
             default_notify(this->parents->xlator, GF_EVENT_CHILD_DOWN, data);
         } break;
         default:
@@ -1084,7 +1093,13 @@ posix_init(xlator_t *this)
     pthread_cond_init(&_private->fsync_cond, NULL);
     pthread_mutex_init(&_private->janitor_mutex, NULL);
     pthread_cond_init(&_private->janitor_cond, NULL);
+    pthread_cond_init(&_private->fd_cond, NULL);
     INIT_LIST_HEAD(&_private->fsyncs);
+    _private->rel_fdcount = 0;
+    ret = posix_spawn_ctx_janitor_thread(this);
+    if (ret)
+        goto out;
+
     ret = gf_thread_create(&_private->fsyncer, NULL, posix_fsyncer, this,
                            "posixfsy");
     if (ret) {
@@ -1197,6 +1212,8 @@ posix_fini(xlator_t *this)
 {
     struct posix_private *priv = this->private;
     gf_boolean_t health_check = _gf_false;
+    glusterfs_ctx_t *ctx = this->ctx;
+    uint32_t count;
     int ret = 0;
     int i = 0;
 
@@ -1243,6 +1260,19 @@ posix_fini(xlator_t *this)
         priv->janitor = NULL;
     }
 
+    pthread_mutex_lock(&ctx->fd_lock);
+    {
+        count = --ctx->pxl_count;
+        if (count == 0) {
+            pthread_cond_signal(&ctx->fd_cond);
+        }
+    }
+    pthread_mutex_unlock(&ctx->fd_lock);
+
+    if (count == 0) {
+        pthread_join(ctx->janitor, NULL);
+    }
+
     if (priv->fsyncer) {
         (void)gf_thread_cleanup_xint(priv->fsyncer);
         priv->fsyncer = 0;
diff --git a/xlators/storage/posix/src/posix-helpers.c b/xlators/storage/posix/src/posix-helpers.c
index 850d6177de6..5d15ccb66fd 100644
--- a/xlators/storage/posix/src/posix-helpers.c
+++ b/xlators/storage/posix/src/posix-helpers.c
@@ -1592,6 +1592,99 @@ unlock:
     return;
 }
 
+static struct posix_fd *
+janitor_get_next_fd(glusterfs_ctx_t *ctx)
+{
+    struct posix_fd *pfd = NULL;
+
+    while (list_empty(&ctx->janitor_fds)) {
+        if (ctx->pxl_count == 0) {
+            return NULL;
+        }
+
+        pthread_cond_wait(&ctx->fd_cond, &ctx->fd_lock);
+    }
+
+    pfd = list_first_entry(&ctx->janitor_fds, struct posix_fd, list);
+    list_del_init(&pfd->list);
+
+    return pfd;
+}
+
+static void
+posix_close_pfd(xlator_t *xl, struct posix_fd *pfd)
+{
+    THIS = xl;
+
+    if (pfd->dir == NULL) {
+        gf_msg_trace(xl->name, 0, "janitor: closing file fd=%d", pfd->fd);
+        sys_close(pfd->fd);
+    } else {
+        gf_msg_debug(xl->name, 0, "janitor: closing dir fd=%p", pfd->dir);
+        sys_closedir(pfd->dir);
+    }
+
+    GF_FREE(pfd);
+}
+
+static void *
+posix_ctx_janitor_thread_proc(void *data)
+{
+    xlator_t *xl;
+    struct posix_fd *pfd;
+    glusterfs_ctx_t *ctx = NULL;
+    struct posix_private *priv_fd;
+
+    ctx = data;
+
+    pthread_mutex_lock(&ctx->fd_lock);
+
+    while ((pfd = janitor_get_next_fd(ctx)) != NULL) {
+        pthread_mutex_unlock(&ctx->fd_lock);
+
+        xl = pfd->xl;
+        posix_close_pfd(xl, pfd);
+
+        pthread_mutex_lock(&ctx->fd_lock);
+
+        priv_fd = xl->private;
+        priv_fd->rel_fdcount--;
+        if (!priv_fd->rel_fdcount)
+            pthread_cond_signal(&priv_fd->fd_cond);
+    }
+
+    pthread_mutex_unlock(&ctx->fd_lock);
+
+    return NULL;
+}
+
+int
+posix_spawn_ctx_janitor_thread(xlator_t *this)
+{
+    int ret = 0;
+    glusterfs_ctx_t *ctx = NULL;
+
+    ctx = this->ctx;
+
+    pthread_mutex_lock(&ctx->fd_lock);
+    {
+        if (ctx->pxl_count++ == 0) {
+            ret = gf_thread_create(&ctx->janitor, NULL,
+                                   posix_ctx_janitor_thread_proc, ctx,
+                                   "posixctxjan");
+
+            if (ret) {
+                gf_msg(this->name, GF_LOG_ERROR, errno, P_MSG_THREAD_FAILED,
+                       "spawning janitor thread failed");
+                ctx->pxl_count--;
+            }
+        }
+    }
+    pthread_mutex_unlock(&ctx->fd_lock);
+
+    return ret;
+}
+
 static int
 is_fresh_file(int64_t sec, int64_t ns)
 {
diff --git a/xlators/storage/posix/src/posix-inode-fd-ops.c b/xlators/storage/posix/src/posix-inode-fd-ops.c
index 762041b5831..6d54d37e5aa 100644
--- a/xlators/storage/posix/src/posix-inode-fd-ops.c
+++ b/xlators/storage/posix/src/posix-inode-fd-ops.c
@@ -1361,6 +1361,22 @@ out:
     return 0;
 }
 
+static void
+posix_add_fd_to_cleanup(xlator_t *this, struct posix_fd *pfd)
+{
+    glusterfs_ctx_t *ctx = this->ctx;
+    struct posix_private *priv = this->private;
+
+    pfd->xl = this;
+    pthread_mutex_lock(&ctx->fd_lock);
+    {
+        list_add_tail(&pfd->list, &ctx->janitor_fds);
+        priv->rel_fdcount++;
+        pthread_cond_signal(&ctx->fd_cond);
+    }
+    pthread_mutex_unlock(&ctx->fd_lock);
+}
+
 int32_t
 posix_releasedir(xlator_t *this, fd_t *fd)
 {
@@ -1383,11 +1399,7 @@ posix_releasedir(xlator_t *this, fd_t *fd)
                "pfd->dir is NULL for fd=%p", fd);
         goto out;
     }
-
-    gf_msg_debug(this->name, 0, "janitor: closing dir fd=%p", pfd->dir);
-
-    sys_closedir(pfd->dir);
-    GF_FREE(pfd);
+    posix_add_fd_to_cleanup(this, pfd);
 
 out:
     return 0;
@@ -2510,7 +2522,6 @@ out:
 int32_t
 posix_release(xlator_t *this, fd_t *fd)
 {
-    struct posix_private *priv = NULL;
     struct posix_fd *pfd = NULL;
     int ret = -1;
     uint64_t tmp_pfd = 0;
@@ -2518,8 +2529,6 @@ posix_release(xlator_t *this, fd_t *fd)
     VALIDATE_OR_GOTO(this, out);
     VALIDATE_OR_GOTO(fd, out);
 
-    priv = this->private;
-
     ret = fd_ctx_del(fd, this, &tmp_pfd);
     if (ret < 0) {
         gf_msg(this->name, GF_LOG_WARNING, 0, P_MSG_PFD_NULL,
@@ -2533,13 +2542,7 @@ posix_release(xlator_t *this, fd_t *fd)
                "pfd->dir is %p (not NULL) for file fd=%p", pfd->dir, fd);
     }
 
-    gf_msg_debug(this->name, 0, "janitor: closing dir fd=%p", pfd->dir);
-
-    sys_close(pfd->fd);
-    GF_FREE(pfd);
-
-    if (!priv)
-        goto out;
+    posix_add_fd_to_cleanup(this, pfd);
 
 out:
     return 0;
diff --git a/xlators/storage/posix/src/posix.h b/xlators/storage/posix/src/posix.h
index 35be197c869..ffedda2e907 100644
--- a/xlators/storage/posix/src/posix.h
+++ b/xlators/storage/posix/src/posix.h
@@ -125,7 +125,7 @@ struct posix_fd {
     off_t dir_eof;         /* offset at dir EOF */
     struct list_head list; /* to add to the janitor list */
     int odirect;
-
+    xlator_t *xl;
     char _pad[4]; /* manual padding */
 };
 
@@ -170,6 +170,7 @@ struct posix_private {
     pthread_cond_t fsync_cond;
     pthread_mutex_t janitor_mutex;
     pthread_cond_t janitor_cond;
+    pthread_cond_t fd_cond;
     int fsync_queue_count;
     int32_t janitor_sleep_duration;
 
@@ -254,8 +255,7 @@ struct posix_private {
     gf_boolean_t aio_configured;
     gf_boolean_t aio_init_done;
     gf_boolean_t aio_capable;
-
-    char _pad[4]; /* manual padding */
+    uint32_t rel_fdcount;
 };
 
 typedef struct {
@@ -662,6 +662,9 @@ posix_cs_maintenance(xlator_t *this, fd_t *fd, loc_t *loc, int *pfd,
 int
 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);