diff options
24 files changed, 1608 insertions, 44 deletions
diff --git a/cli/src/cli-cmd-parser.c b/cli/src/cli-cmd-parser.c index daec9c8d6..479df9386 100644 --- a/cli/src/cli-cmd-parser.c +++ b/cli/src/cli-cmd-parser.c @@ -322,12 +322,16 @@ cli_cmd_volume_set_parse (const char **words, int wordcount, dict_t **options) if (ret) goto out; - for (i = 3; i < wordcount; i++) { - key = strtok ((char *)words[i], "="); - value = strtok (NULL, "="); - - GF_ASSERT (key); - GF_ASSERT (value); + for (i = 3; i < wordcount; i+=2) { + + key = (char *) words[i]; + value = (char *) words[i+1]; + + if ( !key || !value) { + ret = -1; + cli_out ("Usage: volume set <VOLNAME> <KEY> <VALUE>"); + goto out; + } count++; diff --git a/cli/src/cli-cmd-volume.c b/cli/src/cli-cmd-volume.c index b8a5df6d6..fc7fda9df 100644 --- a/cli/src/cli-cmd-volume.c +++ b/cli/src/cli-cmd-volume.c @@ -71,6 +71,11 @@ cli_cmd_volume_info_usage () cli_out ("Usage: volume info [all|<VOLNAME>]"); } +void +cli_cmd_volume_set_usage () +{ + cli_out ("Usage: volume set <VOLNAME> <KEY> <VALUE>"); +} int cli_cmd_volume_info_cbk (struct cli_state *state, struct cli_cmd_word *word, const char **words, int wordcount) @@ -424,8 +429,35 @@ int cli_cmd_volume_set_cbk (struct cli_state *state, struct cli_cmd_word *word, const char **words, int wordcount) { - cli_cmd_broadcast_response (0); - return 0; + + int ret = -1; + rpc_clnt_procedure_t *proc = NULL; + call_frame_t *frame = NULL; + dict_t *options = NULL; + + proc = &cli_rpc_prog->proctable[GF1_CLI_SET_VOLUME]; + + frame = create_frame (THIS, THIS->ctx->pool); + if (!frame) + goto out; + + ret = cli_cmd_volume_set_parse (words, wordcount, &options); + + if (ret) { + cli_cmd_volume_set_usage (); + goto out; + } + + if (proc->fn) { + ret = proc->fn (frame, THIS, options); + } + +out: + if (options) + dict_unref (options); + + return ret; + } void diff --git a/glusterfsd/src/glusterfsd-mgmt.c b/glusterfsd/src/glusterfsd-mgmt.c index c674533e4..6e3cda951 100644 --- a/glusterfsd/src/glusterfsd-mgmt.c +++ b/glusterfsd/src/glusterfsd-mgmt.c @@ -161,6 +161,152 @@ out: static char oldvolfile[131072]; static int oldvollen = 0; +static int +xlator_equal_rec (xlator_t *xl1, xlator_t *xl2) +{ + xlator_list_t *trav1 = NULL; + xlator_list_t *trav2 = NULL; + int ret = 0; + + if (xl1 == NULL || xl2 == NULL) { + gf_log ("xlator", GF_LOG_DEBUG, "invalid argument"); + return -1; + } + + trav1 = xl1->children; + trav2 = xl2->children; + + while (trav1 && trav2) { + ret = xlator_equal_rec (trav1->xlator, trav2->xlator); + if (ret) { + gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, + "xlators children not equal"); + goto out; + } + + trav1 = trav1->next; + trav2 = trav2->next; + } + + if (trav1 || trav2) { + ret = -1; + goto out; + } + + if (strcmp (xl1->name, xl2->name)) { + ret = -1; + goto out; + } +out : + return ret; +} + +static gf_boolean_t +is_graph_topology_equal (glusterfs_graph_t *graph1, + glusterfs_graph_t *graph2) +{ + xlator_t *trav1 = NULL; + xlator_t *trav2 = NULL; + gf_boolean_t ret = _gf_true; + + trav1 = graph1->first; + trav2 = graph2->first; + + ret = xlator_equal_rec (trav1, trav2); + + if (ret) { + gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, + "graphs are not equal"); + ret = _gf_false; + goto out; + } + + ret = _gf_true; + gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, + "graphs are equal"); + +out: + return ret; +} + +static int +glusterfs_volfile_reconfigure (FILE *newvolfile_fp) +{ + glusterfs_graph_t *oldvolfile_graph = NULL; + glusterfs_graph_t *newvolfile_graph = NULL; + FILE *oldvolfile_fp = NULL; + glusterfs_ctx_t *ctx = NULL; + + int ret = 0; + + oldvolfile_fp = tmpfile (); + if (!oldvolfile_fp) + goto out; + + if (!oldvollen) + goto out; + + fwrite (oldvolfile, oldvollen, 1, oldvolfile_fp); + fflush (oldvolfile_fp); + + + oldvolfile_graph = glusterfs_graph_construct (oldvolfile_fp); + if (!oldvolfile_graph) { + ret = -1; + goto out; + } + + newvolfile_graph = glusterfs_graph_construct (newvolfile_fp); + if (!oldvolfile_graph) { + ret = -1; + goto out; + } + + if (!is_graph_topology_equal (oldvolfile_graph, + newvolfile_graph)) { + + gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, + "Graph topology not equal"); + ret = 0; + goto out; + } + + gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, + "Only options have changed in the new " + "graph"); + + ctx = glusterfs_ctx_get (); + + if (!ctx) { + gf_log ("glusterfsd-mgmt", GF_LOG_ERROR, + "glusterfs_ctx_get() returned NULL"); + ret = -1; + goto out; + } + + oldvolfile_graph = ctx->active; + + if (!oldvolfile_graph) { + gf_log ("glusterfsd-mgmt", GF_LOG_ERROR, + "glsuterfs_ctx->active is NULL"); + ret = -1; + goto out; + } + + + + ret = glusterfs_graph_reconfigure (oldvolfile_graph, + newvolfile_graph); + if (ret) { + gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, + "Could not reconfigure new options in old " + "graph"); + } + +out: + return ret; +} + int mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count, void *myframe) @@ -209,6 +355,17 @@ mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count, fwrite (rsp.spec, size, 1, tmpfp); fflush (tmpfp); + /* Check if only options have changed. No need to reload the + volfile if topology hasn't changed. + */ + + ret = glusterfs_volfile_reconfigure (tmpfp); + if (ret) { + gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, + "No need to re-load volfile"); + goto out; + } + ret = glusterfs_process_volfp (ctx, tmpfp); if (ret) goto out; diff --git a/libglusterfs/src/glusterfs.h b/libglusterfs/src/glusterfs.h index 1d0369c4d..669bbfaeb 100644 --- a/libglusterfs/src/glusterfs.h +++ b/libglusterfs/src/glusterfs.h @@ -310,4 +310,6 @@ int glusterfs_graph_destroy (glusterfs_graph_t *graph); int glusterfs_graph_activate (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx); glusterfs_graph_t *glusterfs_graph_construct (FILE *fp); glusterfs_graph_t *glusterfs_graph_new (); +int glusterfs_graph_reconfigure (glusterfs_graph_t *oldgraph, + glusterfs_graph_t *newgraph); #endif /* _GLUSTERFS_H */ diff --git a/libglusterfs/src/graph.c b/libglusterfs/src/graph.c index 4adb04a39..c44fa44ad 100644 --- a/libglusterfs/src/graph.c +++ b/libglusterfs/src/graph.c @@ -495,6 +495,24 @@ glusterfs_graph_activate (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx) return 0; } +int +glusterfs_graph_reconfigure (glusterfs_graph_t *oldgraph, + glusterfs_graph_t *newgraph) +{ + xlator_t *old_xl = NULL; + xlator_t *new_xl = NULL; + int ret = 0; + + GF_ASSERT (oldgraph); + GF_ASSERT (newgraph); + + old_xl = oldgraph->first; + new_xl = newgraph->first; + + ret = xlator_tree_reconfigure (old_xl, new_xl); + + return ret; +} int glusterfs_graph_destroy (glusterfs_graph_t *graph) diff --git a/libglusterfs/src/xlator.c b/libglusterfs/src/xlator.c index 2074c143c..393088019 100644 --- a/libglusterfs/src/xlator.c +++ b/libglusterfs/src/xlator.c @@ -749,6 +749,12 @@ xlator_set_type (xlator_t *xl, dlerror ()); } + if (!(xl->reconfigure = dlsym (handle, "reconfigure"))) { + gf_log ("xlator", GF_LOG_ERROR, + "dlsym(reconfigure) on %s -- neglecting", + dlerror()); + } + INIT_LIST_HEAD (&xl->volume_options); vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t), @@ -910,6 +916,35 @@ xlator_fini_rec (xlator_t *xl) } } +static void +xlator_reconfigure_rec (xlator_t *old_xl, xlator_t *new_xl) +{ + xlator_list_t *trav1 = NULL; + xlator_list_t *trav2 = NULL; + + if (old_xl == NULL || new_xl == NULL) { + gf_log ("xlator", GF_LOG_DEBUG, "invalid argument"); + return; + } + + trav1 = old_xl->children; + trav2 = new_xl->children; + + while (trav1 && trav2) { + xlator_reconfigure_rec (trav1->xlator, trav2->xlator); + + gf_log (trav1->xlator->name, GF_LOG_DEBUG, "reconfigured"); + + trav1 = trav1->next; + trav2 = trav2->next; + } + + if (old_xl->reconfigure) + old_xl->reconfigure (old_xl, new_xl->options); + else + gf_log (old_xl->name, GF_LOG_DEBUG, "No reconfigure() found"); + +} int xlator_notify (xlator_t *xl, int event, void *data, ...) @@ -976,6 +1011,23 @@ xlator_tree_fini (xlator_t *xl) xlator_fini_rec (top); } +int +xlator_tree_reconfigure (xlator_t *old_xl, xlator_t *new_xl) +{ + xlator_t *new_top = NULL; + xlator_t *old_top = NULL; + + GF_ASSERT (old_xl); + GF_ASSERT (new_xl); + + old_top = old_xl; + new_top = new_xl; + + xlator_reconfigure_rec (old_top, new_top); + + return 0; +} + int xlator_tree_free (xlator_t *tree) diff --git a/libglusterfs/src/xlator.h b/libglusterfs/src/xlator.h index 2aa9b372b..84ad990d4 100644 --- a/libglusterfs/src/xlator.h +++ b/libglusterfs/src/xlator.h @@ -806,6 +806,7 @@ struct _xlator { void (*fini) (xlator_t *this); int32_t (*init) (xlator_t *this); + int32_t (*reconfigure) (xlator_t *this, dict_t *options); int32_t (*mem_acct_init) (xlator_t *this); event_notify_fn_t notify; @@ -854,6 +855,7 @@ int loc_copy (loc_t *dst, loc_t *src); #define loc_dup(src, dst) loc_copy(dst, src) void loc_wipe (loc_t *loc); int xlator_mem_acct_init (xlator_t *xl, int num_types); +int xlator_tree_reconfigure (xlator_t *old_xl, xlator_t *new_xl); #define GF_STAT_PRINT_FMT_STR "%"PRIx64",%"PRIx64",%"PRIx32",%"PRIx32",%"PRIx32",%"PRIx32",%"PRIx64",%"PRIx64",%"PRIx32",%"PRIx64",%"PRIx32",%"PRIx32",%"PRIx32",%"PRIx32",%"PRIx32",%"PRIx32"\n" diff --git a/xlators/cluster/afr/src/afr.c b/xlators/cluster/afr/src/afr.c index e1154f9d1..a5906550d 100644 --- a/xlators/cluster/afr/src/afr.c +++ b/xlators/cluster/afr/src/afr.c @@ -61,6 +61,231 @@ mem_acct_init (xlator_t *this) } +int +reconfigure (xlator_t *this, dict_t *options) +{ + + gf_boolean_t metadata_self_heal; /* on/off */ + gf_boolean_t entry_self_heal; + gf_boolean_t data_self_heal; + gf_boolean_t data_change_log; /* on/off */ + gf_boolean_t metadata_change_log; /* on/off */ + gf_boolean_t entry_change_log; /* on/off */ + gf_boolean_t strict_readdir; + + afr_private_t * priv = NULL; + xlator_list_t * trav = NULL; + + char * read_subvol = NULL; + char * self_heal = NULL; + char * change_log = NULL; + char * str_readdir = NULL; + + int32_t background_count = 0; + int32_t window_size = 0; + + int read_ret = -1; + int dict_ret = -1; + int flag = 1; + int ret = 0; + int temp_ret = -1; + + priv = this->private; + + dict_ret = dict_get_int32 (options, "background-self-heal-count", + &background_count); + if (dict_ret == 0) { + gf_log (this->name, GF_LOG_DEBUG, + "Reconfiguring background self-heal count to %d", + background_count); + + priv->background_self_heal_count = background_count; + } + + dict_ret = dict_get_str (options, "metadata-self-heal", + &self_heal); + if (dict_ret == 0) { + temp_ret = gf_string2boolean (self_heal, &metadata_self_heal); + if (temp_ret < 0) { + gf_log (this->name, GF_LOG_WARNING, + "Reconfiguration Invalid 'option metadata" + "-self-heal %s'. Defaulting to old value.", + self_heal); + ret = -1; + goto out; + } + + priv->metadata_self_heal = metadata_self_heal; + gf_log (this->name, GF_LOG_DEBUG, + "Reconfiguring 'option metadata" + "-self-heal %s'.", + self_heal); + } + + dict_ret = dict_get_str (options, "data-self-heal", + &self_heal); + if (dict_ret == 0) { + temp_ret = gf_string2boolean (self_heal, &data_self_heal); + if (temp_ret < 0) { + gf_log (this->name, GF_LOG_WARNING, + "Reconfiguration Invalid 'option data" + "-self-heal %s'. Defaulting to old value.", + self_heal); + ret = -1; + goto out; + } + + priv->data_self_heal = data_self_heal; + gf_log (this->name, GF_LOG_DEBUG, + "Reconfiguring 'option data" + "-self-heal %s'.", self_heal); + } + + dict_ret = dict_get_str (options, "entry-self-heal", + &self_heal); + if (dict_ret == 0) { + temp_ret = gf_string2boolean (self_heal, &entry_self_heal); + if (temp_ret < 0) { + gf_log (this->name, GF_LOG_WARNING, + "Reconfiguration Invalid 'option data" + "-self-heal %s'. Defaulting to old value.", + self_heal); + ret = -1; + goto out; + } + + priv->entry_self_heal = entry_self_heal; + gf_log (this->name, GF_LOG_DEBUG, + "Reconfiguring 'option entry" + "-self-heal %s'.", self_heal); + } + + + dict_ret = dict_get_str (options, "strict-readdir", + &str_readdir); + if (dict_ret == 0) { + temp_ret = gf_string2boolean (str_readdir, &strict_readdir); + if (temp_ret < 0) { + gf_log (this->name, GF_LOG_WARNING, + "Invalid 'option strict-readdir %s'. " + "Defaulting to old value.", + str_readdir); + ret = -1; + goto out; + } + + priv->strict_readdir = strict_readdir; + gf_log (this->name, GF_LOG_DEBUG, + "Reconfiguring 'option strict" + "-readdir %s'.", str_readdir); + } + + dict_ret = dict_get_int32 (options, "data-self-heal-window-size", + &window_size); + if (dict_ret == 0) { + gf_log (this->name, GF_LOG_DEBUG, + "Reconfiguring, Setting data self-heal window size to %d", + window_size); + + priv->data_self_heal_window_size = window_size; + } + + dict_ret = dict_get_str (options, "data-change-log", + &change_log); + if (dict_ret == 0) { + temp_ret = gf_string2boolean (change_log, &data_change_log); + if (temp_ret < 0) { + gf_log (this->name, GF_LOG_WARNING, + "Reconfiguration Invalid 'option data-" + "change-log %s'. Defaulting to old value.", + change_log); + ret = -1; + goto out; + } + + priv->data_change_log = data_change_log; + gf_log (this->name, GF_LOG_DEBUG, + "Reconfiguring 'option data-" + "change-log %s'.", change_log); + } + + dict_ret = dict_get_str (options, "metadata-change-log", + &change_log); + if (dict_ret == 0) { + temp_ret = gf_string2boolean (change_log, + &metadata_change_log); + if (temp_ret < 0) { + gf_log (this->name, GF_LOG_WARNING, + "Invalid 'option metadata-change-log %s'. " + "Defaulting to metadata-change-log as 'off'.", + change_log); + ret = -1; + goto out; + } + + priv->metadata_change_log = metadata_change_log; + gf_log (this->name, GF_LOG_DEBUG, + "Reconfiguring 'option metadata-" + "change-log %s'.", change_log); + } + + dict_ret = dict_get_str (options, "entry-change-log", + &change_log); + if (dict_ret == 0) { + temp_ret = gf_string2boolean (change_log, &entry_change_log); + if (temp_ret < 0) { + gf_log (this->name, GF_LOG_WARNING, + "Invalid 'option entry-change-log %s'. " + "Defaulting to entry-change-log as 'on'.", + change_log); + ret = -1; + goto out; + } + + priv->entry_change_log = entry_change_log; + gf_log (this->name, GF_LOG_DEBUG, + "Reconfiguring 'option entry-" + "change-log %s'.", change_log); + } + + read_ret = dict_get_str (options, "read-subvolume", &read_subvol); + + if (read_ret == -1) + goto next;// No need to traverse, hence set the next option + + trav = this->children; + flag = 0; + while (trav) { + if (!read_ret && !strcmp (read_subvol, trav->xlator->name)) { + gf_log (this->name, GF_LOG_DEBUG, + "Subvolume '%s' specified as read child.", + trav->xlator->name); + + flag = 1; + ret = -1; + goto out; + } + + + trav = trav->next; + } + + if (flag == 0 ) { + + gf_log (this->name, GF_LOG_ERROR, + "Invalid 'option read-subvolume %s', no such subvolume" + , read_subvol); + ret = -1; + goto out; + } + +next: +out: + return ret; + +} + + static const char *favorite_child_warning_str = "You have specified subvolume '%s' " "as the 'favorite child'. This means that if a discrepancy in the content " "or attributes (ownership, permission, etc.) of a file is detected among " diff --git a/xlators/cluster/dht/src/dht.c b/xlators/cluster/dht/src/dht.c index c926a1cf4..bd0258eae 100644 --- a/xlators/cluster/dht/src/dht.c +++ b/xlators/cluster/dht/src/dht.c @@ -252,6 +252,68 @@ mem_acct_init (xlator_t *this) } int +reconfigure (xlator_t *this, dict_t *options) +{ + dht_conf_t *conf = NULL; + char *temp_str = NULL; + gf_boolean_t search_unhashed; + uint32_t temp_free_disk = 0; + int ret = 0; + + + conf = this->private; + + if (dict_get_str (options, "lookup-unhashed", &temp_str) == 0) { + /* If option is not "auto", other options _should_ be boolean*/ + if (strcasecmp (temp_str, "auto")) { + if (!gf_string2boolean (temp_str, &search_unhashed)) { + gf_log(this->name, GF_LOG_DEBUG, "Reconfigure:" + " lookup-unahashed reconfigured (%s)", + temp_str); + conf->search_unhashed = search_unhashed; + } + else { + gf_log(this->name, GF_LOG_ERROR, "Reconfigure:" + " lookup-unahashed should be boolean," + " not (%s), defaulting to (%d)", + temp_str, conf->search_unhashed); + //return -1; + ret = -1; + goto out; + } + + } + else { + gf_log(this->name, GF_LOG_DEBUG, "Reconfigure:" + " lookup-unahashed reconfigured auto "); + conf->search_unhashed = GF_DHT_LOOKUP_UNHASHED_AUTO; + } + } + + if (dict_get_str (options, "min-free-disk", &temp_str) == 0) { + if (gf_string2percent (temp_str, &temp_free_disk) == 0) { + if (temp_free_disk > 100) { + gf_string2bytesize (temp_str, + &conf->min_free_disk); + conf->disk_unit = 'b'; + } else { + conf->min_free_disk = (uint64_t)temp_free_disk; + } + } else { + gf_string2bytesize (temp_str, &conf->min_free_disk); + conf->disk_unit = 'b'; + } + + gf_log(this->name, GF_LOG_DEBUG, "Reconfigure:" + " min-free-disk reconfigured to ", + temp_str); + } + +out: + return ret; +} + +int init (xlator_t *this) { dht_conf_t *conf = NULL; diff --git a/xlators/cluster/stripe/src/stripe.c b/xlators/cluster/stripe/src/stripe.c index a9f620389..00c888f68 100644 --- a/xlators/cluster/stripe/src/stripe.c +++ b/xlators/cluster/stripe/src/stripe.c @@ -3674,8 +3674,7 @@ set_stripe_block_size (xlator_t *this, stripe_private_t *priv, char *data) stripe_str = strtok_r (data, ",", &tmp_str); while (stripe_str) { dup_str = gf_strdup (stripe_str); - stripe_opt = GF_CALLOC (1, sizeof (struct stripe_options), - gf_stripe_mt_stripe_options); + stripe_opt = CALLOC (1, sizeof (struct stripe_options)); if (!stripe_opt) { GF_FREE (dup_str); goto out; @@ -3735,6 +3734,37 @@ out: return ret; } +int +reconfigure (xlator_t *this, dict_t *options) +{ + + stripe_private_t *priv = NULL; + data_t *data = NULL; + int ret = 0; + + + priv = this->private; + + data = dict_get (options, "block-size"); + if (data) { + gf_log (this->name, GF_LOG_TRACE,"Reconfiguring Stripe" + " Block-size"); + ret = set_stripe_block_size (this, priv, data->data); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, + "Reconfigue: Block-Size reconfiguration failed"); + ret = -1; + goto out; + } + gf_log (this->name, GF_LOG_TRACE, + "Reconfigue: Block-Size reconfigured Successfully"); + } + +out: + return ret; + +} + /** * init - This function is called when xlator-graph gets initialized. * The option given in volfiles are parsed here. @@ -3873,7 +3903,7 @@ fini (xlator_t *this) while (trav) { prev = trav; trav = trav->next; - GF_FREE (prev); + FREE (prev); } LOCK_DESTROY (&priv->lock); GF_FREE (priv); diff --git a/xlators/features/quota/src/quota.c b/xlators/features/quota/src/quota.c index 4e9b587c2..094b62d4a 100644 --- a/xlators/features/quota/src/quota.c +++ b/xlators/features/quota/src/quota.c @@ -1042,6 +1042,57 @@ mem_acct_init (xlator_t *this) return ret; } +int +reconfigure (xlator_t *this, dict_t *options) +{ + + struct quota_priv *_private = NULL; + uint64_t disk_usage_limit; + uint32_t min_free_disk_limit; + data_t *data = NULL; + int ret = 0; + + _private = this->private; + + data = dict_get (options, "disk-usage-limit"); + if (data) { + if (gf_string2bytesize (data->data, &disk_usage_limit) != 0) { + gf_log (this->name, GF_LOG_ERROR, + "Reconfigure: Invalid number '%s' " + "for disk-usage limit", data->data); + //return -1; + ret = -1; + goto out; + } + _private->disk_usage_limit = disk_usage_limit; + gf_log (this->name, GF_LOG_TRACE, + "Reconfiguring disk-usage-limit %"PRIu64"", + disk_usage_limit); + + } + + + data = dict_get (options, "min-free-disk-limit"); + if (data) { + if (gf_string2percent (data->data, &min_free_disk_limit) != 0){ + gf_log (this->name, GF_LOG_ERROR, + "Reconfigure : Invalid percent '%s' for" + " min-free-disk-limit", data->data); + ret = -1; + goto out; + } + + _private->min_free_disk_limit = min_free_disk_limit; + gf_log (this->name, GF_LOG_TRACE, + "Reconfiguring min-free-disk-limit %d \%", + min_free_disk_limit); + + } +out: + return ret; + +} + int32_t init (xlator_t *this) { @@ -1106,6 +1157,8 @@ init (xlator_t *this) return ret; } + + void fini (xlator_t *this) { diff --git a/xlators/mgmt/glusterd/src/glusterd-handler.c b/xlators/mgmt/glusterd/src/glusterd-handler.c index 2c99a60e2..bc015293f 100644 --- a/xlators/mgmt/glusterd/src/glusterd-handler.c +++ b/xlators/mgmt/glusterd/src/glusterd-handler.c @@ -1641,6 +1641,42 @@ out: } int +glusterd_handle_set_volume (rpcsvc_request_t *req) +{ + int32_t ret = -1; + gf1_cli_set_vol_req cli_req = {0,}; + dict_t *dict = NULL; + + GF_ASSERT (req); + + if (!gf_xdr_to_cli_set_vol_req (req->msg[0], &cli_req)) { + //failed to decode msg; + req->rpc_err = GARBAGE_ARGS; + goto out; + } + + if (cli_req.dict.dict_len) { + /* Unserialize the dictionary */ + dict = dict_new (); + + ret = dict_unserialize (cli_req.dict.dict_val, + cli_req.dict.dict_len, + &dict); + if (ret < 0) { + gf_log ("glusterd", GF_LOG_ERROR, + "failed to " + "unserialize req-buffer to dictionary"); + goto out; + } + } + + ret = glusterd_set_volume (req, dict); + +out: + return ret; +} + +int glusterd_handle_remove_brick (rpcsvc_request_t *req) { int32_t ret = -1; @@ -2970,6 +3006,29 @@ glusterd_replace_brick (rpcsvc_request_t *req, dict_t *dict) } int32_t +glusterd_set_volume (rpcsvc_request_t *req, dict_t *dict) +{ + int32_t ret = -1; + + GF_ASSERT (req); + GF_ASSERT (dict); + + glusterd_op_set_op (GD_OP_SET_VOLUME); + + glusterd_op_set_ctx (GD_OP_SET_VOLUME, dict); + + glusterd_op_set_ctx_free (GD_OP_SET_VOLUME, _gf_true); + + glusterd_op_set_cli_op (GD_MGMT_CLI_SET_VOLUME); + + glusterd_op_set_req (req); + + ret = glusterd_op_txn_begin (); + + return ret; +} + +int32_t glusterd_remove_brick (rpcsvc_request_t *req, dict_t *dict) { int32_t ret = -1; diff --git a/xlators/mgmt/glusterd/src/glusterd-op-sm.c b/xlators/mgmt/glusterd/src/glusterd-op-sm.c index 1497ae4ad..651cb22e0 100644 --- a/xlators/mgmt/glusterd/src/glusterd-op-sm.c +++ b/xlators/mgmt/glusterd/src/glusterd-op-sm.c @@ -118,6 +118,7 @@ glusterd_op_get_len (glusterd_op_t op) case GD_OP_START_BRICK: break; + case GD_OP_SET_VOLUME: case GD_OP_REPLACE_BRICK: case GD_OP_ADD_BRICK: { @@ -125,7 +126,6 @@ glusterd_op_get_len (glusterd_op_t op) ret = dict_serialized_length (dict); return ret; } - case GD_OP_REMOVE_BRICK: { dict_t *dict = glusterd_op_get_ctx (op); @@ -266,6 +266,20 @@ glusterd_op_build_payload (glusterd_op_t op, gd1_mgmt_stage_op_req **req) } break; + case GD_OP_SET_VOLUME: + { + dict_t *dict = NULL; + dict = glusterd_op_get_ctx (op); + GF_ASSERT (dict); + ret = dict_allocate_and_serialize (dict, + &stage_req->buf.buf_val, + (size_t *)&stage_req->buf.buf_len); + if (ret) { + goto out; + } + } + break; + case GD_OP_REMOVE_BRICK: { dict_t *dict = NULL; @@ -996,6 +1010,128 @@ out: } static int +glusterd_op_stage_set_volume (gd1_mgmt_stage_op_req *req) +{ + int ret = 0; + dict_t *dict = NULL; + char *volname = NULL; + gf_boolean_t exists = _gf_false; + char *key = NULL; + char str[100] = {0, }; + int count = 0; + + GF_ASSERT (req); + + dict = dict_new (); + if (!dict) + goto out; + + ret = dict_unserialize (req->buf.buf_val, req->buf.buf_len, &dict); + + if (ret) { + gf_log ("", GF_LOG_ERROR, "Unable to unserialize dict"); + goto out; + } + + ret = dict_get_str (dict, "volname", &volname); + + if (ret) { + gf_log ("", GF_LOG_ERROR, "Unable to get volume name"); + goto out; + } + + exists = glusterd_check_volume_exists (volname); + + if (!exists) { + gf_log ("", GF_LOG_ERROR, "Volume with name: %s " + "does not exist", + volname); + ret = -1; + goto out; + } + + + for ( count = 1; ret != -1 ; count++ ) { + + sprintf (str, "key%d", count); + ret = dict_get_str (dict, str, &key); + + + if (ret) + break; + + exists = glusterd_check_option_exists(key); + + if (!exists) { + gf_log ("", GF_LOG_ERROR, "Option with name: %s " + "does not exist", key); + ret = -1; + goto out; + } + + + } + + if ( count == 1 ) { + gf_log ("", GF_LOG_ERROR, "No options received "); + ret = -1; + goto out; + } + + ret = 0; + +out: + gf_log ("", GF_LOG_DEBUG, "Returning %d", ret); + + return ret; +} + + +char *set_option_list[] = { + "max-file-size", + "min-file-size", + "cache-timeout", + "priority", + "entry-change-log", + "read-subvolume", + "background-self-heal-count", + "metadata-self-heal", + "data-self-heal", + "entry-self-heal", + "strict-readdir", + "data-self-heal-window-size", + "data-change-log", + "metadata-change-log", + "frame-timeout", + "ping-timeout", + "cache-size", + "disk-usage-limit", + "min-free-disk-limit", + "block-size", + "inode-lru-limit", + "thread-count" , + "lookup-unhashed", + "min-free-disk" +}; + + +gf_boolean_t +glusterd_check_option_exists(char *optstring) +{ + //struct set_option_list *list; + char **list = NULL; + + + for (list = &set_option_list[0]; *list ;list++) + if (!strcmp (optstring, *list)) + return _gf_true; + + + return _gf_false; + +} + +static int glusterd_op_stage_remove_brick (gd1_mgmt_stage_op_req *req) { int ret = 0; @@ -2231,6 +2367,106 @@ out: } static int +glusterd_op_set_volume (gd1_mgmt_stage_op_req *req) +{ + int ret = 0; + dict_t *dict = NULL; + glusterd_volinfo_t *volinfo = NULL; + char *volname = NULL; + xlator_t *this = NULL; + glusterd_conf_t *priv = NULL; + int count = 1; + char *key = NULL; + char *value = NULL; + char str[50] = {0, }; + GF_ASSERT (req); + + this = THIS; + GF_ASSERT (this); + + priv = this->private; + GF_ASSERT (priv); + + dict = dict_new (); + if (!dict) + goto out; + + + ret = dict_unserialize (req->buf.buf_val, req->buf.buf_len, &dict); + if (ret) { + gf_log ("", GF_LOG_ERROR, "Unable to unserialize dict"); + goto out; + } + + ret = dict_get_str (dict, "volname", &volname); + + if (ret) { + gf_log ("", GF_LOG_ERROR, "Unable to get volume name"); + goto out; + } + + ret = glusterd_volinfo_find (volname, &volinfo); + if (ret) { + gf_log ("", GF_LOG_ERROR, "Unable to allocate memory"); + goto out; + } + + for ( count = 1; ret != -1 ; count++ ) { + + sprintf (str, "key%d", count); + ret = dict_get_str (dict, str, &key); + + + if (ret) + break; + + sprintf (str, "value%d", count); + ret = dict_get_str (dict, str, &value); + + if (ret) { + gf_log ("", GF_LOG_ERROR, "invalid key,value pair" + "in 'volume set'"); + ret = -1; + goto out; + } + + ret = set_xlator_option (volinfo->dict, key, value); + + if (ret) { + gf_log ("", GF_LOG_ERROR, "Unable to set the options" + "in 'volume set'"); + ret = -1; + goto out; + } + } + + if ( count == 1 ) { + gf_log ("", GF_LOG_ERROR, "No options received "); + ret = -1; + goto out; + } + + ret = glusterd_create_volfiles (volinfo); + + if (ret) { + gf_log ("", GF_LOG_ERROR, "Unable to create volfile for" + " 'volume set'"); + ret = -1; + goto out; + } + + + + + gf_log ("", GF_LOG_DEBUG, "Received set volume command"); + + ret = 0; + +out: + return ret; +} + +static int glusterd_op_remove_brick (gd1_mgmt_stage_op_req *req) { int ret = 0; @@ -3208,6 +3444,17 @@ glusterd_op_send_cli_response (int32_t op, int32_t op_ret, break; } + case GD_MGMT_CLI_SET_VOLUME: + { + gf1_cli_set_vol_rsp rsp = {0,}; + rsp.op_ret = op_ret; + rsp.op_errno = op_errno; + rsp.volname = ""; + cli_rsp = &rsp; + sfunc = gf_xdr_serialize_cli_set_vol_rsp; + break; + } + case GD_MGMT_CLI_LOG_FILENAME: { gf1_cli_log_filename_rsp rsp = {0,}; @@ -3460,6 +3707,10 @@ glusterd_op_stage_validate (gd1_mgmt_stage_op_req *req, char **op_errstr) ret = glusterd_op_stage_replace_brick (req); break; + case GD_OP_SET_VOLUME: + ret = glusterd_op_stage_set_volume (req); + break; + case GD_OP_REMOVE_BRICK: ret = glusterd_op_stage_remove_brick (req); break; @@ -3515,6 +3766,10 @@ glusterd_op_commit_perform (gd1_mgmt_stage_op_req *req, char **op_errstr) ret = glusterd_op_replace_brick (req); break; + case GD_OP_SET_VOLUME: + ret = glusterd_op_set_volume (req); + break; + case GD_OP_REMOVE_BRICK: ret = glusterd_op_remove_brick (req); break; diff --git a/xlators/mgmt/glusterd/src/glusterd-op-sm.h b/xlators/mgmt/glusterd/src/glusterd-op-sm.h index 66435c8d2..e14f00759 100644 --- a/xlators/mgmt/glusterd/src/glusterd-op-sm.h +++ b/xlators/mgmt/glusterd/src/glusterd-op-sm.h @@ -96,6 +96,7 @@ typedef enum glusterd_op_ { GD_OP_ADD_BRICK, GD_OP_REMOVE_BRICK, GD_OP_REPLACE_BRICK, + GD_OP_SET_VOLUME, GD_OP_SYNC_VOLUME, GD_OP_LOG_FILENAME, GD_OP_LOG_LOCATE, @@ -237,6 +238,9 @@ glusterd_op_clear_ctx_free (glusterd_op_t op); gf_boolean_t glusterd_op_get_ctx_free (glusterd_op_t op); +gf_boolean_t +glusterd_check_option_exists(char *optstring); + int set_xlator_option (dict_t *dict, char *key, char *value); #endif diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.c b/xlators/mgmt/glusterd/src/glusterd-utils.c index 30ba51416..017ab6873 100644 --- a/xlators/mgmt/glusterd/src/glusterd-utils.c +++ b/xlators/mgmt/glusterd/src/glusterd-utils.c @@ -886,6 +886,8 @@ glusterd_volume_start_glusterfs (glusterd_volinfo_t *volinfo, "--brick-port %d -l %s", GFS_PREFIX, volinfo->volname, port, volfile, pidfile, brickinfo->path, port, brickinfo->logfile); + + gf_log ("",GF_LOG_DEBUG,"Starting GlusterFS Command Executed: \n %s \n", cmd_str); ret = gf_system (cmd_str); if (ret == 0) { diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.c b/xlators/mgmt/glusterd/src/glusterd-volgen.c index 3998a0190..28b814500 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volgen.c +++ b/xlators/mgmt/glusterd/src/glusterd-volgen.c @@ -468,13 +468,18 @@ __write_client_xlator (FILE *file, dict_t *dict, char *opt_transtype = NULL; char *opt_nodelay = NULL; int ret = 0; - + char *ping = NULL; + char *frame = NULL; + char ping_timeout[100] = {0, }; + char frame_timeout[100] = {0, }; const char *client_str = "volume %s-%s-%d\n" " type protocol/client\n" " option transport-type %s\n" " option remote-host %s\n" " option transport.socket.nodelay %s\n" + "%s" //for frame-timeout + "%s" //for ping-timeout " option remote-subvolume %s\n" "end-volume\n\n"; @@ -495,6 +500,26 @@ __write_client_xlator (FILE *file, dict_t *dict, goto out; } + if (dict_get (dict, "frame-timeout")) { + ret = dict_get_str (dict, "frame-timeout", &frame); + if (ret) { + goto out; + } + gf_log ("", GF_LOG_DEBUG, "Reconfiguring frame-timeout %s", + frame); + sprintf(frame_timeout, " option frame-timeout %s\n",frame); + } + + if (dict_get (dict, "ping-timeout")) { + ret = dict_get_str (dict, "ping-timeout", &ping); + if (ret) { + goto out; + } + gf_log ("", GF_LOG_DEBUG, "Reconfiguring ping-timeout %s", + ping); + sprintf(ping_timeout, " option ping-timeout %s\n",ping); + } + fprintf (file, client_str, volname, "client", @@ -502,6 +527,8 @@ __write_client_xlator (FILE *file, dict_t *dict, opt_transtype, remote_host, opt_nodelay, + frame_timeout, + ping_timeout, remote_subvol); ret = 0; @@ -608,8 +635,14 @@ __write_iothreads_xlator (FILE *file, dict_t *dict, goto out; } - ret = dict_get_str (dict, VOLGEN_IOT_OPTION_THREADCOUNT, - &opt_threadcount); + if (dict_get (dict, "thread-count")) { + gf_log("", GF_LOG_DEBUG, "Resetting the thread-count value"); + ret = dict_get_str (dict, "thread-count", &opt_threadcount); + } + else + ret = dict_get_str (dict, VOLGEN_IOT_OPTION_THREADCOUNT, + &opt_threadcount); + if (ret) { goto out; } @@ -675,16 +708,19 @@ static int __write_server_xlator (FILE *file, dict_t *dict, char *subvolume) { - char *volname = NULL; - char *opt_transtype = NULL; - char *opt_nodelay = NULL; - int ret = -1; + char *volname = NULL; + char *opt_transtype = NULL; + char *opt_nodelay = NULL; + int ret = -1; + char *lru_count = NULL; + char inode_lru_count[100] = {0,}; const char *server_str = "volume %s-%s\n" " type protocol/server\n" " option transport-type %s\n" " option auth.addr.%s.allow *\n" " option transport.socket.nodelay %s\n" + "%s"//for inode-lru-limit " subvolumes %s\n" "end-volume\n\n"; @@ -705,12 +741,25 @@ __write_server_xlator (FILE *file, dict_t *dict, goto out; } + if (dict_get (dict, "inode-lru-limit")) { + ret = dict_get_str (dict, "inode-lru-limit", &lru_count); + if (ret) { + goto out; + } + gf_log ("", GF_LOG_DEBUG, "Reconfiguring inode-lru-limit %s", + lru_count); + sprintf (inode_lru_count, " option inode-lru-limit %s\n", + lru_count); + } + fprintf (file, server_str, volname, "server", opt_transtype, subvolume, opt_nodelay, - subvolume); + inode_lru_count, + subvolume + ); ret = 0; @@ -747,7 +796,7 @@ __write_replicate_xlator (FILE *file, dict_t *dict, int subvol_len = 0; - const char *replicate_str = "volume %s-%s-%d\n" + char replicate_str[] = "volume %s-%s-%d\n" " type cluster/replicate\n" "# option read-subvolume %s\n" "# option favorite-child %s\n" @@ -771,7 +820,15 @@ __write_replicate_xlator (FILE *file, dict_t *dict, goto out; } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_READSUBVOL, + if (dict_get (dict, "read-subvolume")) { + ret = dict_get_str (dict, "read-subvolume", &opt_readsubvol); + gf_log("", GF_LOG_DEBUG, "Reconfiguring read-subvolume: %s", + &opt_readsubvol); + uncomment_option (replicate_str, + (char *) "# option read-subvolume %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_READSUBVOL, &opt_readsubvol); if (ret) { goto out; @@ -783,14 +840,32 @@ __write_replicate_xlator (FILE *file, dict_t *dict, goto out; } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_BCKSHCOUNT, + if (dict_get (dict, "background-self-heal-count")) { + ret = dict_get_str (dict,"background-self-heal-count", + &opt_bckshcount); + gf_log("", GF_LOG_DEBUG, "Reconfiguring background-self-heal-" + "count: %s", &opt_bckshcount); + uncomment_option (replicate_str, + (char *) "# option background-self-heal-count %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_BCKSHCOUNT, &opt_bckshcount); if (ret) { goto out; } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_DATASH, - &opt_datash); + if (dict_get (dict, "data-self-heal")) { + ret = dict_get_str (dict,"data-self-heal", + &opt_datash); + gf_log("", GF_LOG_DEBUG, "Reconfiguring data-self-heal" + "count: %s", &opt_datash); + uncomment_option (replicate_str, + (char *) "# option data-self-heal %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_DATASH, + &opt_datash); if (ret) { goto out; } @@ -801,43 +876,106 @@ __write_replicate_xlator (FILE *file, dict_t *dict, goto out; } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_SHWINDOWSIZE, + if (dict_get (dict, "data-self-heal-window-size")) { + ret = dict_get_str (dict,"data-self-heal-window-size", + &opt_shwindowsize); + gf_log("", GF_LOG_DEBUG, "Reconfiguring data-self-heal" + "window-size: %s", &opt_shwindowsize); + uncomment_option (replicate_str, + (char *) "# option data-self-heal-window-size %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_SHWINDOWSIZE, &opt_shwindowsize); if (ret) { goto out; } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_METASH, + if (dict_get (dict, "metadata-self-heal")) { + ret = dict_get_str (dict,"metadata-self-heal", + &opt_metash); + gf_log("", GF_LOG_DEBUG, "Reconfiguring metadata-self-heal" + "count: %s", &opt_metash); + uncomment_option (replicate_str, + (char *) "# option metadata-self-heal %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_METASH, &opt_metash); if (ret) { goto out; } - - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_ENTRYSH, + + if (dict_get (dict, "entry-self-heal")) { + ret = dict_get_str (dict,"entry-self-heal", + &opt_entrysh); + gf_log("", GF_LOG_DEBUG, "Reconfiguring entry-self-heal" + "count: %s", &opt_entrysh); + uncomment_option (replicate_str, + (char *) "# option entry-self-heal %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_ENTRYSH, &opt_entrysh); if (ret) { goto out; } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_DATACHANGELOG, + if (dict_get (dict, "data-change-log")) { + ret = dict_get_str (dict,"data-change-log", + &opt_datachangelog); + gf_log("", GF_LOG_DEBUG, "Reconfiguring data-change-log" + "count: %s", &opt_datachangelog); + uncomment_option (replicate_str, + (char *) "# option data-change-log %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_DATACHANGELOG, &opt_datachangelog); if (ret) { goto out; } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_METADATACHANGELOG, + if (dict_get (dict, "metadata-change-log")) { + ret = dict_get_str (dict,"metadata-change-log", + &opt_metadatachangelog); + gf_log("", GF_LOG_DEBUG, "Reconfiguring metadata-change-log" + "count: %s", &opt_metadatachangelog); + uncomment_option (replicate_str, + (char *) "# option metadata-change-log %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_METADATACHANGELOG, &opt_metadatachangelog); if (ret) { goto out; } + if (dict_get (dict, "entry-change-log")) { + ret = dict_get_str (dict, "entry-change-log", &opt_entrychangelog); + gf_log("", GF_LOG_DEBUG, "Reconfiguring entry-change-log: %s", + &opt_entrychangelog); + uncomment_option (replicate_str, + (char *) "# option entry-change-log %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_ENTRYCHANGELOG, &opt_entrychangelog); if (ret) { goto out; } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_STRICTREADDIR, + if (dict_get (dict, "strict-readdir")) { + ret = dict_get_str (dict,"strict-readdir", + &opt_strictreaddir); + gf_log("", GF_LOG_DEBUG, "Reconfiguring sstrict-readdir" + "count: %s", &opt_strictreaddir); + uncomment_option (replicate_str, + (char *) "# option strict-readdir %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_STRICTREADDIR, &opt_strictreaddir); if (ret) { goto out; @@ -914,7 +1052,7 @@ __write_stripe_xlator (FILE *file, dict_t *dict, int subvol_len = 0; int len = 0; - const char *stripe_str = "volume %s-%s-%d\n" + char stripe_str[] = "volume %s-%s-%d\n" " type cluster/stripe\n" "# option block-size %s\n" "# option use-xattr %s\n" @@ -928,7 +1066,15 @@ __write_stripe_xlator (FILE *file, dict_t *dict, goto out; } - ret = dict_get_str (dict, VOLGEN_STRIPE_OPTION_BLOCKSIZE, + if (dict_get (dict, "block-size")) { + ret = dict_get_str (dict, "block-size", &opt_blocksize); + gf_log("", GF_LOG_DEBUG, "Reconfiguring Stripe Count %s", + opt_blocksize); + uncomment_option (stripe_str, + (char *) "# option block-size %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_STRIPE_OPTION_BLOCKSIZE, &opt_blocksize); if (ret) { goto out; @@ -999,7 +1145,7 @@ __write_distribute_xlator (FILE *file, dict_t *dict, int subvol_len = 0; int len = 0; - const char *dht_str = "volume %s-%s\n" + char dht_str[] = "volume %s-%s\n" "type cluster/distribute\n" "# option lookup-unhashed %s\n" "# option min-free-disk %s\n" @@ -1012,12 +1158,28 @@ __write_distribute_xlator (FILE *file, dict_t *dict, goto out; } - ret = dict_get_str (dict, VOLGEN_DHT_OPTION_LOOKUPUNHASH, + if (dict_get (dict, "lookup-unhashed")) { + ret = dict_get_str (dict, "lookup-unhashed", &opt_lookupunhash); + gf_log("", GF_LOG_DEBUG, "Reconfiguring lookup-unhashed %s", + opt_lookupunhash); + uncomment_option (dht_str, + (char *) "# option lookup-unhashed %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_DHT_OPTION_LOOKUPUNHASH, &opt_lookupunhash); if (ret) { goto out; } + if (dict_get (dict, "min-free-disk")) { + ret = dict_get_str (dict, "min-free-disk", &opt_minfreedisk); + gf_log("", GF_LOG_DEBUG, "Reconfiguring min-free-disk", + opt_minfreedisk); + uncomment_option (dht_str, + (char *) "# option min-free-disk %s\n"); + } + else ret = dict_get_str (dict, VOLGEN_DHT_OPTION_MINFREEDISK, &opt_minfreedisk); if (ret) { @@ -1067,6 +1229,24 @@ out: return ret; } + +int +uncomment_option( char *opt_str,char *comment_str) +{ + char *ptr; + + ptr = strstr (opt_str,comment_str); + if (!ptr) + return -1; + + if (*ptr != '#') + return -1; + + *ptr = ' '; + + return 0; +} + static int __write_wb_xlator (FILE *file, dict_t *dict, char *subvolume) @@ -1079,7 +1259,7 @@ __write_wb_xlator (FILE *file, dict_t *dict, char *opt_tricklingwrites = NULL; int ret = -1; - const char *dht_str = "volume %s-%s\n" + char dht_str[] = "volume %s-%s\n" " type performance/write-behind\n" "# option flush-behind %s\n" "# option cache-size %s\n" @@ -1100,7 +1280,13 @@ __write_wb_xlator (FILE *file, dict_t *dict, goto out; } - ret = dict_get_str (dict, VOLGEN_WB_OPTION_CACHESIZE, + if (dict_get (dict, "cache-size")) { + gf_log("",GF_LOG_DEBUG, "Uncommenting option cache-size"); + uncomment_option (dht_str,(char *) "# option cache-size %s\n"); + ret = dict_get_str (dict, "cache-size", &opt_cachesize); + } + else + ret = dict_get_str (dict, VOLGEN_WB_OPTION_CACHESIZE, &opt_cachesize); if (ret) { goto out; @@ -1200,7 +1386,7 @@ __write_iocache_xlator (FILE *file, dict_t *dict, char *opt_maxfilesize = NULL; int ret = -1; - const char *iocache_str = "volume %s-%s\n" + char iocache_str[] = "volume %s-%s\n" " type performance/io-cache\n" "# option priority %s\n" "# option cache-timeout %s\n" @@ -1215,31 +1401,71 @@ __write_iocache_xlator (FILE *file, dict_t *dict, goto out; } - ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_PRIORITY, + if (dict_get (dict, "priority")) { + ret = dict_get_str (dict, "priority", &opt_priority); + gf_log("", GF_LOG_DEBUG, "Reconfiguring priority", + opt_priority); + uncomment_option (iocache_str, + (char *) "# option priority %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_PRIORITY, &opt_priority); if (ret) { goto out; } - ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_TIMEOUT, + if (dict_get (dict, "cache-timeout")) { + ret = dict_get_str (dict, "cache-timeout", &opt_timeout); + gf_log("", GF_LOG_DEBUG, "Reconfiguring cache-timeout", + opt_timeout); + uncomment_option (iocache_str, + (char *) "# option cache-timeout %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_TIMEOUT, &opt_timeout); if (ret) { goto out; } - ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_CACHESIZE, + if (dict_get (dict, "cache-size")) { + ret = dict_get_str (dict, "cache-size", &opt_cachesize); + gf_log("", GF_LOG_DEBUG, "Reconfiguring cache-size :%s", + opt_cachesize); + uncomment_option (iocache_str, + (char *) "# option cache-size %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_CACHESIZE, &opt_cachesize); if (ret) { goto out; } - ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_MINFILESIZE, + if (dict_get (dict, "min-file-size")) { + ret = dict_get_str (dict, "min-file-size", &opt_minfilesize); + gf_log("", GF_LOG_DEBUG, "Reconfiguring min-file-size: %s", + opt_minfilesize); + uncomment_option (iocache_str, + (char *) "# option min-file-size %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_MINFILESIZE, &opt_minfilesize); if (ret) { goto out; } - ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_MAXFILESIZE, + if (dict_get (dict, "max-file-size")) { + ret = dict_get_str (dict, "max-file-size", &opt_maxfilesize); + gf_log("", GF_LOG_DEBUG, "Reconfiguring max-file-size: %s", + opt_maxfilesize); + uncomment_option (iocache_str, + (char *) "# option max-file-size %s\n"); + } + else + ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_MAXFILESIZE, &opt_maxfilesize); if (ret) { goto out; @@ -2016,6 +2242,8 @@ glusterd_create_volfiles (glusterd_volinfo_t *volinfo) { int ret = -1; + gf_log ("", GF_LOG_DEBUG, "Inside Create Volfiles"); + if(volinfo->transport_type == GF_TRANSPORT_RDMA) { ret = set_xlator_option (volinfo->dict, VOLGEN_CLIENT_OPTION_TRANSTYPE, "rdma"); diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.h b/xlators/mgmt/glusterd/src/glusterd-volgen.h index bee572646..a93bac675 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volgen.h +++ b/xlators/mgmt/glusterd/src/glusterd-volgen.h @@ -141,4 +141,7 @@ glusterd_get_nfs_filepath (); int volgen_generate_nfs_volfile (glusterd_volinfo_t *volinfo); + +int +uncomment_option( char *opt_str,char *comment_str); #endif diff --git a/xlators/mgmt/glusterd/src/glusterd.h b/xlators/mgmt/glusterd/src/glusterd.h index 947f1c23a..cfa229301 100644 --- a/xlators/mgmt/glusterd/src/glusterd.h +++ b/xlators/mgmt/glusterd/src/glusterd.h @@ -373,6 +373,12 @@ glusterd_log_rotate (rpcsvc_request_t *req, dict_t *dict); int32_t glusterd_remove_brick (rpcsvc_request_t *req, dict_t *dict); +int32_t +glusterd_set_volume (rpcsvc_request_t *req, dict_t *dict); + +int +glusterd_handle_set_volume (rpcsvc_request_t *req); + int glusterd_xfer_cli_deprobe_resp (rpcsvc_request_t *req, int32_t op_ret, int32_t op_errno, char *hostname); diff --git a/xlators/mgmt/glusterd/src/glusterd3_1-mops.c b/xlators/mgmt/glusterd/src/glusterd3_1-mops.c index 5f0ab79ca..244b71009 100644 --- a/xlators/mgmt/glusterd/src/glusterd3_1-mops.c +++ b/xlators/mgmt/glusterd/src/glusterd3_1-mops.c @@ -1335,7 +1335,13 @@ glusterd_handle_rpc_msg (rpcsvc_request_t *req) ret = glusterd_handle_log_rotate (req); break; + case GD_MGMT_CLI_SET_VOLUME: + ret = glusterd_handle_set_volume (req); + break; + default: + gf_log("", GF_LOG_ERROR, "Recieved Invalid procnum:%d", + req->procnum); GF_ASSERT (0); } @@ -1386,6 +1392,8 @@ rpcsvc_actor_t glusterd1_mgmt_actors[] = { [GD_MGMT_CLI_LOG_FILENAME] = { "LOG FILENAME", GD_MGMT_CLI_LOG_FILENAME, glusterd_handle_rpc_msg, NULL, NULL}, [GD_MGMT_CLI_LOG_LOCATE] = { "LOG LOCATE", GD_MGMT_CLI_LOG_LOCATE, glusterd_handle_log_locate, NULL, NULL}, [GD_MGMT_CLI_LOG_ROTATE] = { "LOG FILENAME", GD_MGMT_CLI_LOG_ROTATE, glusterd_handle_rpc_msg, NULL, NULL}, + [GD_MGMT_CLI_SET_VOLUME] = { "SET_VOLUME", GD_MGMT_CLI_SET_VOLUME, glusterd_handle_rpc_msg, NULL, NULL}, + }; /*rpcsvc_actor_t glusterd1_mgmt_actors[] = { diff --git a/xlators/performance/io-cache/src/io-cache.c b/xlators/performance/io-cache/src/io-cache.c index 490d31688..296edf233 100644 --- a/xlators/performance/io-cache/src/io-cache.c +++ b/xlators/performance/io-cache/src/io-cache.c @@ -1470,6 +1470,165 @@ mem_acct_init (xlator_t *this) return ret; } +int +reconfigure (xlator_t *this, dict_t *options) +{ + ioc_table_t *table = NULL; + int32_t cache_timeout; + int64_t min_file_size = 0; + int64_t max_file_size = 0; + char *tmp = NULL; + uint64_t cache_size; + char *cache_size_string = NULL; + int ret = 0; + + table = this->private; + + ioc_table_lock (table); + { + if (dict_get (options, "cache-timeout")) { + cache_timeout = + data_to_uint32 (dict_get (options, + "cache-timeout")); + if (cache_timeout < 0){ + gf_log (this->name, GF_LOG_WARNING, + "cache-timeout %d seconds invalid," + " has to be >=0", cache_timeout); + ret = -1; + goto out; + } + + + if (cache_timeout > 60){ + gf_log (this->name, GF_LOG_WARNING, + "cache-timeout %d seconds invalid," + " has to be <=60", cache_timeout); + ret = -1; + goto out; + } + + table->cache_timeout = cache_timeout; + + gf_log (this->name, GF_LOG_DEBUG, + "Reconfiguring %d seconds to" + " revalidate cache", table->cache_timeout); + } + + + if (dict_get (options, "cache-size")) + cache_size_string = data_to_str (dict_get (options, + "cache-size")); + if (cache_size_string) { + if (gf_string2bytesize (cache_size_string, + &cache_size) != 0) { + gf_log ("io-cache", GF_LOG_ERROR, + "invalid number format \"%s\" of " + "\"option cache-size\" Defaulting" + "to old value", cache_size_string); + ret = -1; + goto out; + } + + if (cache_size < (4*(2^20))) { + gf_log(this->name, GF_LOG_ERROR, "Reconfiguration" + "'option cache-size %s' failed , Max value" + "can be 4MiB, Defaulting to old value (%d)" + , cache_size_string, table->cache_size); + ret = -1; + goto out; + } + + if (cache_size > (6 *(2^30))) { + gf_log(this->name, GF_LOG_ERROR, "Reconfiguration" + "'option cache-size %s' failed , Max value" + "can be 6GiB, Defaulting to old value (%d)" + , cache_size_string, table->cache_size); + ret = -1; + goto out; + } + + + gf_log (this->name, GF_LOG_DEBUG, "Reconfiguring " + " cache-size %"PRIu64"", table->cache_size); + table->cache_size = cache_size; + } + + + if (dict_get (options, "priority")) { + char *option_list = data_to_str (dict_get (options, + "priority")); + gf_log (this->name, GF_LOG_TRACE, + "option path %s", option_list); + /* parse the list of pattern:priority */ + table->max_pri = ioc_get_priority_list (option_list, + &table->priority_list); + + if (table->max_pri == -1) { + ret = -1; + goto out; + } + table->max_pri ++; + } + + + + min_file_size = table->min_file_size; + tmp = data_to_str (dict_get (options, "min-file-size")); + if (tmp != NULL) { + if (gf_string2bytesize (tmp, + (uint64_t *)&min_file_size) + != 0) { + gf_log ("io-cache", GF_LOG_ERROR, + "invalid number format \"%s\" of " + "\"option min-file-size\"", tmp); + ret = -1; + goto out; + } + + gf_log (this->name, GF_LOG_DEBUG, + "Reconfiguring min-file-size %"PRIu64"", + table->min_file_size); + } + + max_file_size = table->max_file_size; + tmp = data_to_str (dict_get (options, "max-file-size")); + if (tmp != NULL) { + if (gf_string2bytesize (tmp, + (uint64_t *)&max_file_size) + != 0) { + gf_log ("io-cache", GF_LOG_ERROR, + "invalid number format \"%s\" of " + "\"option max-file-size\"", tmp); + ret = -1; + goto out; + } + + + gf_log (this->name, GF_LOG_DEBUG, + "Reconfiguring max-file-size %"PRIu64"", + table->max_file_size); + } + + if ((max_file_size >= 0) & (min_file_size > max_file_size)) { + gf_log ("io-cache", GF_LOG_ERROR, "minimum size (%" + PRIu64") of a file that can be cached is " + "greater than maximum size (%"PRIu64"). " + "Hence Defaulting to old value", + table->min_file_size, table->max_file_size); + ret = -1; + goto out; + } + + table->min_file_size = min_file_size; + table->max_file_size = max_file_size; + } + + ioc_table_unlock (table); +out: + return ret; + +} + /* * init - * @this: diff --git a/xlators/performance/io-threads/src/io-threads.c b/xlators/performance/io-threads/src/io-threads.c index e31bd4bba..0fe034a3f 100644 --- a/xlators/performance/io-threads/src/io-threads.c +++ b/xlators/performance/io-threads/src/io-threads.c @@ -2079,10 +2079,51 @@ mem_acct_init (xlator_t *this) return ret; } + + return ret; } int +reconfigure ( xlator_t *this, dict_t *options) +{ + iot_conf_t *conf = NULL; + int ret = 0; + int thread_count; + + + if (dict_get (options, "thread-count")) { + thread_count = data_to_int32 (dict_get (options, + "thread-count")); + + if (thread_count < IOT_MIN_THREADS) { + gf_log ("io-threads", GF_LOG_WARNING, + "Number of threads opted is less then min rest" + "oring it to previous value",conf->max_count); + ret = -1; + goto out; + } + + if (thread_count > IOT_MAX_THREADS) { + gf_log ("io-threads", GF_LOG_WARNING, + "Number of threads opted is greater than max " + "restoring it to previous value",conf->max_count); + ret = -1; + goto out; + } + + conf->max_count = thread_count; + } + + ret = 0; + +out: + return ret; + + +} + +int init (xlator_t *this) { iot_conf_t *conf = NULL; diff --git a/xlators/performance/write-behind/src/write-behind.c b/xlators/performance/write-behind/src/write-behind.c index c9fc25a5b..efb78acf7 100644 --- a/xlators/performance/write-behind/src/write-behind.c +++ b/xlators/performance/write-behind/src/write-behind.c @@ -2727,6 +2727,57 @@ mem_acct_init (xlator_t *this) return ret; } +int +reconfigure (xlator_t *this, dict_t *options) +{ + char *str=NULL; + uint64_t window_size; + wb_conf_t *conf = NULL; + int ret = 0; + + conf = this->private; + + ret = dict_get_str (options, "cache-size", + &str); + if (ret == 0) { + ret = gf_string2bytesize (str, &window_size); + if (ret != 0) { + gf_log(this->name, GF_LOG_ERROR, "Reconfiguration" + "'option cache-size %s failed , Invalid" + " number format, Defaulting to old value (%d)" + , str, conf->window_size); + ret = -1; + goto out; + } + + if (window_size < (2^19)) { + gf_log(this->name, GF_LOG_ERROR, "Reconfiguration" + "'option cache-size %s' failed , Max value" + "can be 512KiB, Defaulting to old value (%d)" + , str, conf->window_size); + ret = -1; + goto out; + } + + if (window_size > (2^30)) { + gf_log(this->name, GF_LOG_ERROR, "Reconfiguration" + "'option cache-size %s' failed , Max value" + "can be 1 GiB, Defaulting to old value (%d)" + , str, conf->window_size); + ret = -1; + goto out; + } + + conf->window_size = window_size; + gf_log(this->name, GF_LOG_DEBUG, "Reconfiguring " + "'option cache-size %s ' to %d" + , str, conf->window_size); + } +out: + return 0; + +} + int32_t init (xlator_t *this) { diff --git a/xlators/protocol/client/src/client.c b/xlators/protocol/client/src/client.c index 4220afc6d..e3e143d58 100644 --- a/xlators/protocol/client/src/client.c +++ b/xlators/protocol/client/src/client.c @@ -1751,6 +1751,80 @@ out: } int +reconfigure (xlator_t *this, dict_t *options) +{ + int ret = 0; + int timeout_ret=0; + int ping_timeout; + int frame_timeout; + clnt_conf_t *conf = NULL; + + + conf = this->private; + + timeout_ret = dict_get_int32 (options, "frame-timeout", + &frame_timeout); + if (timeout_ret == 0) { + if (frame_timeout < 5 ) { + gf_log (this->name, GF_LOG_ERROR, "Reconfiguration" + "'option frame-timeout %d failed , Min value" + " can be 5, Defaulting to old value (%d)" + , frame_timeout, conf->rpc_conf.rpc_timeout); + ret = -1; + goto out; + } + + if (frame_timeout > 3600 ) { + gf_log (this->name, GF_LOG_ERROR, "Reconfiguration" + "'option frame-timeout %d failed , Max value" + "can be 3600, Defaulting to old value (%d)" + , frame_timeout, conf->rpc_conf.rpc_timeout); + ret = -1; + goto out; + } + + + gf_log (this->name, GF_LOG_DEBUG, + "Reconfiguring otion frame-timeout to %d", + frame_timeout); + + conf->rpc_conf.rpc_timeout = frame_timeout; + } + + timeout_ret = dict_get_int32 (options, "ping-timeout", + &ping_timeout); + if (timeout_ret == 0) { + + if (frame_timeout < 5 ) { + gf_log (this->name, GF_LOG_WARNING, "Reconfiguration" + "'option ping-timeout %d failed , Min value" + " can be 5, Defaulting to old value (%d)" + , ping_timeout, conf->opt.ping_timeout); + ret = -1; + goto out; + } + + if (frame_timeout > 1013 ) { + gf_log (this->name, GF_LOG_WARNING, "Reconfiguration" + "'option frame-timeout %d failed , Max value" + "can be 1013, Defaulting to old value (%d)" + , frame_timeout, conf->opt.ping_timeout); + ret = -1; + goto out; + } + + gf_log (this->name, GF_LOG_DEBUG, "Reconfiguring " + "'option ping-timeout' to %d", ping_timeout); + conf->opt.ping_timeout = ping_timeout; + } + +out: + return ret; + + +} + +int init (xlator_t *this) { int ret = -1; diff --git a/xlators/protocol/server/src/server.c b/xlators/protocol/server/src/server.c index 5d1f3aabe..58a57acee 100644 --- a/xlators/protocol/server/src/server.c +++ b/xlators/protocol/server/src/server.c @@ -457,6 +457,43 @@ mem_acct_init (xlator_t *this) } int +reconfigure (xlator_t *this, dict_t *options) +{ + + server_conf_t *conf =NULL; + int inode_lru_limit; + gf_boolean_t trace; + data_t *data; + int ret; + + conf = this->private; + + if (dict_get_int32 ( options, "inode-lru-limit", &inode_lru_limit) == 0){ + conf->inode_lru_limit = inode_lru_limit; + gf_log (this->name, GF_LOG_TRACE, "Reconfigured inode-lru-limit" + " to %d", conf->inode_lru_limit); + } + + data = dict_get (options, "trace"); + if (data) { + ret = gf_string2boolean (data->data, &trace); + if (ret != 0) { + gf_log (this->name, GF_LOG_WARNING, + "'trace' takes on only boolean values. " + "Neglecting option"); + return -1; + } + conf->trace = trace; + gf_log (this->name, GF_LOG_TRACE, "Reconfigured trace" + " to %d", conf->trace); + + } + + return 0; + +} + +int init (xlator_t *this) { int32_t ret = -1; |