features/bitrot: tuanble object signing waiting time value for bitrot

 Currently bitrot using 120 second waiting time for object to be signed
 after all fop's released. This signing waiting time value should be tunable.

 Command for changing the signing waiting time will be
 #gluster volume bitrot <VOLNAME> signing-time <waiting time value in second>

Change-Id: I89f3121564c1bbd0825f60aae6147413a2fbd798
BUG: 1231832
Signed-off-by: Gaurav Kumar Garg <ggarg@redhat.com>
Signed-off-by: Venky Shankar <vshankar@redhat.com>
Reviewed-on: http://review.gluster.org/11105
(cherry picked from commit 554fa0c1315d0b4b78ba35a2d332d7ac0fd07d48)
Reviewed-on: http://review.gluster.org/11235
Tested-by: Gluster Build System <jenkins@build.gluster.com>

5 files changed, 118 insertions, 8 deletions

diff --git a/xlators/features/bit-rot/src/bitd/bit-rot.c b/xlators/features/bit-rot/src/bitd/bit-rot.c
index 81490830570..513cb1a39a7 100644
--- a/xlators/features/bit-rot/src/bitd/bit-rot.c
+++ b/xlators/features/bit-rot/src/bitd/bit-rot.c
@@ -753,8 +753,11 @@ br_initialize_timer (xlator_t *this, br_object_t *object, br_child_t *child,
                 goto out;
         INIT_LIST_HEAD (&timer->entry);
 
+        timer->expires  = (priv->expiry_time >> 1);
+        if (!timer->expires)
+                timer->expires = 1;
+
         timer->data     = object;
-        timer->expires  = priv->expiry_time;
         timer->function = br_add_object_to_queue;
         gf_tw_add_timer (priv->timer_wheel, timer);
 
@@ -1491,12 +1494,28 @@ br_rate_limit_signer (xlator_t *this, int child_count, int numbricks)
 }
 
 static int32_t
