From c4b8c629f738a8d9e020adccd70a4893c9e42fb8 Mon Sep 17 00:00:00 2001

From: Poornima G <pgurusid@redhat.com>

Date: Wed, 12 Apr 2017 15:24:14 +0530

Subject: [PATCH 392/393] Implement negative lookup cache

Before creating any file negative lookups(1 in Fuse, 4 in SMB etc.)

are sent to verify if the file already exists. By serving these

lookups from the cache when possible, increases the create

performance by multiple folds in SMB access and some percentage

in Fuse/NFS access.

Feature page: https://review.gluster.org/#/c/16436

>Signed-off-by: Poornima G <pgurusid@redhat.com>

>Reviewed-on: https://review.gluster.org/16952

>Reviewed-by: Pranith Kumar Karampuri <pkarampu@redhat.com>

>Tested-by: Pranith Kumar Karampuri <pkarampu@redhat.com>

>Smoke: Gluster Build System <jenkins@build.gluster.org>

>NetBSD-regression: NetBSD Build System <jenkins@build.gluster.org>

>CentOS-regression: Gluster Build System <jenkins@build.gluster.org>

Updates #82

Change-Id: Ib1c0e7ac7a386f943d84f6398c27f9a03665b2a4

BUG: 1427099

Signed-off-by: Poornima G <pgurusid@redhat.com>

Reviewed-on: https://code.engineering.redhat.com/gerrit/103884

Reviewed-by: Milind Changire <mchangir@redhat.com>

Reviewed-by: Atin Mukherjee <amukherj@redhat.com>

---

 configure.ac                                       |    2 +

 glusterfs.spec.in                                  |    1 +

 libglusterfs/src/glfs-message-id.h                 |    4 +

 libglusterfs/src/globals.h                         |    4 +-

 tests/basic/nl-cache.t                             |   64 ++

 xlators/mgmt/glusterd/src/glusterd-volume-set.c    |   31 +

 xlators/performance/Makefile.am                    |    2 +-

 xlators/performance/nl-cache/Makefile.am           |    3 +

 xlators/performance/nl-cache/src/Makefile.am       |   12 +

 xlators/performance/nl-cache/src/nl-cache-helper.c | 1142 ++++++++++++++++++++

 .../performance/nl-cache/src/nl-cache-mem-types.h  |   29 +

 .../performance/nl-cache/src/nl-cache-messages.h   |   34 +

 xlators/performance/nl-cache/src/nl-cache.c        |  775 +++++++++++++

 xlators/performance/nl-cache/src/nl-cache.h        |  173 +++

 14 files changed, 2274 insertions(+), 2 deletions(-)

 create mode 100755 tests/basic/nl-cache.t

 create mode 100644 xlators/performance/nl-cache/Makefile.am

 create mode 100644 xlators/performance/nl-cache/src/Makefile.am

 create mode 100644 xlators/performance/nl-cache/src/nl-cache-helper.c

 create mode 100644 xlators/performance/nl-cache/src/nl-cache-mem-types.h

 create mode 100644 xlators/performance/nl-cache/src/nl-cache-messages.h

 create mode 100644 xlators/performance/nl-cache/src/nl-cache.c

 create mode 100644 xlators/performance/nl-cache/src/nl-cache.h

diff --git a/configure.ac b/configure.ac

index 2c25be6..b5357dc 100644

--- a/configure.ac

+++ b/configure.ac

