1 files changed, 104 insertions, 14 deletions

diff --git a/xlators/storage/posix/src/posix-helpers.c b/xlators/storage/posix/src/posix-helpers.c
index bb4a5309f45..67db3324083 100644
--- a/xlators/storage/posix/src/posix-helpers.c
+++ b/xlators/storage/posix/src/posix-helpers.c
@@ -1505,7 +1505,7 @@ posix_janitor_task(void *data)
     if (!priv)
         goto out;
 
-    time(&now);
+    now = gf_time();
     if ((now - priv->last_landfill_check) > priv->janitor_sleep_duration) {
         if (priv->disable_landfill_purge) {
             gf_msg_debug(this->name, 0,
@@ -1592,16 +1592,108 @@ 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)
+is_fresh_file(struct timespec *ts)
 {
-    struct timeval tv;
+    struct timespec now;
     int64_t elapsed;
 
-    gettimeofday(&tv, NULL);
+    timespec_now_realtime(&now);
+    elapsed = (int64_t)gf_tsdiff(ts, &now);
 
-    elapsed = (tv.tv_sec - sec) * 1000000L;
-    elapsed += tv.tv_usec - (ns / 1000L);
     if (elapsed < 0) {
         /* The file has been modified in the future !!!
          * Is it fresh ? previous implementation considered this as a
@@ -1610,11 +1702,7 @@ is_fresh_file(int64_t sec, int64_t ns)
     }
 
     /* If the file is newer than a second, we consider it fresh. */
-    if (elapsed < 1000000) {
-        return 1;
-    }
-
-    return 0;
+    return elapsed < 1000000;
 }
 
 int
@@ -1677,7 +1765,9 @@ posix_gfid_heal(xlator_t *this, const char *path, loc_t *loc, dict_t *xattr_req)
         if (ret != 16) {
             /* TODO: This is a very hacky way of doing this, and very prone to
              *       errors and unexpected behavior. This should be changed. */
-            if (is_fresh_file(stbuf.ia_ctime, stbuf.ia_ctime_nsec)) {
+            struct timespec ts = {.tv_sec = stbuf.ia_ctime,
+                                  .tv_nsec = stbuf.ia_ctime_nsec};
+            if (is_fresh_file(&ts)) {
                 gf_msg(this->name, GF_LOG_ERROR, ENOENT, P_MSG_FRESHFILE,
                        "Fresh file: %s", path);
                 return -ENOENT;
@@ -1691,7 +1781,7 @@ posix_gfid_heal(xlator_t *this, const char *path, loc_t *loc, dict_t *xattr_req)
         if (ret != 16) {
             /* TODO: This is a very hacky way of doing this, and very prone to
              *       errors and unexpected behavior. This should be changed. */
-            if (is_fresh_file(stat.st_ctim.tv_sec, stat.st_ctim.tv_nsec)) {
+            if (is_fresh_file(&stat.st_ctim)) {
                 gf_msg(this->name, GF_LOG_ERROR, ENOENT, P_MSG_FRESHFILE,
                        "Fresh file: %s", path);
                 return -ENOENT;
@@ -1950,7 +2040,7 @@ posix_fs_health_check(xlator_t *this, char *file_path)
         goto out;
     }
 
-    time_sec = time(NULL);
+    time_sec = gf_time();
     gf_time_fmt(timestamp, sizeof timestamp, time_sec, gf_timefmt_FT);
     timelen = strlen(timestamp);