+br_signer_handle_options (xlator_t *this, br_private_t *priv, dict_t *options)
+{
+        if (options)
+                GF_OPTION_RECONF ("expiry-time", priv->expiry_time,
+                                  options, uint32, error_return);
+        else
+                GF_OPTION_INIT ("expiry-time", priv->expiry_time,
+                                uint32, error_return);
+
+        return 0;
+
+error_return:
+        return -1;
+}
+
+static int32_t
 br_signer_init (xlator_t *this, br_private_t *priv)
 {
         int32_t ret = 0;
         int numbricks = 0;
 
-        GF_OPTION_INIT ("expiry-time", priv->expiry_time, int32, error_return);
+        GF_OPTION_INIT ("expiry-time", priv->expiry_time, uint32, error_return);
         GF_OPTION_INIT ("brick-count", numbricks, int32, error_return);
 
         ret = br_rate_limit_signer (this, priv->child_count, numbricks);
@@ -1581,6 +1600,8 @@ init (xlator_t *this)
 
         if (!priv->iamscrubber) {
                 ret = br_signer_init (this, priv);
+                if (!ret)
+                        ret = br_signer_handle_options (this, priv, NULL);
         } else {
                 ret = br_scrubber_init (this, priv);
                 if (!ret)
@@ -1651,8 +1672,12 @@ reconfigure (xlator_t *this, dict_t *options)
 
         priv = this->private;
 
-        if (!priv->iamscrubber)
+        if (!priv->iamscrubber) {
+                ret = br_signer_handle_options (this, priv, options);
+                if (ret)
+                        goto err;
                 return 0;
+        }
 
         ret = br_scrubber_handle_options (this, priv, options);
         if (ret)
@@ -1700,10 +1725,8 @@ struct xlator_cbks cbks;
 struct volume_options options[] = {
         { .key = {"expiry-time"},
           .type = GF_OPTION_TYPE_INT,
-          /* Let the default timer be half the value of the wait time for
-           * sining (which is 120 as of now) */
-          .default_value = "60",
-          .description = "default time duration for which an object waits "
+          .default_value = SIGNING_TIMEOUT,
+          .description = "Waiting time for an object on which it waits "
                          "before it is signed",
         },
         { .key = {"brick-count"},
diff --git a/xlators/features/bit-rot/src/bitd/bit-rot.h b/xlators/features/bit-rot/src/bitd/bit-rot.h
index 40e02ebf378..562f17e12bc 100644
--- a/xlators/features/bit-rot/src/bitd/bit-rot.h
+++ b/xlators/features/bit-rot/src/bitd/bit-rot.h
@@ -162,7 +162,7 @@ struct br_private {
                                              and ready to be picked up for
                                              signing and the workers which sign
                                              the objects */
-        int32_t expiry_time;              /* objects "wait" time */
+        uint32_t expiry_time;              /* objects "wait" time */
 
         br_tbf_t *tbf;                    /* token bucket filter */
 
diff --git a/xlators/mgmt/glusterd/src/glusterd-bitrot.c b/xlators/mgmt/glusterd/src/glusterd-bitrot.c
index 08976cf6fb3..758a46b3834 100644
--- a/xlators/mgmt/glusterd/src/glusterd-bitrot.c
+++ b/xlators/mgmt/glusterd/src/glusterd-bitrot.c
@@ -37,6 +37,7 @@ const char *gd_bitrot_op_list[GF_BITROT_OPTION_TYPE_MAX] = {
         [GF_BITROT_OPTION_TYPE_SCRUB_THROTTLE]  = "scrub-throttle",
         [GF_BITROT_OPTION_TYPE_SCRUB_FREQ]      = "scrub-frequency",
         [GF_BITROT_OPTION_TYPE_SCRUB]           = "scrub",
+        [GF_BITROT_OPTION_TYPE_EXPIRY_TIME]     = "expiry-time",
 };
 
 int
@@ -248,6 +249,44 @@ out:
 }
 
 static int
+glusterd_bitrot_expiry_time (glusterd_volinfo_t *volinfo, dict_t *dict,
+                             char *key, char **op_errstr)
+{
+        int32_t        ret                  = -1;
+        uint32_t       expiry_time          = 0;
+        xlator_t       *this                = NULL;
+        char           dkey[1024]           = {0,};
+
+        this = THIS;
+        GF_ASSERT (this);
+
+        ret = dict_get_uint32 (dict, "expiry-time", &expiry_time);
+        if (ret) {
+                gf_log (this->name, GF_LOG_ERROR, "Unable to get bitrot expiry"
+                        " timer value.");
+                goto out;
+        }
+
+        snprintf (dkey, sizeof (dkey), "%d", expiry_time);
+
+        ret = dict_set_dynstr_with_alloc (volinfo->dict, key, dkey);
+        if (ret) {
+                gf_log (this->name, GF_LOG_ERROR, "Failed to set option %s",
+                        key);
+                goto out;
+        }
+
+        ret = glusterd_bitdsvc_reconfigure ();
+        if (ret) {
+                gf_log (this->name, GF_LOG_ERROR, "Failed to reconfigure bitrot"
+                         "services");
+                goto out;
+        }
+out:
+        return ret;
+}
+
+static int
 glusterd_bitrot_enable (glusterd_volinfo_t *volinfo, char **op_errstr)
 {
         int32_t         ret             = -1;
@@ -476,6 +515,14 @@ glusterd_op_bitrot (dict_t *dict, char **op_errstr, dict_t *rsp_dict)
                         goto out;
                 break;
 
+        case GF_BITROT_OPTION_TYPE_EXPIRY_TIME:
+                ret = glusterd_bitrot_expiry_time (volinfo, dict,
+                                                   "features.expiry-time",
+                                                   op_errstr);
+                if (ret)
+                        goto out;
+                break;
+
         default:
                 gf_asprintf (op_errstr, "Bitrot command failed. Invalid "
                              "opcode");
diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.c b/xlators/mgmt/glusterd/src/glusterd-volgen.c
index 9c09c78f79e..a79e1294dba 100644
--- a/xlators/mgmt/glusterd/src/glusterd-volgen.c
+++ b/xlators/mgmt/glusterd/src/glusterd-volgen.c
@@ -3743,6 +3743,33 @@ gd_get_matching_option (char **options, char *option)
 }
 
 static int
+bitrot_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme,
+                       void *param)
+{
+        xlator_t           *xl                 = NULL;
+        char               *bitrot_option      = NULL;
+        int                 ret                = 0;
+        glusterd_volinfo_t *volinfo            = NULL;
+
+        volinfo = param;
+
+        xl = first_of (graph);
+
+        if (!strcmp (vme->option, "expiry-time")) {
+                ret = gf_asprintf (&bitrot_option, "expiry-time");
+                if (ret != -1) {
+                        ret = xlator_set_option (xl, bitrot_option, vme->value);
+                        GF_FREE (bitrot_option);
+                }
+
+                if (ret)
+                        return -1;
+        }
+
+        return ret;
+}
+
+static int
 scrubber_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme,
                        void *param)
 {
@@ -4981,6 +5008,12 @@ build_bitd_volume_graph (volgen_graph_t *graph,
                 goto out;
         }
 
+        ret = volgen_graph_set_options_generic (&cgraph, set_dict,
+                                                volinfo,
+                                                bitrot_option_handler);
+        if (ret)
+                goto out;
+
         ret = volgen_graph_merge_sub (graph, &cgraph, clusters);
         if (ret)
                 goto out;
diff --git a/xlators/mgmt/glusterd/src/glusterd-volume-set.c b/xlators/mgmt/glusterd/src/glusterd-volume-set.c
index 5c13abd1861..d979cc31dd3 100644
--- a/xlators/mgmt/glusterd/src/glusterd-volume-set.c
+++ b/xlators/mgmt/glusterd/src/glusterd-volume-set.c
@@ -1940,6 +1940,13 @@ struct volopt_map_entry glusterd_volopt_map[] = {
           .flags      = OPT_FLAG_FORCE,
           .type       = NO_DOC,
         },
+        { .key        = "features.expiry-time",
+          .voltype    = "features/bitrot",
+          .value      = SIGNING_TIMEOUT,
+          .option     = "expiry-time",
+          .op_version = GD_OP_VERSION_3_7_0,
+          .type       = NO_DOC,
+        },
         /* Upcall translator options */
         { .key         = "features.cache-invalidation",
           .voltype     = "features/upcall",