@@ -101,6 +101,8 @@ AC_CONFIG_FILES([Makefile

                 xlators/performance/md-cache/src/Makefile

                 xlators/performance/decompounder/Makefile

                 xlators/performance/decompounder/src/Makefile

+                xlators/performance/nl-cache/Makefile

+                xlators/performance/nl-cache/src/Makefile

                 xlators/debug/Makefile

                 xlators/debug/trace/Makefile

                 xlators/debug/trace/src/Makefile

diff --git a/glusterfs.spec.in b/glusterfs.spec.in

index c313d2f..da334d5 100644

--- a/glusterfs.spec.in

+++ b/glusterfs.spec.in

@@ -1128,6 +1128,7 @@ exit 0

 %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/performance/readdir-ahead.so

 %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/performance/stat-prefetch.so

 %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/performance/write-behind.so

+%{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/performance/nl-cache.so

 %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/system/posix-acl.so

 %dir %{_localstatedir}/run/gluster

 %if 0%{?_tmpfilesdir:1}

diff --git a/libglusterfs/src/glfs-message-id.h b/libglusterfs/src/glfs-message-id.h

index de7c494..a511f0d 100644

--- a/libglusterfs/src/glfs-message-id.h

+++ b/libglusterfs/src/glfs-message-id.h

@@ -179,6 +179,10 @@ GLFS_MSGID_COMP_SYMLINK_CACHE_END

 #define GLFS_MSGID_COMP_LEASES_END         (GLFS_MSGID_COMP_LEASES +\

                                            GLFS_MSGID_SEGMENT)

+#define GLFS_MSGID_COMP_NLC                GLFS_MSGID_COMP_LEASES_END

+#define GLFS_MSGID_COMP_NLC_END            (GLFS_MSGID_COMP_NLC +\

+                                           GLFS_MSGID_SEGMENT)

+

 /* --- new segments for messages goes above this line --- */

 #endif /* !_GLFS_MESSAGE_ID_H_ */

diff --git a/libglusterfs/src/globals.h b/libglusterfs/src/globals.h

index 5d57a42..a1ec8f0 100644

--- a/libglusterfs/src/globals.h

+++ b/libglusterfs/src/globals.h

@@ -43,7 +43,7 @@

  */

 #define GD_OP_VERSION_MIN  1 /* MIN is the fresh start op-version, mostly

                                 should not change */

-#define GD_OP_VERSION_MAX  GD_OP_VERSION_3_10_1 /* MAX VERSION is the maximum

+#define GD_OP_VERSION_MAX  GD_OP_VERSION_3_11_0 /* MAX VERSION is the maximum

                                                   count in VME table, should

                                                   keep changing with

                                                   introduction of newer

@@ -89,6 +89,8 @@

 #define GD_OP_VERSION_3_10_1   31001 /* Op-version for GlusterFS 3.10.1 */

+#define GD_OP_VERSION_3_11_0   31100 /* Op-version for GlusterFS 3.11.0 */

+

 #include "xlator.h"

 /* THIS */

diff --git a/tests/basic/nl-cache.t b/tests/basic/nl-cache.t

new file mode 100755

index 0000000..ddd4e25

--- /dev/null

+++ b/tests/basic/nl-cache.t

@@ -0,0 +1,64 @@

+#!/bin/bash

+

+. $(dirname $0)/../include.rc

+. $(dirname $0)/../volume.rc

+

+cleanup;

+

+TEST glusterd

+

+TEST $CLI volume create $V0 $H0:$B0/${V0}{0..4}

+EXPECT 'Created' volinfo_field $V0 'Status'

+

+TEST $CLI volume set $V0 performance.nl-cache on

+TEST $CLI volume set $V0 features.cache-invalidation on

+TEST $CLI volume set $V0 features.cache-invalidation-timeout 600

+

+TEST $CLI volume start $V0;

+EXPECT 'Started' volinfo_field $V0 'Status';

+

+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M0

+TEST glusterfs --volfile-id=/$V0 --volfile-server=$H0 $M1

+

+TEST ! ls $M0/file2

+TEST touch $M0/file1

+TEST ! ls $M0/file2

+TEST touch $M0/file2

+TEST ls $M0/file2

+TEST rm $M0/file2

+TEST rm $M0/file1

+

+TEST mkdir $M0/dir1

+TEST ! ls -l $M0/dir1/file

+TEST mkdir $M0/dir1/dir2

+TEST ! ls -l $M0/dir1/file

+TEST ! ls -l $M0/dir1/dir2/file

+TEST ls -l $M0/dir1/dir2

+TEST rmdir $M0/dir1/dir2

+TEST rmdir $M0/dir1

+

+TEST ! ls -l $M0/file2

+TEST touch $M1/file2

+TEST ls -l $M0/file2

+TEST rm $M1/file2

+

+TEST ! ls -l $M0/dir1

+TEST mkdir $M1/dir1

+TEST ls -l $M0/dir1

+TEST ! ls -l $M0/dir1/file1

+TEST mkdir $M1/dir1/dir2

+TEST ! ls -l $M0/dir1/file1

+TEST ls -l $M0/dir1/dir2

+TEST ! ls -l $M1/dir1/file1

+

+TEST touch $M0/dir1/file

+TEST ln $M0/dir1/file $M0/dir1/file_link

+TEST ls -l $M1/dir1/file

+TEST ls -l $M1/dir1/file_link

+TEST rm $M0/dir1/file

+TEST rm $M0/dir1/file_link

+TEST rmdir $M0/dir1/dir2

+TEST rmdir $M0/dir1

+

+cleanup;

+#G_TESTDEF_TEST_STATUS_NETBSD7=BAD_TEST,BUG=000000

diff --git a/xlators/mgmt/glusterd/src/glusterd-volume-set.c b/xlators/mgmt/glusterd/src/glusterd-volume-set.c

index bbb07b0..4ee27b4 100644

--- a/xlators/mgmt/glusterd/src/glusterd-volume-set.c

+++ b/xlators/mgmt/glusterd/src/glusterd-volume-set.c

@@ -1941,6 +1941,16 @@ struct volopt_map_entry glusterd_volopt_map[] = {

           .flags       = OPT_FLAG_CLIENT_OPT | OPT_FLAG_XLATOR_OPT

         },

+        { .key         = "performance.nl-cache",

+          .voltype     = "performance/nl-cache",

+          .option      = "!perf",

+          .value       = "off",

+          .op_version  = GD_OP_VERSION_3_11_0,

+          .description = "enable/disable negative entry caching translator in "

+                         "the volume. Enabling this option improves performance"

+                         " of 'create file/directory' workload",

+          .flags       = OPT_FLAG_CLIENT_OPT | OPT_FLAG_XLATOR_OPT

+        },

         { .key         = "performance.stat-prefetch",

           .voltype     = "performance/md-cache",

           .option      = "!perf",

@@ -3104,6 +3114,27 @@ struct volopt_map_entry glusterd_volopt_map[] = {

           .flags       = OPT_FLAG_CLIENT_OPT,

           .op_version  = GD_OP_VERSION_3_9_1,

         },

+        { .key         = "performance.nl-cache-positive-entry",

+          .voltype     = "performance/nl-cache",

+          .value       = "on",

+          .type        = DOC,

+          .flags       = OPT_FLAG_CLIENT_OPT,

+          .op_version  = GD_OP_VERSION_3_11_0,

+          .description = "enable/disable storing of entries that were lookedup"

+                         " and found to be present in the volume, thus lookup"

+                         " on non existant file is served from the cache",

+        },

+        { .key         = "performance.nl-cache-limit",

+          .voltype     = "performance/nl-cache",

+          .value       = "10MB",

+          .flags       = OPT_FLAG_CLIENT_OPT,

+          .op_version  = GD_OP_VERSION_3_11_0,

+        },

+        { .key         = "performance.nl-cache-timeout",

+          .voltype     = "performance/nl-cache",

+          .flags       = OPT_FLAG_CLIENT_OPT,

+          .op_version  = GD_OP_VERSION_3_11_0,

+        },

         { .key        = "disperse.optimistic-change-log",

           .voltype    = "cluster/disperse",

           .type       = NO_DOC,

diff --git a/xlators/performance/Makefile.am b/xlators/performance/Makefile.am

index eb4e32c..e162734 100644

--- a/xlators/performance/Makefile.am

+++ b/xlators/performance/Makefile.am

@@ -1,3 +1,3 @@

-SUBDIRS = write-behind read-ahead readdir-ahead io-threads io-cache symlink-cache quick-read md-cache open-behind decompounder

+SUBDIRS = write-behind read-ahead readdir-ahead io-threads io-cache symlink-cache quick-read md-cache open-behind decompounder nl-cache

 CLEANFILES = 

diff --git a/xlators/performance/nl-cache/Makefile.am b/xlators/performance/nl-cache/Makefile.am

new file mode 100644

index 0000000..a985f42

--- /dev/null

+++ b/xlators/performance/nl-cache/Makefile.am

@@ -0,0 +1,3 @@

+SUBDIRS = src

+

+CLEANFILES =

diff --git a/xlators/performance/nl-cache/src/Makefile.am b/xlators/performance/nl-cache/src/Makefile.am

new file mode 100644

index 0000000..f45e8be

--- /dev/null

+++ b/xlators/performance/nl-cache/src/Makefile.am

@@ -0,0 +1,12 @@

+xlator_LTLIBRARIES = nl-cache.la

+xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/performance

+nl_cache_la_LDFLAGS = -module -avoid-version

+nl_cache_la_SOURCES = nl-cache.c nl-cache-helper.c

+nl_cache_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la

+noinst_HEADERS = nl-cache.h nl-cache-mem-types.h nl-cache-messages.h

+AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \

+        -I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src \

+        -I$(CONTRIBDIR)/timer-wheel

+

+AM_CFLAGS = -Wall -fno-strict-aliasing $(GF_CFLAGS)

+CLEANFILES =

diff --git a/xlators/performance/nl-cache/src/nl-cache-helper.c b/xlators/performance/nl-cache/src/nl-cache-helper.c

new file mode 100644

index 0000000..34438ed

--- /dev/null

+++ b/xlators/performance/nl-cache/src/nl-cache-helper.c

@@ -0,0 +1,1142 @@

+/*

+ *   Copyright (c) 2017 Red Hat, Inc. <http://www.redhat.com>

+ *   This file is part of GlusterFS.

+ *

+ *   This file is licensed to you under your choice of the GNU Lesser

+ *   General Public License, version 3 or any later version (LGPLv3 or

+ *   later), or the GNU General Public License, version 2 (GPLv2), in all

+ *   cases as published by the Free Software Foundation.

+ */

+

+#include "nl-cache.h"

+#include "timer-wheel.h"

+#include "statedump.h"

+

+/* Caching guidelines:

+ * This xlator serves negative lookup(ENOENT lookups) from the cache,

+ * there by making create faster.

+ *   What is cached?

+ *      Negative lookup cache is stored for each directory, and has 2 entries:

+ *      - Negative entries: Populated only when lookup/stat returns ENOENT.

+ *        Fuse mostly sends only one lookup before create, hence negative entry

+ *        cache is almost useless. But for SMB access, multiple lookups/stats

+ *        are sent before creating the file. Hence the negative entry cache.

+ *        It can exist even when the positive entry cache is invalid. It also

+ *        has the entries that were deleted from this directory.

+ *        Freed on recieving upcall(with dentry change flag) or on expiring

+ *        timeout of the cache.

+ *

+ *      - Positive entries: Populated as a part of readdirp, and as a part of

+ *        mkdir followed by creates inside that directory. Lookups and other

+ *        fops do not populate the positive entry (as it can grow long and is

+ *        of no value add)

+ *        Freed on recieving upcall(with dentry change flag) or on expiring

+ *        timeout of the cache.

+ *

+ *   Data structures to store cache?

+ *      The cache of any directory is stored in the inode_ctx of the directory.

+ *      Negative entries are stored as list of strings.

+ *             Search - O(n)

+ *             Add    - O(1)

+ *             Delete - O(n) - as it has to be searched before deleting

+ *      Positive entries are stored as a list, each list node has a pointer

+ *          to the inode of the positive entry or the name of the entry.

+ *          Since the client side inode table already will have inodes for

+ *          positive entries, we just take a ref of that inode and store as

+ *          positive entry cache. In cases like hardlinks and readdirp where

+ *          inode is NULL, we store the names.

+ *          Name Search - O(n)

+ *          Inode Search - O(1) - Actually complexity of inode_find()

+ *          Name/inode Add - O(1)

+ *          Name Delete - O(n)

+ *          Inode Delete - O(1)

+ *

+ * Locking order:

+ *

+ * TODO:

+ * - Fill Positive entries on readdir/p, after which in lookup_cbk check if the

+ *   name is in PE and replace it with inode.

+ * - fini, PARENET_DOWN, disable caching

+ * - Virtual setxattr to dump the inode_ctx, to ease debugging

+ * - Handle dht_nuke xattr: clear all cache

+ * - Special handling for .meta and .trashcan?

+ */

+

+int __nlc_inode_ctx_timer_start (xlator_t *this, inode_t *inode, nlc_ctx_t *nlc_ctx);

+int __nlc_add_to_lru (xlator_t *this, inode_t *inode, nlc_ctx_t *nlc_ctx);

+void nlc_remove_from_lru (xlator_t *this, inode_t *inode);

+void __nlc_inode_ctx_timer_delete (xlator_t *this, nlc_ctx_t *nlc_ctx);

+gf_boolean_t __nlc_search_ne (nlc_ctx_t *nlc_ctx, const char *name);

+

+static int32_t

+nlc_get_cache_timeout (xlator_t *this)

+{

+        nlc_conf_t *conf = NULL;

+

+        conf = this->private;

+

+        /* Cache timeout is generally not meant to be changed often,

+         * once set, hence not within locks */

+        return conf->cache_timeout;

+}

+

+

+static gf_boolean_t

+__nlc_is_cache_valid (xlator_t *this, nlc_ctx_t *nlc_ctx)

+{

+        nlc_conf_t   *conf         = NULL;

+        time_t       last_val_time;

+        gf_boolean_t ret           = _gf_false;

+

+        GF_VALIDATE_OR_GOTO (this->name, nlc_ctx, out);

+

+        conf = this->private;

+

+        LOCK (&conf->lock);

+        {

+                last_val_time = conf->last_child_down;

+        }

+        UNLOCK (&conf->lock);

+

+        if (last_val_time <= nlc_ctx->cache_time)

+                ret = _gf_true;

+out:

+        return ret;

+}

+

+

+void

+nlc_update_child_down_time (xlator_t *this, time_t *now)

+{

+        nlc_conf_t *conf = NULL;

+

+        conf = this->private;

+

+        LOCK (&conf->lock);

+        {

+                conf->last_child_down = *now;

+        }

+        UNLOCK (&conf->lock);

+

+        return;

+}

+

+

+void

+nlc_disable_cache (xlator_t *this)

+{

+        nlc_conf_t *conf = NULL;

+

+        conf = this->private;

+

+        LOCK (&conf->lock);

+        {

+                conf->disable_cache = _gf_true;

+        }

+        UNLOCK (&conf->lock);

+

+        return;

+}

+

+

+static int

+__nlc_inode_ctx_get (xlator_t *this, inode_t *inode, nlc_ctx_t **nlc_ctx_p,

+                     nlc_pe_t **nlc_pe_p)

+{

+        int              ret = 0;

+        nlc_ctx_t        *nlc_ctx = NULL;

+        nlc_pe_t         *nlc_pe = NULL;

+        uint64_t         nlc_ctx_int = 0;

+        uint64_t         nlc_pe_int = 0;

+

+        ret = __inode_ctx_get2 (inode, this, &nlc_ctx_int, &nlc_pe_int);

+        if (ret == 0 && nlc_ctx_p) {

+                nlc_ctx = (void *) (long) (nlc_ctx_int);

+                *nlc_ctx_p = nlc_ctx;

+        }

+        if (ret == 0 && nlc_pe_p) {

+                nlc_pe = (void *) (long) (&nlc_pe_int);

+                *nlc_pe_p = nlc_pe;

+        }

+        return ret;

+}

+

+

+static int

+nlc_inode_ctx_set (xlator_t *this, inode_t *inode, nlc_ctx_t *nlc_ctx,

+                   nlc_pe_t *nlc_pe_p)

+{

+        int   ret = -1;

+

+        /* The caller may choose to set one of the ctxs, hence check

+         * if the ctx1/2 is non zero and then send the adress. If we

+         * blindly send the address of both the ctxs, it may reset the

+         * ctx the caller had sent NULL(intended as leave untouched) for.*/

+        LOCK(&inode->lock);

+        {

+                ret = __inode_ctx_set2 (inode, this,

+                                        nlc_ctx ? (uint64_t *) &nlc_ctx : 0,

+                                        nlc_pe_p ? (uint64_t *) &nlc_pe_p : 0);

+        }

+        UNLOCK(&inode->lock);

+        return ret;

+}

+

+

+static void

+nlc_inode_ctx_get (xlator_t *this, inode_t *inode, nlc_ctx_t **nlc_ctx_p,

+                   nlc_pe_t **nlc_pe_p)

+{

+        int ret = 0;

+

+        LOCK (&inode->lock);

+        {

+                ret = __nlc_inode_ctx_get (this, inode, nlc_ctx_p, nlc_pe_p);

+                if (ret < 0)

+                        gf_msg_debug (this->name, 0, "inode ctx get failed for "

+                                      "inode:%p", inode);

+        }

+        UNLOCK (&inode->lock);

+

+        return;

+}

+

+

+static nlc_ctx_t *

+nlc_inode_ctx_get_set (xlator_t *this, inode_t *inode, nlc_ctx_t **nlc_ctx_p,

+                       nlc_pe_t **nlc_pe_p)

+{

+        int                         ret    = 0;

+        nlc_ctx_t                  *nlc_ctx = NULL;

+        nlc_conf_t                 *conf   = NULL;

+

+        conf = this->private;

+

+        LOCK (&inode->lock);

+        {

+                ret = __nlc_inode_ctx_get (this, inode, &nlc_ctx, nlc_pe_p);

+                if (nlc_ctx)

+                        goto unlock;

+

+                nlc_ctx = GF_CALLOC (sizeof (*nlc_ctx), 1, gf_nlc_mt_nlc_ctx_t);

+                if (!nlc_ctx)

+                        goto unlock;

+

+                LOCK_INIT (&nlc_ctx->lock);

+                INIT_LIST_HEAD (&nlc_ctx->pe);

+                INIT_LIST_HEAD (&nlc_ctx->ne);

+

+                ret = __nlc_inode_ctx_timer_start (this, inode, nlc_ctx);

+                if (ret < 0)

+                        goto unlock;

+

+                ret = __nlc_add_to_lru (this, inode, nlc_ctx);

+                if (ret < 0) {

+                        __nlc_inode_ctx_timer_delete (this, nlc_ctx);

+                        goto unlock;

+                }

+

+                ret = __inode_ctx_set2 (inode, this, (uint64_t *) &nlc_ctx, NULL);

+                if (ret) {

+                        gf_msg (this->name, GF_LOG_ERROR, ENOMEM,

+                                NLC_MSG_NO_MEMORY, "inode ctx set failed");

+                        __nlc_inode_ctx_timer_delete (this, nlc_ctx);

+                        nlc_remove_from_lru (this, inode);

+                        goto unlock;

+                }

+

+                /*TODO: also sizeof (gf_tw_timer_list) + nlc_timer_data_t ?*/

+                nlc_ctx->cache_size = sizeof (*nlc_ctx);

+                GF_ATOMIC_ADD (conf->current_cache_size, nlc_ctx->cache_size);

+        }

+unlock:

+        UNLOCK (&inode->lock);

+

+        if (ret == 0 && nlc_ctx_p)

+                *nlc_ctx_p = nlc_ctx;

+

+        if (ret < 0 && nlc_ctx) {

+                LOCK_DESTROY (&nlc_ctx->lock);

+                GF_FREE (nlc_ctx);

+                nlc_ctx = NULL;

+                goto out;

+        }

+out:

+        return nlc_ctx;

+}

+

+

+nlc_local_t *

+nlc_local_init (call_frame_t *frame, xlator_t *this, glusterfs_fop_t fop,

+                loc_t *loc, loc_t *loc2)

+{

+        nlc_local_t *local = NULL;

+

+        local = GF_CALLOC (sizeof (*local), 1, gf_nlc_mt_nlc_local_t);

+        if (!local)

+                goto out;

+

+        if (loc)

+                loc_copy (&local->loc, loc);

+        if (loc2)

+                loc_copy (&local->loc2, loc2);

+

+        local->fop = fop;

+        frame->local = local;

+out:

+        return local;

+}

+

+

+void

+nlc_local_wipe (xlator_t *this, nlc_local_t *local)

+{

+        if (!local)

+                goto out;

+

+        loc_wipe (&local->loc);

+

+        loc_wipe (&local->loc2);

+

+        GF_FREE (local);

+out:

+        return;

+}

+

+

+static void

+__nlc_set_dir_state (nlc_ctx_t *nlc_ctx, uint64_t new_state)

+{

+        nlc_ctx->state |= new_state;

+

+        return;

+}

+

+

+void

+nlc_set_dir_state (xlator_t *this, inode_t *inode, uint64_t state)

+{

+        nlc_ctx_t        *nlc_ctx = NULL;

+

+        if (inode->ia_type != IA_IFDIR) {

+                gf_msg_callingfn (this->name, GF_LOG_ERROR, EINVAL,

+                                  NLC_MSG_EINVAL, "inode is not of type dir");

+                goto out;

+        }

+

+        nlc_inode_ctx_get_set (this, inode, &nlc_ctx, NULL);

+        if (!nlc_ctx)

+                goto out;

+

+        LOCK (&nlc_ctx->lock);

+        {

+                __nlc_set_dir_state (nlc_ctx, state);

+        }

+        UNLOCK (&nlc_ctx->lock);

+out:

+        return;

+}

+

+

+static void

+nlc_cache_timeout_handler (struct gf_tw_timer_list *timer,

+                           void *data, unsigned long calltime)

+{

+        nlc_timer_data_t *tmp = data;

+

+        nlc_inode_clear_cache (tmp->this, tmp->inode, NLC_TIMER_EXPIRED);

+        inode_unref (tmp->inode);

+

+        GF_FREE (tmp);

+        GF_FREE (timer);

+

+        return;

+}

+

+

+void

+__nlc_inode_ctx_timer_delete (xlator_t *this, nlc_ctx_t *nlc_ctx)

+{

+        nlc_conf_t                  *conf   = NULL;

+

+        conf = this->private;

+

+        gf_tw_del_timer (conf->timer_wheel, nlc_ctx->timer);

+

+        inode_unref (nlc_ctx->timer_data->inode);

+        GF_FREE (nlc_ctx->timer_data);

+

+        GF_FREE (nlc_ctx->timer);

+        nlc_ctx->timer = NULL;

+

+        return;

+}

+

+

+int

+__nlc_inode_ctx_timer_start (xlator_t *this, inode_t *inode, nlc_ctx_t *nlc_ctx)

+{

+        struct gf_tw_timer_list    *timer  = NULL;

+        nlc_timer_data_t           *tmp    = NULL;

+        nlc_conf_t                 *conf   = NULL;

+        int                         ret    = -1;

+

+        conf = this->private;

+

+        /* We are taking inode_table->lock within inode->lock

+         * as the only other caller which takes inode->lock within

+         * inode_table->lock and cause deadlock is inode_table_destroy.

+         * Hopefully, there can be no fop when inode_table_destroy is

+         * being called. */

+        tmp = GF_CALLOC (1, sizeof (*tmp), gf_nlc_mt_nlc_timer_data_t);

+        if (!tmp)

+                goto out;

+        tmp->inode = inode_ref (inode);

+        tmp->this = this;

+

+        timer = GF_CALLOC (1, sizeof (*timer),

+                           gf_common_mt_tw_timer_list);

+        if (!timer)

+                goto out;

+

+        INIT_LIST_HEAD (&timer->entry);

+        timer->expires = nlc_get_cache_timeout (this);

+        timer->function = nlc_cache_timeout_handler;

+        timer->data = tmp;

+        nlc_ctx->timer = timer;

+        nlc_ctx->timer_data = tmp;

+        gf_tw_add_timer (conf->timer_wheel, timer);

+

+        time (&nlc_ctx->cache_time);

+        gf_msg_trace (this->name, 0, "Registering timer:%p, inode:%p, "

+                      "gfid:%s", timer, inode, uuid_utoa (inode->gfid));

+

+        ret = 0;

+

+out:

+        if (ret < 0) {

+                if (tmp && tmp->inode)

+                        inode_unref (tmp->inode);

+                GF_FREE (tmp);

+                GF_FREE (timer);

+        }

+

+        return ret;

+}

+

+

+int

+__nlc_add_to_lru (xlator_t *this, inode_t *inode, nlc_ctx_t *nlc_ctx)

+{

+        nlc_lru_node_t              *lru_ino   = NULL;

+        uint64_t                    nlc_pe_int = 0;

+        nlc_conf_t                  *conf      = NULL;

+        int                          ret       = -1;

+

+        conf = this->private;

+

+        lru_ino = GF_CALLOC (1, sizeof (*lru_ino), gf_nlc_mt_nlc_lru_node);

+        if (!lru_ino)

+                goto out;

+