11 files changed, 134 insertions, 136 deletions

diff --git a/xlators/performance/io-cache/src/io-cache.c b/xlators/performance/io-cache/src/io-cache.c
index 2fefaef8de8..9375d29c17f 100644
--- a/xlators/performance/io-cache/src/io-cache.c
+++ b/xlators/performance/io-cache/src/io-cache.c
@@ -133,23 +133,17 @@ ioc_update_pages(call_frame_t *frame, ioc_inode_t *ioc_inode,
     return 0;
 }
 
-int32_t
+static gf_boolean_t
 ioc_inode_need_revalidate(ioc_inode_t *ioc_inode)
 {
-    int8_t need_revalidate = 0;
-    struct timeval tv = {
-        0,
-    };
     ioc_table_t *table = NULL;
 
+    GF_ASSERT(ioc_inode);
     table = ioc_inode->table;
+    GF_ASSERT(table);
 
-    gettimeofday(&tv, NULL);
-
-    if (time_elapsed(&tv, &ioc_inode->cache.tv) >= table->cache_timeout)
-        need_revalidate = 1;
-
-    return need_revalidate;
+    return (gf_time() - ioc_inode->cache.last_revalidate >=
+            table->cache_timeout);
 }
 
 /*
@@ -411,9 +405,6 @@ ioc_cache_validate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
     ioc_inode_t *ioc_inode = NULL;
     size_t destroy_size = 0;
     struct iatt *local_stbuf = NULL;
-    struct timeval tv = {
-        0,
-    };
 
     local = frame->local;
     ioc_inode = local->inode;
@@ -451,10 +442,9 @@ ioc_cache_validate_cbk(call_frame_t *frame, void *cookie, xlator_t *this,
     if (op_ret < 0)
         local_stbuf = NULL;
 
-    gettimeofday(&tv, NULL);
     ioc_inode_lock(ioc_inode);
     {
-        memcpy(&ioc_inode->cache.tv, &tv, sizeof(struct timeval));
+        ioc_inode->cache.last_revalidate = gf_time();
     }
     ioc_inode_unlock(ioc_inode);
 
@@ -1405,9 +1395,6 @@ ioc_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
 {
     ioc_inode_t *ioc_inode = NULL;
     uint64_t tmp_inode = 0;
-    struct timeval tv = {
-        0,
-    };
 
     inode_ctx_get(fd->inode, this, &tmp_inode);
     ioc_inode = (ioc_inode_t *)(long)tmp_inode;
@@ -1418,10 +1405,9 @@ ioc_lk(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t cmd,
         return 0;
     }
 
-    gettimeofday(&tv, NULL);
     ioc_inode_lock(ioc_inode);
     {
-        memcpy(&ioc_inode->cache.tv, &tv, sizeof(struct timeval));
+        ioc_inode->cache.last_revalidate = gf_time();
     }
     ioc_inode_unlock(ioc_inode);
 
@@ -1955,9 +1941,9 @@ __ioc_cache_dump(ioc_inode_t *ioc_inode, char *prefix)
 
     table = ioc_inode->table;
 
-    if (ioc_inode->cache.tv.tv_sec) {
-        gf_time_fmt_tv(timestr, sizeof timestr, &ioc_inode->cache.tv,
-                       gf_timefmt_FT);
+    if (ioc_inode->cache.last_revalidate) {
+        gf_time_fmt(timestr, sizeof timestr, ioc_inode->cache.last_revalidate,
+                    gf_timefmt_FT);
 
         gf_proc_dump_write("last-cache-validation-time", "%s", timestr);
     }
diff --git a/xlators/performance/io-cache/src/io-cache.h b/xlators/performance/io-cache/src/io-cache.h
index 4303c2fae13..14923c75edc 100644
--- a/xlators/performance/io-cache/src/io-cache.h
+++ b/xlators/performance/io-cache/src/io-cache.h
@@ -117,15 +117,13 @@ struct ioc_page {
 struct ioc_cache {
     rbthash_table_t *page_table;
     struct list_head page_lru;
-    time_t mtime;      /*
-                        * seconds component of file mtime
-                        */
-    time_t mtime_nsec; /*
-                        * nanosecond component of file mtime
-                        */
-    struct timeval tv; /*
-                        * time-stamp at last re-validate
-                        */
+    time_t mtime;           /*
+                             * seconds component of file mtime
+                             */
+    time_t mtime_nsec;      /*
+                             * nanosecond component of file mtime
+                             */
+    time_t last_revalidate; /* timestamp at last re-validate */
 };
 
 struct ioc_inode {
@@ -270,17 +268,6 @@ ioc_frame_fill(ioc_page_t *page, call_frame_t *frame, off_t offset, size_t size,
         pthread_mutex_unlock(&page->page_lock);                                \
     } while (0)
 
-static inline uint64_t
-time_elapsed(struct timeval *now, struct timeval *then)
-{
-    uint64_t sec = now->tv_sec - then->tv_sec;
-
-    if (sec)
-        return sec;
-
-    return 0;
-}
-
 ioc_inode_t *
 ioc_inode_search(ioc_table_t *table, inode_t *inode);
 
diff --git a/xlators/performance/io-cache/src/page.c b/xlators/performance/io-cache/src/page.c
index a8edbde23f2..84b1ae6cb20 100644
--- a/xlators/performance/io-cache/src/page.c
+++ b/xlators/performance/io-cache/src/page.c
@@ -413,9 +413,6 @@ ioc_fault_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
     ioc_waitq_t *waitq = NULL;
     size_t iobref_page_size = 0;
     char zero_filled = 0;
-    struct timeval tv = {
-        0,
-    };
 
     GF_ASSERT(frame);
 
@@ -431,7 +428,6 @@ ioc_fault_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
 
     zero_filled = ((op_ret >= 0) && (stbuf->ia_mtime == 0));
 
-    gettimeofday(&tv, NULL);
     ioc_inode_lock(ioc_inode);
     {
         if (op_ret == -1 ||
@@ -448,7 +444,7 @@ ioc_fault_cbk(call_frame_t *frame, void *cookie, xlator_t *this, int32_t op_ret,
             ioc_inode->cache.mtime_nsec = stbuf->ia_mtime_nsec;
         }
 
-        memcpy(&ioc_inode->cache.tv, &tv, sizeof(struct timeval));
+        ioc_inode->cache.last_revalidate = gf_time();
 
         if (op_ret < 0) {
             /* error, readv returned -1 */
diff --git a/xlators/performance/io-threads/src/io-threads.c b/xlators/performance/io-threads/src/io-threads.c
index 6fa4d88389c..3d24cc97f4b 100644
--- a/xlators/performance/io-threads/src/io-threads.c
+++ b/xlators/performance/io-threads/src/io-threads.c
@@ -1016,16 +1016,13 @@ static uint32_t THRESH_LIMIT = 1209600; /* SECONDS * (EVENTS-1) */
 static void
 iot_apply_event(xlator_t *this, threshold_t *thresh)
 {
-    struct timespec now;
-    time_t delta;
+    time_t delta, now = gf_time();
 
     /* Refresh for manual testing/debugging.  It's cheap. */
     THRESH_LIMIT = THRESH_SECONDS * (THRESH_EVENTS - 1);
 
-    timespec_now(&now);
-
     if (thresh->value && thresh->update_time) {
-        delta = now.tv_sec - thresh->update_time;
+        delta = now - thresh->update_time;
         /* Be careful about underflow. */
         if (thresh->value <= delta) {
             thresh->value = 0;
@@ -1046,7 +1043,7 @@ iot_apply_event(xlator_t *this, threshold_t *thresh)
         kill(getpid(), SIGTRAP);
     }
 
-    thresh->update_time = now.tv_sec;
+    thresh->update_time = now;
 }
 
 static void *
@@ -1311,7 +1308,7 @@ notify(xlator_t *this, int32_t event, void *data, ...)
             /* Wait for draining stub from queue before notify PARENT_DOWN */
             stub_cnt = GF_ATOMIC_GET(conf->stub_cnt);
             if (stub_cnt) {
-                clock_gettime(CLOCK_REALTIME, &sleep_till);
+                timespec_now_realtime(&sleep_till);
                 sleep_till.tv_sec += 1;
                 pthread_mutex_lock(&conf->mutex);
                 {
diff --git a/xlators/performance/md-cache/src/md-cache.c b/xlators/performance/md-cache/src/md-cache.c
index 1313c2b55c3..a405be51f02 100644
--- a/xlators/performance/md-cache/src/md-cache.c
+++ b/xlators/performance/md-cache/src/md-cache.c
@@ -8,7 +8,6 @@
   cases as published by the Free Software Foundation.
 */
 
-#include <glusterfs/timespec.h>
 #include <glusterfs/glusterfs.h>
 #include <glusterfs/defaults.h>
 #include <glusterfs/logging.h>
@@ -33,8 +32,7 @@
 
 struct mdc_statfs_cache {
     pthread_mutex_t lock;
-    gf_boolean_t initialized;
-    struct timespec last_refreshed;
+    time_t last_refreshed; /* (time_t)-1 if not yet initialized. */
     struct statvfs buf;
 };
 
@@ -61,7 +59,7 @@ struct mdc_statistics {
 };
 
 struct mdc_conf {
-    int timeout;
+    uint32_t timeout;
     gf_boolean_t cache_posix_acl;
     gf_boolean_t cache_glusterfs_acl;
     gf_boolean_t cache_selinux;
@@ -376,10 +374,9 @@ unlock:
 static gf_boolean_t
 __is_cache_valid(xlator_t *this, time_t mdc_time)
 {
-    time_t now = 0;
     gf_boolean_t ret = _gf_true;
     struct mdc_conf *conf = NULL;
-    int timeout = 0;
+    uint32_t timeout = 0;
     time_t last_child_down = 0;
 
     conf = this->private;
@@ -393,15 +390,13 @@ __is_cache_valid(xlator_t *this, time_t mdc_time)
     last_child_down = conf->last_child_down;
     timeout = conf->timeout;
 
-    time(&now);
-
     if ((mdc_time == 0) ||
         ((last_child_down != 0) && (mdc_time < last_child_down))) {
         ret = _gf_false;
         goto out;
     }
 
-    if (now >= (mdc_time + timeout)) {
+    if (gf_time() >= (mdc_time + timeout)) {
         ret = _gf_false;
     }
 
@@ -581,10 +576,9 @@ mdc_inode_iatt_set_validate(xlator_t *this, inode_t *inode, struct iatt *prebuf,
             mdc_from_iatt(mdc, iatt);
             mdc->valid = _gf_true;
             if (update_time) {
-                time(&mdc->ia_time);
-
+                mdc->ia_time = gf_time();
                 if (mdc->xa_time && update_xa_time)
-                    time(&mdc->xa_time);
+                    mdc->xa_time = mdc->ia_time;
             }
 
             gf_msg_callingfn(
@@ -785,7 +779,7 @@ mdc_inode_xatt_set(xlator_t *this, inode_t *inode, dict_t *dict)
         if (newdict)
             mdc->xattr = newdict;
 
-        time(&mdc->xa_time);
+        mdc->xa_time = gf_time();
         gf_msg_trace("md-cache", 0, "xatt cache set for (%s) time:%lld",
                      uuid_utoa(inode->gfid), (long long)mdc->xa_time);
     }
@@ -1063,8 +1057,7 @@ mdc_cache_statfs(xlator_t *this, struct statvfs *buf)
     pthread_mutex_lock(&conf->statfs_cache.lock);
     {
         memcpy(&conf->statfs_cache.buf, buf, sizeof(struct statvfs));
-        clock_gettime(CLOCK_MONOTONIC, &conf->statfs_cache.last_refreshed);
-        conf->statfs_cache.initialized = _gf_true;
+        conf->statfs_cache.last_refreshed = gf_time();
     }
     pthread_mutex_unlock(&conf->statfs_cache.lock);
 }
@@ -1073,8 +1066,7 @@ int
 mdc_load_statfs_info_from_cache(xlator_t *this, struct statvfs **buf)
 {
     struct mdc_conf *conf = this->private;
-    struct timespec now;
-    double cache_age = 0.0;
+    uint32_t cache_age = 0;
     int ret = 0;
 
     if (!buf || !conf) {
@@ -1083,23 +1075,23 @@ mdc_load_statfs_info_from_cache(xlator_t *this, struct statvfs **buf)
     }
 
     *buf = NULL;
-    timespec_now(&now);
 
     pthread_mutex_lock(&conf->statfs_cache.lock);
     {
-        /* Skip if the cache is not initialized */
-        if (!conf->statfs_cache.initialized) {
+        /* Skip if the cache is not initialized. */
+        if (conf->statfs_cache.last_refreshed == (time_t)-1) {
             ret = -1;
             goto unlock;
         }
 
-        cache_age = (now.tv_sec - conf->statfs_cache.last_refreshed.tv_sec);
+        cache_age = (gf_time() - conf->statfs_cache.last_refreshed);
 
-        gf_log(this->name, GF_LOG_DEBUG, "STATFS cache age = %lf", cache_age);
+        gf_log(this->name, GF_LOG_DEBUG, "STATFS cache age = %u secs",
+               cache_age);
         if (cache_age > conf->timeout) {
-            /* Expire the cache */
+            /* Expire the cache. */
             gf_log(this->name, GF_LOG_DEBUG,
-                   "Cache age %lf exceeded timeout %d", cache_age,
+                   "Cache age %u secs exceeded timeout %u secs", cache_age,
                    conf->timeout);
             ret = -1;
             goto unlock;
@@ -3616,7 +3608,7 @@ int
 mdc_reconfigure(xlator_t *this, dict_t *options)
 {
     struct mdc_conf *conf = NULL;
-    int timeout = 0;
+    int timeout = 0, ret = 0;
     char *tmp_str = NULL;
 
     conf = this->private;
@@ -3656,7 +3648,10 @@ mdc_reconfigure(xlator_t *this, dict_t *options)
     GF_OPTION_RECONF("md-cache-statfs", conf->cache_statfs, options, bool, out);
 
     GF_OPTION_RECONF("xattr-cache-list", tmp_str, options, str, out);
-    mdc_xattr_list_populate(conf, tmp_str);
+
+    ret = mdc_xattr_list_populate(conf, tmp_str);
+    if (ret < 0)
+        goto out;
 
     /* If timeout is greater than 60s (default before the patch that added
      * cache invalidation support was added) then, cache invalidation
@@ -3669,25 +3664,22 @@ mdc_reconfigure(xlator_t *this, dict_t *options)
     }
     conf->timeout = timeout;
 
-    (void)mdc_register_xattr_inval(this);
+    ret = mdc_register_xattr_inval(this);
 out:
-    return 0;
+    return ret;
 }
 
 int32_t
 mdc_mem_acct_init(xlator_t *this)
 {
-    int ret = -1;
-
-    ret = xlator_mem_acct_init(this, gf_mdc_mt_end + 1);
-    return ret;
+    return xlator_mem_acct_init(this, gf_mdc_mt_end + 1);
 }
 
 int
 mdc_init(xlator_t *this)
 {
     struct mdc_conf *conf = NULL;
-    int timeout = 0;
+    uint32_t timeout = 0;
     char *tmp_str = NULL;
 
     conf = GF_CALLOC(sizeof(*conf), 1, gf_mdc_mt_mdc_conf_t);
@@ -3699,7 +3691,7 @@ mdc_init(xlator_t *this)
 
     LOCK_INIT(&conf->lock);
 
-    GF_OPTION_INIT("md-cache-timeout", timeout, int32, out);
+    GF_OPTION_INIT("md-cache-timeout", timeout, uint32, out);
 
     GF_OPTION_INIT("cache-selinux", conf->cache_selinux, bool, out);
 
@@ -3733,7 +3725,9 @@ mdc_init(xlator_t *this)
     GF_OPTION_INIT("xattr-cache-list", tmp_str, str, out);
     mdc_xattr_list_populate(conf, tmp_str);
 
-    time(&conf->last_child_down);
+    conf->last_child_down = gf_time();
+    conf->statfs_cache.last_refreshed = (time_t)-1;
+
     /* initialize gf_atomic_t counters */
     GF_ATOMIC_INIT(conf->mdc_counter.stat_hit, 0);
     GF_ATOMIC_INIT(conf->mdc_counter.stat_miss, 0);
@@ -3764,7 +3758,7 @@ out:
 }
 
 void
-mdc_update_child_down_time(xlator_t *this, time_t *now)
+mdc_update_child_down_time(xlator_t *this, time_t now)
 {
     struct mdc_conf *conf = NULL;
 
@@ -3772,7 +3766,7 @@ mdc_update_child_down_time(xlator_t *this, time_t *now)
 
     LOCK(&conf->lock);
     {
-        conf->last_child_down = *now;
+        conf->last_child_down = now;
     }
     UNLOCK(&conf->lock);
 }
@@ -3782,14 +3776,12 @@ mdc_notify(xlator_t *this, int event, void *data, ...)
 {
     int ret = 0;
     struct mdc_conf *conf = NULL;
-    time_t now = 0;
 
     conf = this->private;
     switch (event) {
         case GF_EVENT_CHILD_DOWN:
         case GF_EVENT_SOME_DESCENDENT_DOWN:
-            time(&now);
-            mdc_update_child_down_time(this, &now);
+            mdc_update_child_down_time(this, gf_time());
             break;
         case GF_EVENT_UPCALL:
             if (conf->mdc_invalidation)
diff --git a/xlators/performance/nl-cache/src/nl-cache-helper.c b/xlators/performance/nl-cache/src/nl-cache-helper.c
index 03dedf8ea08..29b99b5b8ea 100644
--- a/xlators/performance/nl-cache/src/nl-cache-helper.c
+++ b/xlators/performance/nl-cache/src/nl-cache-helper.c
@@ -113,7 +113,7 @@ out:
 }
 
 void
-nlc_update_child_down_time(xlator_t *this, time_t *now)
+nlc_update_child_down_time(xlator_t *this, time_t now)
 {
     nlc_conf_t *conf = NULL;
 
@@ -121,7 +121,7 @@ nlc_update_child_down_time(xlator_t *this, time_t *now)
 
     LOCK(&conf->lock);
     {
-        conf->last_child_down = *now;
+        conf->last_child_down = now;
     }
     UNLOCK(&conf->lock);
 
@@ -262,7 +262,7 @@ nlc_init_invalid_ctx(xlator_t *this, inode_t *inode, nlc_ctx_t *nlc_ctx)
         if (nlc_ctx->timer) {
             gf_tw_mod_timer_pending(conf->timer_wheel, nlc_ctx->timer,
                                     conf->cache_timeout);
-            time(&nlc_ctx->cache_time);
+            nlc_ctx->cache_time = gf_time();
             goto unlock;
         }
 
@@ -496,7 +496,7 @@ __nlc_inode_ctx_timer_start(xlator_t *this, inode_t *inode, nlc_ctx_t *nlc_ctx)
     nlc_ctx->timer_data = tmp;
     gf_tw_add_timer(conf->timer_wheel, timer);
 
-    time(&nlc_ctx->cache_time);
+    nlc_ctx->cache_time = gf_time();
     gf_msg_trace(this->name, 0,
                  "Registering timer:%p, inode:%p, "
                  "gfid:%s",
diff --git a/xlators/performance/nl-cache/src/nl-cache.c b/xlators/performance/nl-cache/src/nl-cache.c
index cd0e1d195fd..33a7c471663 100644
--- a/xlators/performance/nl-cache/src/nl-cache.c
+++ b/xlators/performance/nl-cache/src/nl-cache.c
@@ -520,15 +520,13 @@ int
 nlc_notify(xlator_t *this, int event, void *data, ...)
 {
     int ret = 0;
-    time_t now = 0;
 
     switch (event) {
         case GF_EVENT_CHILD_DOWN:
         case GF_EVENT_SOME_DESCENDENT_DOWN:
         case GF_EVENT_CHILD_UP:
         case GF_EVENT_SOME_DESCENDENT_UP:
-            time(&now);
-            nlc_update_child_down_time(this, &now);
+            nlc_update_child_down_time(this, gf_time());
             /* TODO: nlc_clear_all_cache (this); else
              lru prune will lazily clear it*/
             break;
@@ -731,7 +729,7 @@ nlc_init(xlator_t *this)
     GF_ATOMIC_INIT(conf->nlc_counter.nlc_invals, 0);
 
     INIT_LIST_HEAD(&conf->lru);
-    time(&conf->last_child_down);
+    conf->last_child_down = gf_time();
 
     conf->timer_wheel = glusterfs_ctx_tw_get(this->ctx);
     if (!conf->timer_wheel) {
diff --git a/xlators/performance/nl-cache/src/nl-cache.h b/xlators/performance/nl-cache/src/nl-cache.h
index 8b09972bb09..85fcc176342 100644
--- a/xlators/performance/nl-cache/src/nl-cache.h
+++ b/xlators/performance/nl-cache/src/nl-cache.h
@@ -155,7 +155,7 @@ nlc_local_init(call_frame_t *frame, xlator_t *this, glusterfs_fop_t fop,
                loc_t *loc, loc_t *loc2);
 
 void
-nlc_update_child_down_time(xlator_t *this, time_t *now);
+nlc_update_child_down_time(xlator_t *this, time_t now);
 
 void
 nlc_inode_clear_cache(xlator_t *this, inode_t *inode, int reason);
diff --git a/xlators/performance/open-behind/src/open-behind.c b/xlators/performance/open-behind/src/open-behind.c
index e43fe73bcca..600c3b62ffe 100644
--- a/xlators/performance/open-behind/src/open-behind.c
+++ b/xlators/performance/open-behind/src/open-behind.c
@@ -333,6 +333,15 @@ ob_stub_dispatch(xlator_t *xl, ob_inode_t *ob_inode, fd_t *fd,
     return 0;
 }
 
+static void
+ob_open_destroy(call_stub_t *stub, fd_t *fd)
+{
+    stub->frame->local = NULL;
+    STACK_DESTROY(stub->frame->root);
+    call_stub_destroy(stub);
+    fd_unref(fd);
+}
+
 static int32_t
 ob_open_dispatch(xlator_t *xl, ob_inode_t *ob_inode, fd_t *fd,
                  call_stub_t *stub)
@@ -355,8 +364,7 @@ ob_open_dispatch(xlator_t *xl, ob_inode_t *ob_inode, fd_t *fd,
 
     if (stub != NULL) {
         if (closed) {
-            call_stub_destroy(stub);
-            fd_unref(fd);
+            ob_open_destroy(stub, fd);
         } else {
             call_resume(stub);
         }
@@ -509,6 +517,56 @@ ob_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, fd_t *fd,
 }
 
 static int32_t
+ob_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int flags,
+          mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata)
+{
+    ob_inode_t *ob_inode;
+    call_stub_t *stub;
+    fd_t *first_fd;
+    ob_state_t state;
+
+    /* Create requests are never delayed. We always send them synchronously. */
+    state = ob_open_and_resume_fd(this, fd, 1, true, true, &ob_inode,
+                                  &first_fd);
+    if (state == OB_STATE_READY) {
+        /* There's no pending open, but there are other file descriptors opened
+         * so we simply forward the request synchronously. */
+        return default_create(frame, this, loc, flags, mode, umask, fd, xdata);
+    }
+
+    if (state == OB_STATE_OPEN_TRIGGERED) {
+        /* The first open is in progress (either because it was already issued
+         * or because this request triggered it). We try to create a new stub
+         * to retry the operation once the initial open completes. */
+        stub = fop_create_stub(frame, ob_create, loc, flags, mode, umask, fd,
+                               xdata);
+        if (stub != NULL) {
+            return ob_stub_dispatch(this, ob_inode, first_fd, stub);
+        }
+
+        state = -ENOMEM;
+    }
+
+    /* Since we forced a synchronous request, OB_STATE_FIRST_OPEN will never
+     * be returned by ob_open_and_resume_fd(). If we are here it can only be
+     * because there has been a problem. */
+
+    /* In case of failure we need to decrement the number of open files because
+     * ob_fdclose() won't be called. */
+
+    LOCK(&fd->inode->lock);
+    {
+        ob_inode->open_count--;
+    }
+    UNLOCK(&fd->inode->lock);
+
+    gf_smsg(this->name, GF_LOG_ERROR, -state, OPEN_BEHIND_MSG_FAILED, "fop=%s",
+            "create", "path=%s", loc->path, NULL);
+
+    return default_create_failure_cbk(frame, -state);
+}
+
+static int32_t
 ob_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size,
          off_t offset, uint32_t flags, dict_t *xdata)
 {
@@ -776,8 +834,7 @@ ob_fdclose(xlator_t *this, fd_t *fd)
     UNLOCK(&fd->inode->lock);
 
     if (stub != NULL) {
-        call_stub_destroy(stub);
-        fd_unref(fd);
+        ob_open_destroy(stub, fd);
     }
 
     ob_resume_pending(&list);
@@ -940,6 +997,7 @@ fini(xlator_t *this)
 
 struct xlator_fops fops = {
     .open = ob_open,
+    .create = ob_create,
     .readv = ob_readv,
     .writev = ob_writev,
     .flush = ob_flush,
diff --git a/xlators/performance/quick-read/src/quick-read.c b/xlators/performance/quick-read/src/quick-read.c
index 640c9ac51c6..7fe4b3c3a4b 100644
--- a/xlators/performance/quick-read/src/quick-read.c
+++ b/xlators/performance/quick-read/src/quick-read.c
@@ -421,9 +421,6 @@ qr_content_update(xlator_t *this, qr_inode_t *qr_inode, void *data,
     qr_private_t *priv = NULL;
     qr_inode_table_t *table = NULL;
     uint32_t rollover = 0;
-    struct timeval tv = {
-        0,
-    };
 
     rollover = gen >> 32;
     gen = gen & 0xffffffff;
@@ -431,7 +428,6 @@ qr_content_update(xlator_t *this, qr_inode_t *qr_inode, void *data,
     priv = this->private;
     table = &priv->table;
 
-    gettimeofday(&tv, NULL);
     LOCK(&table->lock);
     {
         if ((rollover != qr_inode->gen_rollover) ||
@@ -453,8 +449,7 @@ qr_content_update(xlator_t *this, qr_inode_t *qr_inode, void *data,
         qr_inode->ia_ctime_nsec = buf->ia_ctime_nsec;
 
         qr_inode->buf = *buf;
-
-        memcpy(&qr_inode->last_refresh, &tv, sizeof(struct timeval));
+        qr_inode->last_refresh = gf_time();
 
         __qr_inode_register(this, table, qr_inode);
     }
@@ -524,9 +519,7 @@ __qr_content_refresh(xlator_t *this, qr_inode_t *qr_inode, struct iatt *buf,
 
     if (qr_size_fits(conf, buf) && qr_time_equal(conf, qr_inode, buf)) {
         qr_inode->buf = *buf;
-
-        gettimeofday(&qr_inode->last_refresh, NULL);
-
+        qr_inode->last_refresh = gf_time();
         __qr_inode_register(this, table, qr_inode);
     } else {
         __qr_inode_prune(this, table, qr_inode, gen);
@@ -558,20 +551,14 @@ __qr_cache_is_fresh(xlator_t *this, qr_inode_t *qr_inode)
 {
     qr_conf_t *conf = NULL;
     qr_private_t *priv = NULL;
-    struct timeval now;
-    struct timeval diff;
 
     priv = this->private;
     conf = &priv->conf;
 
-    gettimeofday(&now, NULL);
-
-    timersub(&now, &qr_inode->last_refresh, &diff);
-
-    if (qr_inode->last_refresh.tv_sec < priv->last_child_down)
+    if (qr_inode->last_refresh < priv->last_child_down)
         return _gf_false;
 
-    if (diff.tv_sec >= conf->cache_timeout)
+    if (gf_time() - qr_inode->last_refresh >= conf->cache_timeout)
         return _gf_false;
 
     return _gf_true;
@@ -1049,9 +1036,8 @@ qr_inodectx_dump(xlator_t *this, inode_t *inode)
     gf_proc_dump_write("entire-file-cached", "%s",
                        qr_inode->data ? "yes" : "no");
 
-    if (qr_inode->last_refresh.tv_sec) {
-        gf_time_fmt_tv(buf, sizeof buf, &qr_inode->last_refresh, gf_timefmt_FT);
-
+    if (qr_inode->last_refresh) {
+        gf_time_fmt(buf, sizeof buf, qr_inode->last_refresh, gf_timefmt_FT);
         gf_proc_dump_write("last-cache-validation-time", "%s", buf);
     }
 
@@ -1404,7 +1390,7 @@ qr_init(xlator_t *this)
 
     ret = 0;
 
-    time(&priv->last_child_down);
+    priv->last_child_down = gf_time();
     GF_ATOMIC_INIT(priv->generation, 0);
     this->private = priv;
 out:
@@ -1454,7 +1440,7 @@ qr_conf_destroy(qr_conf_t *conf)
 }
 
 void
-qr_update_child_down_time(xlator_t *this, time_t *now)
+qr_update_child_down_time(xlator_t *this, time_t now)
 {
     qr_private_t *priv = NULL;
 
@@ -1462,7 +1448,7 @@ qr_update_child_down_time(xlator_t *this, time_t *now)
 
     LOCK(&priv->lock);
     {
-        priv->last_child_down = *now;
+        priv->last_child_down = now;
     }
     UNLOCK(&priv->lock);
 }
@@ -1508,7 +1494,6 @@ qr_notify(xlator_t *this, int event, void *data, ...)
 {
     int ret = 0;
     qr_private_t *priv = NULL;
-    time_t now = 0;
     qr_conf_t *conf = NULL;
 
     priv = this->private;
@@ -1517,8 +1502,7 @@ qr_notify(xlator_t *this, int event, void *data, ...)
     switch (event) {
         case GF_EVENT_CHILD_DOWN:
         case GF_EVENT_SOME_DESCENDENT_DOWN:
-            time(&now);
-            qr_update_child_down_time(this, &now);
+            qr_update_child_down_time(this, gf_time());
             break;
         case GF_EVENT_UPCALL:
             if (conf->qr_invalidation)
diff --git a/xlators/performance/quick-read/src/quick-read.h b/xlators/performance/quick-read/src/quick-read.h
index 67850821b8e..20fcc70b3a7 100644
--- a/xlators/performance/quick-read/src/quick-read.h
+++ b/xlators/performance/quick-read/src/quick-read.h
@@ -39,7 +39,7 @@ struct qr_inode {
     uint32_t ia_ctime_nsec;
     uint32_t gen_rollover;
     struct iatt buf;
-    struct timeval last_refresh;
+    time_t last_refresh;
     struct list_head lru;
     uint64_t gen;
     uint64_t invalidation_time;