diff options
Diffstat (limited to 'xlators/mgmt/glusterd/src/glusterd-volgen.c')
| -rw-r--r-- | xlators/mgmt/glusterd/src/glusterd-volgen.c | 10876 |
1 files changed, 5334 insertions, 5542 deletions
diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.c b/xlators/mgmt/glusterd/src/glusterd-volgen.c index 166d52394f1..9c00f6b976a 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volgen.c +++ b/xlators/mgmt/glusterd/src/glusterd-volgen.c @@ -39,33 +39,34 @@ #include "glusterd-gfproxyd-svc-helper.h" struct gd_validate_reconf_opts { - dict_t *options; - char **op_errstr; + dict_t *options; + char **op_errstr; }; extern struct volopt_map_entry glusterd_volopt_map[]; -#define RPC_SET_OPT(XL, CLI_OPT, XLATOR_OPT, ERROR_CMD) do { \ - char *_value = NULL; \ - \ - if (dict_get_str (set_dict, CLI_OPT, &_value) == 0) { \ - if (xlator_set_option (XL, \ - "transport.socket." XLATOR_OPT, _value) != 0) { \ - gf_msg ("glusterd", GF_LOG_WARNING, errno, \ - GD_MSG_XLATOR_SET_OPT_FAIL, \ - "failed to set " XLATOR_OPT); \ - ERROR_CMD; \ - } \ - } \ -} while (0 /* CONSTCOND */) +#define RPC_SET_OPT(XL, CLI_OPT, XLATOR_OPT, ERROR_CMD) \ + do { \ + char *_value = NULL; \ + \ + if (dict_get_str(set_dict, CLI_OPT, &_value) == 0) { \ + if (xlator_set_option(XL, "transport.socket." XLATOR_OPT, \ + _value) != 0) { \ + gf_msg("glusterd", GF_LOG_WARNING, errno, \ + GD_MSG_XLATOR_SET_OPT_FAIL, \ + "failed to set " XLATOR_OPT); \ + ERROR_CMD; \ + } \ + } \ + } while (0 /* CONSTCOND */) static int -volgen_graph_build_clients (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, void *param); +volgen_graph_build_clients(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, void *param); static int -build_client_graph (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *mod_dict); +build_client_graph(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *mod_dict); /********************************************* * @@ -74,271 +75,260 @@ build_client_graph (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, *********************************************/ static void -set_graph_errstr (volgen_graph_t *graph, const char *str) +set_graph_errstr(volgen_graph_t *graph, const char *str) { - if (!graph->errstr) - return; + if (!graph->errstr) + return; - *graph->errstr = gf_strdup (str); + *graph->errstr = gf_strdup(str); } static xlator_t * -xlator_instantiate_va (const char *type, const char *format, va_list arg) +xlator_instantiate_va(const char *type, const char *format, va_list arg) { - xlator_t *xl = NULL; - char *volname = NULL; - int ret = 0; + xlator_t *xl = NULL; + char *volname = NULL; + int ret = 0; - ret = gf_vasprintf (&volname, format, arg); - if (ret < 0) { - volname = NULL; + ret = gf_vasprintf(&volname, format, arg); + if (ret < 0) { + volname = NULL; - goto error; - } + goto error; + } - xl = GF_CALLOC (1, sizeof (*xl), gf_common_mt_xlator_t); - if (!xl) - goto error; - ret = xlator_set_type_virtual (xl, type); - if (ret) - goto error; - xl->options = dict_new (); - if (!xl->options) - goto error; - xl->name = volname; - CDS_INIT_LIST_HEAD (&xl->volume_options); - - xl->ctx = THIS->ctx; - - return xl; - - error: - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_XLATOR_CREATE_FAIL, - "creating xlator of type %s failed", - type); - GF_FREE (volname); - if (xl) - xlator_destroy (xl); + xl = GF_CALLOC(1, sizeof(*xl), gf_common_mt_xlator_t); + if (!xl) + goto error; + ret = xlator_set_type_virtual(xl, type); + if (ret) + goto error; + xl->options = dict_new(); + if (!xl->options) + goto error; + xl->name = volname; + CDS_INIT_LIST_HEAD(&xl->volume_options); - return NULL; + xl->ctx = THIS->ctx; + + return xl; + +error: + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_XLATOR_CREATE_FAIL, + "creating xlator of type %s failed", type); + GF_FREE(volname); + if (xl) + xlator_destroy(xl); + + return NULL; } static xlator_t * -xlator_instantiate (const char *type, const char *format, ...) +xlator_instantiate(const char *type, const char *format, ...) { - va_list arg; - xlator_t *xl; + va_list arg; + xlator_t *xl; - va_start (arg, format); - xl = xlator_instantiate_va (type, format, arg); - va_end (arg); + va_start(arg, format); + xl = xlator_instantiate_va(type, format, arg); + va_end(arg); - return xl; + return xl; } static int -volgen_xlator_link (xlator_t *pxl, xlator_t *cxl) +volgen_xlator_link(xlator_t *pxl, xlator_t *cxl) { - int ret = 0; + int ret = 0; - ret = glusterfs_xlator_link (pxl, cxl); - if (ret == -1) { - gf_msg ("glusterd", GF_LOG_ERROR, ENOMEM, - GD_MSG_NO_MEMORY, - "Out of memory, cannot link xlators %s <- %s", - pxl->name, cxl->name); - } + ret = glusterfs_xlator_link(pxl, cxl); + if (ret == -1) { + gf_msg("glusterd", GF_LOG_ERROR, ENOMEM, GD_MSG_NO_MEMORY, + "Out of memory, cannot link xlators %s <- %s", pxl->name, + cxl->name); + } - return ret; + return ret; } static int -volgen_graph_link (volgen_graph_t *graph, xlator_t *xl) +volgen_graph_link(volgen_graph_t *graph, xlator_t *xl) { - int ret = 0; + int ret = 0; - /* no need to care about graph->top here */ - if (graph->graph.first) - ret = volgen_xlator_link (xl, graph->graph.first); - if (ret == -1) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_GRAPH_ENTRY_ADD_FAIL, - "failed to add graph entry %s", - xl->name); + /* no need to care about graph->top here */ + if (graph->graph.first) + ret = volgen_xlator_link(xl, graph->graph.first); + if (ret == -1) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_GRAPH_ENTRY_ADD_FAIL, + "failed to add graph entry %s", xl->name); - return -1; - } + return -1; + } - return 0; + return 0; } static xlator_t * -volgen_graph_add_as (volgen_graph_t *graph, const char *type, - const char *format, ...) +volgen_graph_add_as(volgen_graph_t *graph, const char *type, const char *format, + ...) { - va_list arg; - xlator_t *xl = NULL; + va_list arg; + xlator_t *xl = NULL; - va_start (arg, format); - xl = xlator_instantiate_va (type, format, arg); - va_end (arg); + va_start(arg, format); + xl = xlator_instantiate_va(type, format, arg); + va_end(arg); - if (!xl) - return NULL; + if (!xl) + return NULL; - if (volgen_graph_link (graph, xl)) { - xlator_destroy (xl); + if (volgen_graph_link(graph, xl)) { + xlator_destroy(xl); - return NULL; - } else - glusterfs_graph_set_first (&graph->graph, xl); + return NULL; + } else + glusterfs_graph_set_first(&graph->graph, xl); - return xl; + return xl; } static xlator_t * -volgen_graph_add_nolink (volgen_graph_t *graph, const char *type, - const char *format, ...) +volgen_graph_add_nolink(volgen_graph_t *graph, const char *type, + const char *format, ...) { - va_list arg; - xlator_t *xl = NULL; + va_list arg; + xlator_t *xl = NULL; - va_start (arg, format); - xl = xlator_instantiate_va (type, format, arg); - va_end (arg); + va_start(arg, format); + xl = xlator_instantiate_va(type, format, arg); + va_end(arg); - if (!xl) - return NULL; + if (!xl) + return NULL; - glusterfs_graph_set_first (&graph->graph, xl); + glusterfs_graph_set_first(&graph->graph, xl); - return xl; + return xl; } static xlator_t * -volgen_graph_add (volgen_graph_t *graph, char *type, char *volname) +volgen_graph_add(volgen_graph_t *graph, char *type, char *volname) { - char *shorttype = NULL; + char *shorttype = NULL; - shorttype = strrchr (type, '/'); - GF_ASSERT (shorttype); - shorttype++; - GF_ASSERT (*shorttype); + shorttype = strrchr(type, '/'); + GF_ASSERT(shorttype); + shorttype++; + GF_ASSERT(*shorttype); - return volgen_graph_add_as (graph, type, "%s-%s", volname, shorttype); + return volgen_graph_add_as(graph, type, "%s-%s", volname, shorttype); } /* XXX Seems there is no such generic routine? * Maybe should put to xlator.c ?? */ static int -xlator_set_option (xlator_t *xl, char *key, char *value) +xlator_set_option(xlator_t *xl, char *key, char *value) { - char *dval = NULL; + char *dval = NULL; - dval = gf_strdup (value); - if (!dval) { - gf_msg ("glusterd", GF_LOG_ERROR, errno, - GD_MSG_NO_MEMORY, - "failed to set xlator opt: %s[%s] = %s", - xl->name, key, value); + dval = gf_strdup(value); + if (!dval) { + gf_msg("glusterd", GF_LOG_ERROR, errno, GD_MSG_NO_MEMORY, + "failed to set xlator opt: %s[%s] = %s", xl->name, key, value); - return -1; - } + return -1; + } - return dict_set_dynstr (xl->options, key, dval); + return dict_set_dynstr(xl->options, key, dval); } static int -xlator_get_option (xlator_t *xl, char *key, char **value) +xlator_get_option(xlator_t *xl, char *key, char **value) { - GF_ASSERT (xl); - return dict_get_str (xl->options, key, value); + GF_ASSERT(xl); + return dict_get_str(xl->options, key, value); } static xlator_t * -first_of (volgen_graph_t *graph) +first_of(volgen_graph_t *graph) { - return (xlator_t *)graph->graph.first; + return (xlator_t *)graph->graph.first; } - - - /************************** * * Trie glue * *************************/ - static int -volopt_selector (int lvl, char **patt, void *param, - int (*optcbk)(char *word, void *param)) -{ - struct volopt_map_entry *vme = NULL; - char *w = NULL; - int i = 0; - int len = 0; - int ret = 0; - char *dot = NULL; - - for (vme = glusterd_volopt_map; vme->key; vme++) { - w = vme->key; - - for (i = 0; i < lvl; i++) { - if (patt[i]) { - w = strtail (w, patt[i]); - GF_ASSERT (!w || *w); - if (!w || *w != '.') - goto next; - } else { - w = strchr (w, '.'); - GF_ASSERT (w); - } - w++; - } - - dot = strchr (w, '.'); - if (dot) { - len = dot - w; - w = gf_strdup (w); - if (!w) - return -1; - w[len] = '\0'; - } - ret = optcbk (w, param); - if (dot) - GF_FREE (w); - if (ret) - return -1; - next: - continue; +volopt_selector(int lvl, char **patt, void *param, + int (*optcbk)(char *word, void *param)) +{ + struct volopt_map_entry *vme = NULL; + char *w = NULL; + int i = 0; + int len = 0; + int ret = 0; + char *dot = NULL; + + for (vme = glusterd_volopt_map; vme->key; vme++) { + w = vme->key; + + for (i = 0; i < lvl; i++) { + if (patt[i]) { + w = strtail(w, patt[i]); + GF_ASSERT(!w || *w); + if (!w || *w != '.') + goto next; + } else { + w = strchr(w, '.'); + GF_ASSERT(w); + } + w++; + } + + dot = strchr(w, '.'); + if (dot) { + len = dot - w; + w = gf_strdup(w); + if (!w) + return -1; + w[len] = '\0'; } + ret = optcbk(w, param); + if (dot) + GF_FREE(w); + if (ret) + return -1; + next: + continue; + } - return 0; + return 0; } static int -volopt_trie_cbk (char *word, void *param) +volopt_trie_cbk(char *word, void *param) { - return trie_add ((trie_t *)param, word); + return trie_add((trie_t *)param, word); } static int -process_nodevec (struct trienodevec *nodevec, char **hint) +process_nodevec(struct trienodevec *nodevec, char **hint) { - int ret = 0; - char *hint1 = NULL; - char *hint2 = NULL; - char *hintinfx = ""; - trienode_t **nodes = nodevec->nodes; + int ret = 0; + char *hint1 = NULL; + char *hint2 = NULL; + char *hintinfx = ""; + trienode_t **nodes = nodevec->nodes; - if (!nodes[0]) { - *hint = NULL; - return 0; - } + if (!nodes[0]) { + *hint = NULL; + return 0; + } #if 0 /* Limit as in git */ @@ -348,775 +338,776 @@ process_nodevec (struct trienodevec *nodevec, char **hint) } #endif - if (trienode_get_word (nodes[0], &hint1)) - return -1; + if (trienode_get_word(nodes[0], &hint1)) + return -1; - if (nodevec->cnt < 2 || !nodes[1]) { - *hint = hint1; - return 0; - } + if (nodevec->cnt < 2 || !nodes[1]) { + *hint = hint1; + return 0; + } - if (trienode_get_word (nodes[1], &hint2)) - return -1; + if (trienode_get_word(nodes[1], &hint2)) + return -1; - if (*hint) - hintinfx = *hint; - ret = gf_asprintf (hint, "%s or %s%s", hint1, hintinfx, hint2); - if (ret > 0) - ret = 0; - return ret; + if (*hint) + hintinfx = *hint; + ret = gf_asprintf(hint, "%s or %s%s", hint1, hintinfx, hint2); + if (ret > 0) + ret = 0; + return ret; } static int -volopt_trie_section (int lvl, char **patt, char *word, char **hint, int hints) +volopt_trie_section(int lvl, char **patt, char *word, char **hint, int hints) { - trienode_t *nodes[] = { NULL, NULL }; - struct trienodevec nodevec = { nodes, 2}; - trie_t *trie = NULL; - int ret = 0; + trienode_t *nodes[] = {NULL, NULL}; + struct trienodevec nodevec = {nodes, 2}; + trie_t *trie = NULL; + int ret = 0; - trie = trie_new (); - if (!trie) - return -1; + trie = trie_new(); + if (!trie) + return -1; - if (volopt_selector (lvl, patt, trie, &volopt_trie_cbk)) { - trie_destroy (trie); + if (volopt_selector(lvl, patt, trie, &volopt_trie_cbk)) { + trie_destroy(trie); - return -1; - } + return -1; + } - GF_ASSERT (hints <= 2); - nodevec.cnt = hints; - ret = trie_measure_vec (trie, word, &nodevec); - if (!ret && nodevec.nodes[0]) - ret = process_nodevec (&nodevec, hint); + GF_ASSERT(hints <= 2); + nodevec.cnt = hints; + ret = trie_measure_vec(trie, word, &nodevec); + if (!ret && nodevec.nodes[0]) + ret = process_nodevec(&nodevec, hint); - trie_destroy (trie); + trie_destroy(trie); - return ret; + return ret; } static int -volopt_trie (char *key, char **hint) +volopt_trie(char *key, char **hint) { - char *patt[] = { NULL }; - char *fullhint = NULL; - char *dot = NULL; - char *dom = NULL; - int len = 0; - int ret = 0; - - *hint = NULL; + char *patt[] = {NULL}; + char *fullhint = NULL; + char *dot = NULL; + char *dom = NULL; + int len = 0; + int ret = 0; - dot = strchr (key, '.'); - if (!dot) - return volopt_trie_section (1, patt, key, hint, 2); + *hint = NULL; - len = dot - key; - dom = gf_strdup (key); - if (!dom) - return -1; - dom[len] = '\0'; + dot = strchr(key, '.'); + if (!dot) + return volopt_trie_section(1, patt, key, hint, 2); - ret = volopt_trie_section (0, NULL, dom, patt, 1); - GF_FREE (dom); - if (ret) { - patt[0] = NULL; - goto out; - } - if (!patt[0]) - goto out; - - *hint = "..."; - ret = volopt_trie_section (1, patt, dot + 1, hint, 2); - if (ret) - goto out; - if (*hint) { - ret = gf_asprintf (&fullhint, "%s.%s", patt[0], *hint); - GF_FREE (*hint); - if (ret >= 0) { - ret = 0; - *hint = fullhint; - } - } + len = dot - key; + dom = gf_strdup(key); + if (!dom) + return -1; + dom[len] = '\0'; + + ret = volopt_trie_section(0, NULL, dom, patt, 1); + GF_FREE(dom); + if (ret) { + patt[0] = NULL; + goto out; + } + if (!patt[0]) + goto out; + + *hint = "..."; + ret = volopt_trie_section(1, patt, dot + 1, hint, 2); + if (ret) + goto out; + if (*hint) { + ret = gf_asprintf(&fullhint, "%s.%s", patt[0], *hint); + GF_FREE(*hint); + if (ret >= 0) { + ret = 0; + *hint = fullhint; + } + } - out: - GF_FREE (patt[0]); - if (ret) - *hint = NULL; +out: + GF_FREE(patt[0]); + if (ret) + *hint = NULL; - return ret; + return ret; } - - - /************************** * * Volume generation engine * **************************/ - -typedef int (*volgen_opthandler_t) (volgen_graph_t *graph, - struct volopt_map_entry *vme, - void *param); +typedef int (*volgen_opthandler_t)(volgen_graph_t *graph, + struct volopt_map_entry *vme, void *param); struct opthandler_data { - volgen_graph_t *graph; - volgen_opthandler_t handler; - struct volopt_map_entry *vme; - gf_boolean_t found; - gf_boolean_t data_t_fake; - int rv; - char *volname; - void *param; + volgen_graph_t *graph; + volgen_opthandler_t handler; + struct volopt_map_entry *vme; + gf_boolean_t found; + gf_boolean_t data_t_fake; + int rv; + char *volname; + void *param; }; static int -process_option (char *key, data_t *value, void *param) +process_option(char *key, data_t *value, void *param) { - struct opthandler_data *odt = param; - struct volopt_map_entry vme = {0,}; + struct opthandler_data *odt = param; + struct volopt_map_entry vme = { + 0, + }; - if (odt->rv) - return 0; - odt->found = _gf_true; - - vme.key = key; - vme.voltype = odt->vme->voltype; - vme.option = odt->vme->option; - vme.op_version = odt->vme->op_version; - - if (!vme.option) { - vme.option = strrchr (key, '.'); - if (vme.option) - vme.option++; - else - vme.option = key; - } - if (odt->data_t_fake) - vme.value = (char *)value; + if (odt->rv) + return 0; + odt->found = _gf_true; + + vme.key = key; + vme.voltype = odt->vme->voltype; + vme.option = odt->vme->option; + vme.op_version = odt->vme->op_version; + + if (!vme.option) { + vme.option = strrchr(key, '.'); + if (vme.option) + vme.option++; else - vme.value = value->data; + vme.option = key; + } + if (odt->data_t_fake) + vme.value = (char *)value; + else + vme.value = value->data; - odt->rv = odt->handler (odt->graph, &vme, odt->param); - return 0; + odt->rv = odt->handler(odt->graph, &vme, odt->param); + return 0; } static int -volgen_graph_set_options_generic (volgen_graph_t *graph, dict_t *dict, - void *param, volgen_opthandler_t handler) -{ - struct volopt_map_entry *vme = NULL; - struct opthandler_data odt = {0,}; - data_t *data = NULL; - - odt.graph = graph; - odt.handler = handler; - odt.param = param; - (void)data; - - for (vme = glusterd_volopt_map; vme->key; vme++) { - odt.vme = vme; - odt.found = _gf_false; - odt.data_t_fake = _gf_false; - - data = dict_get (dict, vme->key); - if (!strcmp (vme->key, "performance.client-io-threads") && - dict_get_str_boolean (dict, "skip-CLIOT", - _gf_false) == _gf_true) { - continue; - } +volgen_graph_set_options_generic(volgen_graph_t *graph, dict_t *dict, + void *param, volgen_opthandler_t handler) +{ + struct volopt_map_entry *vme = NULL; + struct opthandler_data odt = { + 0, + }; + data_t *data = NULL; - if (data) - process_option (vme->key, data, &odt); - if (odt.rv) - return odt.rv; + odt.graph = graph; + odt.handler = handler; + odt.param = param; + (void)data; - if (odt.found) - continue; + for (vme = glusterd_volopt_map; vme->key; vme++) { + odt.vme = vme; + odt.found = _gf_false; + odt.data_t_fake = _gf_false; - /* check for default value */ + data = dict_get(dict, vme->key); + if (!strcmp(vme->key, "performance.client-io-threads") && + dict_get_str_boolean(dict, "skip-CLIOT", _gf_false) == _gf_true) { + continue; + } - if (vme->value) { - /* stupid hack to be able to reuse dict iterator - * in this context - */ - odt.data_t_fake = _gf_true; - process_option (vme->key, (data_t *)vme->value, &odt); - if (odt.rv) - return odt.rv; - } + if (data) + process_option(vme->key, data, &odt); + if (odt.rv) + return odt.rv; + + if (odt.found) + continue; + + /* check for default value */ + + if (vme->value) { + /* stupid hack to be able to reuse dict iterator + * in this context + */ + odt.data_t_fake = _gf_true; + process_option(vme->key, (data_t *)vme->value, &odt); + if (odt.rv) + return odt.rv; } + } - return 0; + return 0; } static int -no_filter_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, - void *param) +no_filter_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - xlator_t *trav; - int ret = 0; + xlator_t *trav; + int ret = 0; - for (trav = first_of (graph); trav; trav = trav->next) { - if (strcmp (trav->type, vme->voltype) != 0) - continue; + for (trav = first_of(graph); trav; trav = trav->next) { + if (strcmp(trav->type, vme->voltype) != 0) + continue; - ret = xlator_set_option (trav, vme->option, vme->value); - if (ret) - break; - } - return ret; + ret = xlator_set_option(trav, vme->option, vme->value); + if (ret) + break; + } + return ret; } static int -basic_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, - void *param) +basic_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - int ret = 0; + int ret = 0; - if (vme->option[0] == '!') - goto out; + if (vme->option[0] == '!') + goto out; - ret = no_filter_option_handler (graph, vme, param); + ret = no_filter_option_handler(graph, vme, param); out: - return ret; + return ret; } static int -volgen_graph_set_options (volgen_graph_t *graph, dict_t *dict) +volgen_graph_set_options(volgen_graph_t *graph, dict_t *dict) { - return volgen_graph_set_options_generic (graph, dict, NULL, - &basic_option_handler); + return volgen_graph_set_options_generic(graph, dict, NULL, + &basic_option_handler); } static int -optget_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, - void *param) +optget_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - struct volopt_map_entry *vme2 = param; + struct volopt_map_entry *vme2 = param; - if (strcmp (vme->key, vme2->key) == 0) - vme2->value = vme->value; + if (strcmp(vme->key, vme2->key) == 0) + vme2->value = vme->value; - return 0; + return 0; } /* This getter considers defaults also. */ static int -volgen_dict_get (dict_t *dict, char *key, char **value) +volgen_dict_get(dict_t *dict, char *key, char **value) { - struct volopt_map_entry vme = {0,}; - int ret = 0; + struct volopt_map_entry vme = { + 0, + }; + int ret = 0; - vme.key = key; + vme.key = key; - ret = volgen_graph_set_options_generic (NULL, dict, &vme, - &optget_option_handler); - if (ret) { - gf_msg ("glusterd", GF_LOG_ERROR, ENOMEM, - GD_MSG_NO_MEMORY, "Out of memory"); + ret = volgen_graph_set_options_generic(NULL, dict, &vme, + &optget_option_handler); + if (ret) { + gf_msg("glusterd", GF_LOG_ERROR, ENOMEM, GD_MSG_NO_MEMORY, + "Out of memory"); - return -1; - } + return -1; + } - *value = vme.value; + *value = vme.value; - return 0; + return 0; } static int -option_complete (char *key, char **completion) +option_complete(char *key, char **completion) { - struct volopt_map_entry *vme = NULL; + struct volopt_map_entry *vme = NULL; - *completion = NULL; - for (vme = glusterd_volopt_map; vme->key; vme++) { - if (strcmp (strchr (vme->key, '.') + 1, key) != 0) - continue; + *completion = NULL; + for (vme = glusterd_volopt_map; vme->key; vme++) { + if (strcmp(strchr(vme->key, '.') + 1, key) != 0) + continue; - if (*completion && strcmp (*completion, vme->key) != 0) { - /* cancel on non-unique match */ - *completion = NULL; + if (*completion && strcmp(*completion, vme->key) != 0) { + /* cancel on non-unique match */ + *completion = NULL; - return 0; - } else - *completion = vme->key; - } + return 0; + } else + *completion = vme->key; + } - if (*completion) { - /* For sake of unified API we want - * have the completion to be a to-be-freed - * string. - */ - *completion = gf_strdup (*completion); - return -!*completion; - } + if (*completion) { + /* For sake of unified API we want + * have the completion to be a to-be-freed + * string. + */ + *completion = gf_strdup(*completion); + return -!*completion; + } - return 0; + return 0; } int -glusterd_volinfo_get (glusterd_volinfo_t *volinfo, char *key, char **value) +glusterd_volinfo_get(glusterd_volinfo_t *volinfo, char *key, char **value) { - return volgen_dict_get (volinfo->dict, key, value); + return volgen_dict_get(volinfo->dict, key, value); } int -glusterd_volinfo_get_boolean (glusterd_volinfo_t *volinfo, char *key) +glusterd_volinfo_get_boolean(glusterd_volinfo_t *volinfo, char *key) { - char *val = NULL; - gf_boolean_t enabled = _gf_false; - int ret = 0; + char *val = NULL; + gf_boolean_t enabled = _gf_false; + int ret = 0; - ret = glusterd_volinfo_get (volinfo, key, &val); - if (ret) - return -1; + ret = glusterd_volinfo_get(volinfo, key, &val); + if (ret) + return -1; - if (val) - ret = gf_string2boolean (val, &enabled); - if (ret) { - gf_msg ("glusterd", GF_LOG_ERROR, EINVAL, - GD_MSG_INVALID_ENTRY, - "value for %s option is not valid", key); + if (val) + ret = gf_string2boolean(val, &enabled); + if (ret) { + gf_msg("glusterd", GF_LOG_ERROR, EINVAL, GD_MSG_INVALID_ENTRY, + "value for %s option is not valid", key); - return -1; - } + return -1; + } - return enabled; + return enabled; } gf_boolean_t -glusterd_check_voloption_flags (char *key, int32_t flags) -{ - char *completion = NULL; - struct volopt_map_entry *vmep = NULL; - int ret = 0; - - COMPLETE_OPTION(key, completion, ret); - for (vmep = glusterd_volopt_map; vmep->key; vmep++) { - if (strcmp (vmep->key, key) == 0) { - if (vmep->flags & flags) - return _gf_true; - else - return _gf_false; - } +glusterd_check_voloption_flags(char *key, int32_t flags) +{ + char *completion = NULL; + struct volopt_map_entry *vmep = NULL; + int ret = 0; + + COMPLETE_OPTION(key, completion, ret); + for (vmep = glusterd_volopt_map; vmep->key; vmep++) { + if (strcmp(vmep->key, key) == 0) { + if (vmep->flags & flags) + return _gf_true; + else + return _gf_false; } + } - return _gf_false; + return _gf_false; } gf_boolean_t -glusterd_check_globaloption (char *key) -{ - char *completion = NULL; - struct volopt_map_entry *vmep = NULL; - int ret = 0; - - COMPLETE_OPTION(key, completion, ret); - for (vmep = glusterd_volopt_map; vmep->key; vmep++) { - if (strcmp (vmep->key, key) == 0) { - if ((vmep->type == GLOBAL_DOC) || - (vmep->type == GLOBAL_NO_DOC)) - return _gf_true; - else - return _gf_false; - } +glusterd_check_globaloption(char *key) +{ + char *completion = NULL; + struct volopt_map_entry *vmep = NULL; + int ret = 0; + + COMPLETE_OPTION(key, completion, ret); + for (vmep = glusterd_volopt_map; vmep->key; vmep++) { + if (strcmp(vmep->key, key) == 0) { + if ((vmep->type == GLOBAL_DOC) || (vmep->type == GLOBAL_NO_DOC)) + return _gf_true; + else + return _gf_false; } + } - return _gf_false; + return _gf_false; } gf_boolean_t -glusterd_check_localoption (char *key) -{ - char *completion = NULL; - struct volopt_map_entry *vmep = NULL; - int ret = 0; - - COMPLETE_OPTION(key, completion, ret); - for (vmep = glusterd_volopt_map; vmep->key; vmep++) { - if (strcmp (vmep->key, key) == 0) { - if ((vmep->type == DOC) || - (vmep->type == NO_DOC)) - return _gf_true; - else - return _gf_false; - } +glusterd_check_localoption(char *key) +{ + char *completion = NULL; + struct volopt_map_entry *vmep = NULL; + int ret = 0; + + COMPLETE_OPTION(key, completion, ret); + for (vmep = glusterd_volopt_map; vmep->key; vmep++) { + if (strcmp(vmep->key, key) == 0) { + if ((vmep->type == DOC) || (vmep->type == NO_DOC)) + return _gf_true; + else + return _gf_false; } + } - return _gf_false; + return _gf_false; } int -glusterd_check_option_exists (char *key, char **completion) -{ - struct volopt_map_entry vme = {0,}; - struct volopt_map_entry *vmep = NULL; - int ret = 0; - xlator_t *this = THIS; - - (void)vme; - (void)vmep; - - if (!strchr (key, '.')) { - if (completion) { - ret = option_complete (key, completion); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, ENOMEM, - GD_MSG_NO_MEMORY, - "Out of memory"); - return -1; - } - - ret = !!*completion; - if (ret) - return ret; - else - goto trie; - } else - return 0; - } - - for (vmep = glusterd_volopt_map; vmep->key; vmep++) { - if (strcmp (vmep->key, key) == 0) { - ret = 1; - break; - } - } +glusterd_check_option_exists(char *key, char **completion) +{ + struct volopt_map_entry vme = { + 0, + }; + struct volopt_map_entry *vmep = NULL; + int ret = 0; + xlator_t *this = THIS; + + (void)vme; + (void)vmep; + + if (!strchr(key, '.')) { + if (completion) { + ret = option_complete(key, completion); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, GD_MSG_NO_MEMORY, + "Out of memory"); + return -1; + } - if (ret || !completion) + ret = !!*completion; + if (ret) return ret; + else + goto trie; + } else + return 0; + } - trie: - ret = volopt_trie (key, completion); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - GD_MSG_ERROR_ENCOUNTERED, - "Some error occurred during keyword hinting"); + for (vmep = glusterd_volopt_map; vmep->key; vmep++) { + if (strcmp(vmep->key, key) == 0) { + ret = 1; + break; } + } + if (ret || !completion) return ret; + +trie: + ret = volopt_trie(key, completion); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, GD_MSG_ERROR_ENCOUNTERED, + "Some error occurred during keyword hinting"); + } + + return ret; } int -glusterd_volopt_validate (glusterd_volinfo_t *volinfo, dict_t *dict, char *key, - char *value, char **op_errstr) -{ - struct volopt_map_entry *vme = NULL; - int ret = 0; - xlator_t *this = THIS; - - if (!dict || !key || !value) { - gf_msg_callingfn (this->name, GF_LOG_WARNING, EINVAL, - GD_MSG_INVALID_ENTRY, "Invalid " - "Arguments (dict=%p, key=%s, value=%s)", dict, - key, value); - return -1; - } - - for (vme = &glusterd_volopt_map[0]; vme->key; vme++) { - if ((vme->validate_fn) && - ((!strcmp (key, vme->key)) || - (!strcmp (key, strchr (vme->key, '.') + 1)))) { - if ((vme->type != GLOBAL_DOC && - vme->type != GLOBAL_NO_DOC) && !volinfo) { - gf_msg (this->name, GF_LOG_ERROR, 0, - GD_MSG_INVALID_ENTRY, "%s is not" - " a global option", vme->key); - ret = -1; - goto out; - } - ret = vme->validate_fn (volinfo, dict, key, value, - op_errstr); - if (ret) - goto out; - break; - } +glusterd_volopt_validate(glusterd_volinfo_t *volinfo, dict_t *dict, char *key, + char *value, char **op_errstr) +{ + struct volopt_map_entry *vme = NULL; + int ret = 0; + xlator_t *this = THIS; + + if (!dict || !key || !value) { + gf_msg_callingfn(this->name, GF_LOG_WARNING, EINVAL, + GD_MSG_INVALID_ENTRY, + "Invalid " + "Arguments (dict=%p, key=%s, value=%s)", + dict, key, value); + return -1; + } + + for (vme = &glusterd_volopt_map[0]; vme->key; vme++) { + if ((vme->validate_fn) && ((!strcmp(key, vme->key)) || + (!strcmp(key, strchr(vme->key, '.') + 1)))) { + if ((vme->type != GLOBAL_DOC && vme->type != GLOBAL_NO_DOC) && + !volinfo) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_INVALID_ENTRY, + "%s is not" + " a global option", + vme->key); + ret = -1; + goto out; + } + ret = vme->validate_fn(volinfo, dict, key, value, op_errstr); + if (ret) + goto out; + break; } + } out: - return ret; + return ret; } -char* -glusterd_get_trans_type_rb (gf_transport_type ttype) +char * +glusterd_get_trans_type_rb(gf_transport_type ttype) { - char *trans_type = NULL; + char *trans_type = NULL; - switch (ttype) { + switch (ttype) { case GF_TRANSPORT_RDMA: - gf_asprintf (&trans_type, "rdma"); - break; + gf_asprintf(&trans_type, "rdma"); + break; case GF_TRANSPORT_TCP: case GF_TRANSPORT_BOTH_TCP_RDMA: - gf_asprintf (&trans_type, "tcp"); - break; + gf_asprintf(&trans_type, "tcp"); + break; default: - gf_msg (THIS->name, GF_LOG_ERROR, EINVAL, - GD_MSG_INVALID_ENTRY, "Unknown " - "transport type"); - } + gf_msg(THIS->name, GF_LOG_ERROR, EINVAL, GD_MSG_INVALID_ENTRY, + "Unknown " + "transport type"); + } - return trans_type; + return trans_type; } static int -_xl_link_children (xlator_t *parent, xlator_t *children, size_t child_count) -{ - xlator_t *trav = NULL; - size_t seek = 0; - int ret = -1; - - if (child_count == 0) - goto out; - seek = child_count; - for (trav = children; --seek; trav = trav->next); - for (; child_count--; trav = trav->prev) { - ret = volgen_xlator_link (parent, trav); - gf_msg_debug (THIS->name, 0, "%s:%s", parent->name, - trav->name); - if (ret) - goto out; - } - ret = 0; +_xl_link_children(xlator_t *parent, xlator_t *children, size_t child_count) +{ + xlator_t *trav = NULL; + size_t seek = 0; + int ret = -1; + + if (child_count == 0) + goto out; + seek = child_count; + for (trav = children; --seek; trav = trav->next) + ; + for (; child_count--; trav = trav->prev) { + ret = volgen_xlator_link(parent, trav); + gf_msg_debug(THIS->name, 0, "%s:%s", parent->name, trav->name); + if (ret) + goto out; + } + ret = 0; out: - return ret; + return ret; } static int -volgen_graph_merge_sub (volgen_graph_t *dgraph, volgen_graph_t *sgraph, - size_t child_count) +volgen_graph_merge_sub(volgen_graph_t *dgraph, volgen_graph_t *sgraph, + size_t child_count) { - xlator_t *trav = NULL; - int ret = 0; + xlator_t *trav = NULL; + int ret = 0; - GF_ASSERT (dgraph->graph.first); + GF_ASSERT(dgraph->graph.first); - ret = _xl_link_children (first_of (dgraph), first_of (sgraph), - child_count); - if (ret) - goto out; + ret = _xl_link_children(first_of(dgraph), first_of(sgraph), child_count); + if (ret) + goto out; - for (trav = first_of (dgraph); trav->next; trav = trav->next); + for (trav = first_of(dgraph); trav->next; trav = trav->next) + ; - trav->next = first_of (sgraph); - trav->next->prev = trav; - dgraph->graph.xl_count += sgraph->graph.xl_count; + trav->next = first_of(sgraph); + trav->next->prev = trav; + dgraph->graph.xl_count += sgraph->graph.xl_count; out: - return ret; + return ret; } static void -volgen_apply_filters (char *orig_volfile) -{ - DIR *filterdir = NULL; - struct dirent *entry = NULL; - struct dirent scratch[2] = {{0,},}; - struct stat statbuf = {0,}; - char filterpath[PATH_MAX] = {0,}; - - filterdir = sys_opendir (FILTERDIR); - - if (!filterdir) - return; - - for (;;) { - - errno = 0; - - entry = sys_readdir (filterdir, scratch); - - if (!entry || errno != 0) - break; - - if (strcmp (entry->d_name, ".") == 0 || - strcmp (entry->d_name, "..") == 0) - continue; - /* - * d_type isn't guaranteed to be present/valid on all systems, - * so do an explicit stat instead. - */ - (void) snprintf (filterpath, sizeof(filterpath), "%s/%s", - FILTERDIR, entry->d_name); - - /* Deliberately use stat instead of lstat to allow symlinks. */ - if (sys_stat (filterpath, &statbuf) == -1) - continue; - - if (!S_ISREG (statbuf.st_mode)) - continue; - /* - * We could check the mode in statbuf directly, or just skip - * this entirely and check for EPERM after exec fails, but this - * is cleaner. - */ - if (sys_access (filterpath, X_OK) != 0) - continue; - - if (runcmd (filterpath, orig_volfile, NULL)) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_FILTER_RUN_FAILED, - "failed to run filter %s", - entry->d_name); - } +volgen_apply_filters(char *orig_volfile) +{ + DIR *filterdir = NULL; + struct dirent *entry = NULL; + struct dirent scratch[2] = { + { + 0, + }, + }; + struct stat statbuf = { + 0, + }; + char filterpath[PATH_MAX] = { + 0, + }; + + filterdir = sys_opendir(FILTERDIR); + + if (!filterdir) + return; + + for (;;) { + errno = 0; + + entry = sys_readdir(filterdir, scratch); + + if (!entry || errno != 0) + break; + + if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) + continue; + /* + * d_type isn't guaranteed to be present/valid on all systems, + * so do an explicit stat instead. + */ + (void)snprintf(filterpath, sizeof(filterpath), "%s/%s", FILTERDIR, + entry->d_name); + + /* Deliberately use stat instead of lstat to allow symlinks. */ + if (sys_stat(filterpath, &statbuf) == -1) + continue; + + if (!S_ISREG(statbuf.st_mode)) + continue; + /* + * We could check the mode in statbuf directly, or just skip + * this entirely and check for EPERM after exec fails, but this + * is cleaner. + */ + if (sys_access(filterpath, X_OK) != 0) + continue; + + if (runcmd(filterpath, orig_volfile, NULL)) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_FILTER_RUN_FAILED, + "failed to run filter %s", entry->d_name); } + } - (void) sys_closedir (filterdir); + (void)sys_closedir(filterdir); } static int -volgen_write_volfile (volgen_graph_t *graph, char *filename) +volgen_write_volfile(volgen_graph_t *graph, char *filename) { - char *ftmp = NULL; - FILE *f = NULL; - int fd = 0; - xlator_t *this = NULL; + char *ftmp = NULL; + FILE *f = NULL; + int fd = 0; + xlator_t *this = NULL; - this = THIS; + this = THIS; - if (gf_asprintf (&ftmp, "%s.tmp", filename) == -1) { - ftmp = NULL; - goto error; - } + if (gf_asprintf(&ftmp, "%s.tmp", filename) == -1) { + ftmp = NULL; + goto error; + } - fd = sys_creat (ftmp, S_IRUSR | S_IWUSR); - if (fd < 0) { - gf_msg (this->name, GF_LOG_ERROR, errno, - GD_MSG_FILE_OP_FAILED, "file creation failed"); - goto error; - } + fd = sys_creat(ftmp, S_IRUSR | S_IWUSR); + if (fd < 0) { + gf_msg(this->name, GF_LOG_ERROR, errno, GD_MSG_FILE_OP_FAILED, + "file creation failed"); + goto error; + } - sys_close (fd); - - f = fopen (ftmp, "w"); - if (!f) - goto error; - - if (glusterfs_graph_print_file (f, &graph->graph) == -1) - goto error; - - if (fclose (f) != 0) { - gf_msg (THIS->name, GF_LOG_ERROR, errno, - GD_MSG_FILE_OP_FAILED, "fclose on the file %s " - "failed", ftmp); - /* - * Even though fclose has failed here, we have to set f to NULL. - * Otherwise when the code path goes to error, there again we - * try to close it which might cause undefined behavior such as - * process crash. - */ - f = NULL; - goto error; - } + sys_close(fd); + + f = fopen(ftmp, "w"); + if (!f) + goto error; + if (glusterfs_graph_print_file(f, &graph->graph) == -1) + goto error; + + if (fclose(f) != 0) { + gf_msg(THIS->name, GF_LOG_ERROR, errno, GD_MSG_FILE_OP_FAILED, + "fclose on the file %s " + "failed", + ftmp); + /* + * Even though fclose has failed here, we have to set f to NULL. + * Otherwise when the code path goes to error, there again we + * try to close it which might cause undefined behavior such as + * process crash. + */ f = NULL; + goto error; + } - if (sys_rename (ftmp, filename) == -1) - goto error; + f = NULL; - GF_FREE (ftmp); + if (sys_rename(ftmp, filename) == -1) + goto error; - volgen_apply_filters(filename); + GF_FREE(ftmp); - return 0; + volgen_apply_filters(filename); - error: + return 0; - GF_FREE (ftmp); - if (f) - fclose (f); +error: - gf_msg (this->name, GF_LOG_ERROR, 0, - GD_MSG_VOLFILE_CREATE_FAIL, - "failed to create volfile %s", filename); + GF_FREE(ftmp); + if (f) + fclose(f); - return -1; + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_VOLFILE_CREATE_FAIL, + "failed to create volfile %s", filename); + + return -1; } static void -volgen_graph_free (volgen_graph_t *graph) +volgen_graph_free(volgen_graph_t *graph) { - xlator_t *trav = NULL; - xlator_t *trav_old = NULL; + xlator_t *trav = NULL; + xlator_t *trav_old = NULL; - for (trav = first_of (graph) ;; trav = trav->next) { - if (trav_old) - xlator_destroy (trav_old); + for (trav = first_of(graph);; trav = trav->next) { + if (trav_old) + xlator_destroy(trav_old); - trav_old = trav; + trav_old = trav; - if (!trav) - break; - } + if (!trav) + break; + } } static int -build_graph_generic (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *mod_dict, void *param, - int (*builder) (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - dict_t *set_dict, void *param)) +build_graph_generic(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *mod_dict, void *param, + int (*builder)(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, + dict_t *set_dict, void *param)) { - dict_t *set_dict = NULL; - int ret = 0; + dict_t *set_dict = NULL; + int ret = 0; - if (mod_dict) { - set_dict = dict_copy_with_ref (volinfo->dict, NULL); - if (!set_dict) - return -1; - dict_copy (mod_dict, set_dict); - /* XXX dict_copy swallows errors */ - } else { - set_dict = volinfo->dict; - } + if (mod_dict) { + set_dict = dict_copy_with_ref(volinfo->dict, NULL); + if (!set_dict) + return -1; + dict_copy(mod_dict, set_dict); + /* XXX dict_copy swallows errors */ + } else { + set_dict = volinfo->dict; + } - ret = builder (graph, volinfo, set_dict, param); - if (!ret) - ret = volgen_graph_set_options (graph, set_dict); + ret = builder(graph, volinfo, set_dict, param); + if (!ret) + ret = volgen_graph_set_options(graph, set_dict); - if (mod_dict) - dict_unref (set_dict); + if (mod_dict) + dict_unref(set_dict); - return ret; + return ret; } static gf_transport_type -transport_str_to_type (char *tt) +transport_str_to_type(char *tt) { - gf_transport_type type = GF_TRANSPORT_TCP; + gf_transport_type type = GF_TRANSPORT_TCP; - if (!strcmp ("tcp", tt)) - type = GF_TRANSPORT_TCP; - else if (!strcmp ("rdma", tt)) - type = GF_TRANSPORT_RDMA; - else if (!strcmp ("tcp,rdma", tt)) - type = GF_TRANSPORT_BOTH_TCP_RDMA; - return type; + if (!strcmp("tcp", tt)) + type = GF_TRANSPORT_TCP; + else if (!strcmp("rdma", tt)) + type = GF_TRANSPORT_RDMA; + else if (!strcmp("tcp,rdma", tt)) + type = GF_TRANSPORT_BOTH_TCP_RDMA; + return type; } static void -transport_type_to_str (gf_transport_type type, char *tt) +transport_type_to_str(gf_transport_type type, char *tt) { - switch (type) { + switch (type) { case GF_TRANSPORT_RDMA: - strcpy (tt, "rdma"); - break; + strcpy(tt, "rdma"); + break; case GF_TRANSPORT_TCP: - strcpy (tt, "tcp"); - break; + strcpy(tt, "tcp"); + break; case GF_TRANSPORT_BOTH_TCP_RDMA: - strcpy (tt, "tcp,rdma"); - break; - } + strcpy(tt, "tcp,rdma"); + break; + } } static void -get_vol_transport_type (glusterd_volinfo_t *volinfo, char *tt) +get_vol_transport_type(glusterd_volinfo_t *volinfo, char *tt) { - transport_type_to_str (volinfo->transport_type, tt); + transport_type_to_str(volinfo->transport_type, tt); } /* If no value has specified for tcp,rdma volume from cli @@ -1124,16 +1115,15 @@ get_vol_transport_type (glusterd_volinfo_t *volinfo, char *tt) * mentioned in volinfo */ static void -get_vol_nfs_transport_type (glusterd_volinfo_t *volinfo, char *tt) -{ - if (volinfo->transport_type == GF_TRANSPORT_BOTH_TCP_RDMA) { - strcpy (tt, "tcp"); - gf_msg ("glusterd", GF_LOG_INFO, 0, - GD_MSG_DEFAULT_OPT_INFO, - "The default transport type for tcp,rdma volume " - "is tcp if option is not defined by the user "); - } else - transport_type_to_str (volinfo->transport_type, tt); +get_vol_nfs_transport_type(glusterd_volinfo_t *volinfo, char *tt) +{ + if (volinfo->transport_type == GF_TRANSPORT_BOTH_TCP_RDMA) { + strcpy(tt, "tcp"); + gf_msg("glusterd", GF_LOG_INFO, 0, GD_MSG_DEFAULT_OPT_INFO, + "The default transport type for tcp,rdma volume " + "is tcp if option is not defined by the user "); + } else + transport_type_to_str(volinfo->transport_type, tt); } /* gets the volinfo, dict, a character array for filling in @@ -1143,2422 +1133,2345 @@ get_vol_nfs_transport_type (glusterd_volinfo_t *volinfo, char *tt) * and client transport type is filled in the character array */ static void -get_transport_type (glusterd_volinfo_t *volinfo, dict_t *set_dict, - char *transt, gf_boolean_t is_nfs) -{ - int ret = -1; - char *tt = NULL; - char *key = NULL; - typedef void (*transport_type) (glusterd_volinfo_t *volinfo, char *tt); - transport_type get_transport; - - if (is_nfs == _gf_false) { - key = "client-transport-type"; - get_transport = get_vol_transport_type; - } else { - key = "nfs.transport-type"; - get_transport = get_vol_nfs_transport_type; - } - - ret = dict_get_str (set_dict, key, &tt); - if (ret) - get_transport (volinfo, transt); - if (!ret) - strcpy (transt, tt); +get_transport_type(glusterd_volinfo_t *volinfo, dict_t *set_dict, char *transt, + gf_boolean_t is_nfs) +{ + int ret = -1; + char *tt = NULL; + char *key = NULL; + typedef void (*transport_type)(glusterd_volinfo_t * volinfo, char *tt); + transport_type get_transport; + + if (is_nfs == _gf_false) { + key = "client-transport-type"; + get_transport = get_vol_transport_type; + } else { + key = "nfs.transport-type"; + get_transport = get_vol_nfs_transport_type; + } + + ret = dict_get_str(set_dict, key, &tt); + if (ret) + get_transport(volinfo, transt); + if (!ret) + strcpy(transt, tt); } static int -server_auth_option_handler (volgen_graph_t *graph, - struct volopt_map_entry *vme, void *param) +server_auth_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - xlator_t *xl = NULL; - char *aa = NULL; - int ret = 0; - char *key = NULL; - char *auth_path = NULL; + xlator_t *xl = NULL; + char *aa = NULL; + int ret = 0; + char *key = NULL; + char *auth_path = NULL; - if (strcmp (vme->option, "!server-auth") != 0) - return 0; + if (strcmp(vme->option, "!server-auth") != 0) + return 0; - xl = first_of (graph); + xl = first_of(graph); - /* from 'auth.allow' -> 'allow', and 'auth.reject' -> 'reject' */ - key = strchr (vme->key, '.') + 1; + /* from 'auth.allow' -> 'allow', and 'auth.reject' -> 'reject' */ + key = strchr(vme->key, '.') + 1; - ret = xlator_get_option (xl, "auth-path", &auth_path); - if (ret) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_DEFAULT_OPT_INFO, - "Failed to get auth-path from server graph"); - return -1; - } - ret = gf_asprintf (&aa, "auth.addr.%s.%s", auth_path, - key); - if (ret != -1) { - ret = xlator_set_option (xl, aa, vme->value); - GF_FREE (aa); - } - if (ret) - return -1; + ret = xlator_get_option(xl, "auth-path", &auth_path); + if (ret) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_DEFAULT_OPT_INFO, + "Failed to get auth-path from server graph"); + return -1; + } + ret = gf_asprintf(&aa, "auth.addr.%s.%s", auth_path, key); + if (ret != -1) { + ret = xlator_set_option(xl, aa, vme->value); + GF_FREE(aa); + } + if (ret) + return -1; - return 0; + return 0; } static int -loglevel_option_handler (volgen_graph_t *graph, - struct volopt_map_entry *vme, void *param) +loglevel_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - char *role = param; - struct volopt_map_entry vme2 = {0,}; + char *role = param; + struct volopt_map_entry vme2 = { + 0, + }; - if ( (strcmp (vme->option, "!client-log-level") != 0 && - strcmp (vme->option, "!brick-log-level") != 0) - || !strstr (vme->key, role)) - return 0; + if ((strcmp(vme->option, "!client-log-level") != 0 && + strcmp(vme->option, "!brick-log-level") != 0) || + !strstr(vme->key, role)) + return 0; - memcpy (&vme2, vme, sizeof (vme2)); - vme2.option = "log-level"; + memcpy(&vme2, vme, sizeof(vme2)); + vme2.option = "log-level"; - return basic_option_handler (graph, &vme2, NULL); + return basic_option_handler(graph, &vme2, NULL); } static int -server_check_changelog_off (volgen_graph_t *graph, struct volopt_map_entry *vme, - glusterd_volinfo_t *volinfo) +server_check_changelog_off(volgen_graph_t *graph, struct volopt_map_entry *vme, + glusterd_volinfo_t *volinfo) { - gf_boolean_t enabled = _gf_false; - int ret = 0; + gf_boolean_t enabled = _gf_false; + int ret = 0; - GF_ASSERT (volinfo); - GF_ASSERT (vme); + GF_ASSERT(volinfo); + GF_ASSERT(vme); - if (strcmp (vme->option, "changelog") != 0) - return 0; - - ret = gf_string2boolean (vme->value, &enabled); - if (ret || enabled) - goto out; - - ret = glusterd_volinfo_get_boolean (volinfo, VKEY_CHANGELOG); - if (ret < 0) { - gf_msg ("glusterd", GF_LOG_WARNING, 0, - GD_MSG_CHANGELOG_GET_FAIL, - "failed to get the changelog status"); - ret = -1; - goto out; - } + if (strcmp(vme->option, "changelog") != 0) + return 0; - if (ret) { - enabled = _gf_false; - glusterd_check_geo_rep_configured (volinfo, &enabled); - - if (enabled) { - gf_msg ("glusterd", GF_LOG_WARNING, 0, - GD_MSG_XLATOR_SET_OPT_FAIL, - GEOREP" sessions active" - "for the volume %s, cannot disable changelog ", - volinfo->volname); - set_graph_errstr (graph, - VKEY_CHANGELOG" cannot be disabled " - "while "GEOREP" sessions exist"); - ret = -1; - goto out; - } - } + ret = gf_string2boolean(vme->value, &enabled); + if (ret || enabled) + goto out; - ret = 0; - out: - gf_msg_debug ("glusterd", 0, "Returning %d", ret); - return ret; + ret = glusterd_volinfo_get_boolean(volinfo, VKEY_CHANGELOG); + if (ret < 0) { + gf_msg("glusterd", GF_LOG_WARNING, 0, GD_MSG_CHANGELOG_GET_FAIL, + "failed to get the changelog status"); + ret = -1; + goto out; + } + + if (ret) { + enabled = _gf_false; + glusterd_check_geo_rep_configured(volinfo, &enabled); + + if (enabled) { + gf_msg("glusterd", GF_LOG_WARNING, 0, GD_MSG_XLATOR_SET_OPT_FAIL, + GEOREP + " sessions active" + "for the volume %s, cannot disable changelog ", + volinfo->volname); + set_graph_errstr(graph, VKEY_CHANGELOG + " cannot be disabled " + "while " GEOREP " sessions exist"); + ret = -1; + goto out; + } + } + + ret = 0; +out: + gf_msg_debug("glusterd", 0, "Returning %d", ret); + return ret; } static int -server_check_marker_off (volgen_graph_t *graph, struct volopt_map_entry *vme, - glusterd_volinfo_t *volinfo) +server_check_marker_off(volgen_graph_t *graph, struct volopt_map_entry *vme, + glusterd_volinfo_t *volinfo) { - gf_boolean_t enabled = _gf_false; - int ret = 0; + gf_boolean_t enabled = _gf_false; + int ret = 0; - GF_ASSERT (volinfo); - GF_ASSERT (vme); + GF_ASSERT(volinfo); + GF_ASSERT(vme); - if (strcmp (vme->option, "!xtime") != 0) - return 0; - - ret = gf_string2boolean (vme->value, &enabled); - if (ret || enabled) - goto out; - - ret = glusterd_volinfo_get_boolean (volinfo, VKEY_MARKER_XTIME); - if (ret < 0) { - gf_msg ("glusterd", GF_LOG_WARNING, 0, - GD_MSG_MARKER_STATUS_GET_FAIL, - "failed to get the marker status"); - ret = -1; - goto out; - } - - if (ret) { - enabled = _gf_false; - glusterd_check_geo_rep_configured (volinfo, &enabled); - - if (enabled) { - gf_msg ("glusterd", GF_LOG_WARNING, 0, - GD_MSG_MARKER_DISABLE_FAIL, - GEOREP" sessions active" - "for the volume %s, cannot disable marker " - ,volinfo->volname); - set_graph_errstr (graph, - VKEY_MARKER_XTIME" cannot be disabled " - "while "GEOREP" sessions exist"); - ret = -1; - goto out; - } - } + if (strcmp(vme->option, "!xtime") != 0) + return 0; - ret = 0; - out: - gf_msg_debug ("glusterd", 0, "Returning %d", ret); - return ret; + ret = gf_string2boolean(vme->value, &enabled); + if (ret || enabled) + goto out; + ret = glusterd_volinfo_get_boolean(volinfo, VKEY_MARKER_XTIME); + if (ret < 0) { + gf_msg("glusterd", GF_LOG_WARNING, 0, GD_MSG_MARKER_STATUS_GET_FAIL, + "failed to get the marker status"); + ret = -1; + goto out; + } + + if (ret) { + enabled = _gf_false; + glusterd_check_geo_rep_configured(volinfo, &enabled); + + if (enabled) { + gf_msg("glusterd", GF_LOG_WARNING, 0, GD_MSG_MARKER_DISABLE_FAIL, + GEOREP + " sessions active" + "for the volume %s, cannot disable marker ", + volinfo->volname); + set_graph_errstr(graph, VKEY_MARKER_XTIME + " cannot be disabled " + "while " GEOREP " sessions exist"); + ret = -1; + goto out; + } + } + + ret = 0; +out: + gf_msg_debug("glusterd", 0, "Returning %d", ret); + return ret; } static int -sys_loglevel_option_handler (volgen_graph_t *graph, - struct volopt_map_entry *vme, - void *param) +sys_loglevel_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - char *role = NULL; - struct volopt_map_entry vme2 = {0,}; + char *role = NULL; + struct volopt_map_entry vme2 = { + 0, + }; - role = (char *) param; + role = (char *)param; - if (strcmp (vme->option, "!sys-log-level") != 0 || - !strstr (vme->key, role)) - return 0; + if (strcmp(vme->option, "!sys-log-level") != 0 || !strstr(vme->key, role)) + return 0; - memcpy (&vme2, vme, sizeof (vme2)); - vme2.option = "sys-log-level"; + memcpy(&vme2, vme, sizeof(vme2)); + vme2.option = "sys-log-level"; - return basic_option_handler (graph, &vme2, NULL); + return basic_option_handler(graph, &vme2, NULL); } static int -logger_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, - void *param) +logger_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - char *role = NULL; - struct volopt_map_entry vme2 = {0,}; + char *role = NULL; + struct volopt_map_entry vme2 = { + 0, + }; - role = (char *) param; + role = (char *)param; - if (strcmp (vme->option, "!logger") != 0 || - !strstr (vme->key, role)) - return 0; + if (strcmp(vme->option, "!logger") != 0 || !strstr(vme->key, role)) + return 0; - memcpy (&vme2, vme, sizeof (vme2)); - vme2.option = "logger"; + memcpy(&vme2, vme, sizeof(vme2)); + vme2.option = "logger"; - return basic_option_handler (graph, &vme2, NULL); + return basic_option_handler(graph, &vme2, NULL); } static int -log_format_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, - void *param) +log_format_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - char *role = NULL; - struct volopt_map_entry vme2 = {0,}; + char *role = NULL; + struct volopt_map_entry vme2 = { + 0, + }; - role = (char *) param; + role = (char *)param; - if (strcmp (vme->option, "!log-format") != 0 || - !strstr (vme->key, role)) - return 0; + if (strcmp(vme->option, "!log-format") != 0 || !strstr(vme->key, role)) + return 0; - memcpy (&vme2, vme, sizeof (vme2)); - vme2.option = "log-format"; + memcpy(&vme2, vme, sizeof(vme2)); + vme2.option = "log-format"; - return basic_option_handler (graph, &vme2, NULL); + return basic_option_handler(graph, &vme2, NULL); } static int -log_localtime_logging_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, - void *param) +log_localtime_logging_option_handler(volgen_graph_t *graph, + struct volopt_map_entry *vme, void *param) { - char *role = NULL; - struct volopt_map_entry vme2 = {0,}; + char *role = NULL; + struct volopt_map_entry vme2 = { + 0, + }; - role = (char *) param; + role = (char *)param; - if (strcmp (vme->option, "!cluster.localtime-logging") != 0 || - !strstr (vme->key, role)) - return 0; + if (strcmp(vme->option, "!cluster.localtime-logging") != 0 || + !strstr(vme->key, role)) + return 0; - memcpy (&vme2, vme, sizeof (vme2)); - vme2.option = GLUSTERD_LOCALTIME_LOGGING_KEY; + memcpy(&vme2, vme, sizeof(vme2)); + vme2.option = GLUSTERD_LOCALTIME_LOGGING_KEY; - return basic_option_handler (graph, &vme2, NULL); + return basic_option_handler(graph, &vme2, NULL); } static int -log_buf_size_option_handler (volgen_graph_t *graph, - struct volopt_map_entry *vme, - void *param) +log_buf_size_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - char *role = NULL; - struct volopt_map_entry vme2 = {0,}; + char *role = NULL; + struct volopt_map_entry vme2 = { + 0, + }; - role = (char *) param; + role = (char *)param; - if (strcmp (vme->option, "!log-buf-size") != 0 || - !strstr (vme->key, role)) - return 0; + if (strcmp(vme->option, "!log-buf-size") != 0 || !strstr(vme->key, role)) + return 0; - memcpy (&vme2, vme, sizeof (vme2)); - vme2.option = "log-buf-size"; + memcpy(&vme2, vme, sizeof(vme2)); + vme2.option = "log-buf-size"; - return basic_option_handler (graph, &vme2, NULL); + return basic_option_handler(graph, &vme2, NULL); } static int -log_flush_timeout_option_handler (volgen_graph_t *graph, - struct volopt_map_entry *vme, - void *param) +log_flush_timeout_option_handler(volgen_graph_t *graph, + struct volopt_map_entry *vme, void *param) { - char *role = NULL; - struct volopt_map_entry vme2 = {0,}; + char *role = NULL; + struct volopt_map_entry vme2 = { + 0, + }; - role = (char *) param; + role = (char *)param; - if (strcmp (vme->option, "!log-flush-timeout") != 0 || - !strstr (vme->key, role)) - return 0; + if (strcmp(vme->option, "!log-flush-timeout") != 0 || + !strstr(vme->key, role)) + return 0; - memcpy (&vme2, vme, sizeof (vme2)); - vme2.option = "log-flush-timeout"; + memcpy(&vme2, vme, sizeof(vme2)); + vme2.option = "log-flush-timeout"; - return basic_option_handler (graph, &vme2, NULL); + return basic_option_handler(graph, &vme2, NULL); } static int -volgen_graph_set_xl_options (volgen_graph_t *graph, dict_t *dict) -{ - int32_t ret = -1; - char *xlator = NULL; - char xlator_match[1024] = {0,}; /* for posix* -> *posix* */ - char *loglevel = NULL; - xlator_t *trav = NULL; - - ret = dict_get_str (dict, "xlator", &xlator); - if (ret) - goto out; - - ret = dict_get_str (dict, "loglevel", &loglevel); - if (ret) - goto out; - - snprintf (xlator_match, 1024, "*%s", xlator); - - for (trav = first_of (graph); trav; trav = trav->next) { - if (fnmatch(xlator_match, trav->type, FNM_NOESCAPE) == 0) { - gf_msg_debug ("glusterd", 0, - "Setting log level for xlator: %s", - trav->type); - ret = xlator_set_option (trav, "log-level", loglevel); - if (ret) - break; - } +volgen_graph_set_xl_options(volgen_graph_t *graph, dict_t *dict) +{ + int32_t ret = -1; + char *xlator = NULL; + char xlator_match[1024] = { + 0, + }; /* for posix* -> *posix* */ + char *loglevel = NULL; + xlator_t *trav = NULL; + + ret = dict_get_str(dict, "xlator", &xlator); + if (ret) + goto out; + + ret = dict_get_str(dict, "loglevel", &loglevel); + if (ret) + goto out; + + snprintf(xlator_match, 1024, "*%s", xlator); + + for (trav = first_of(graph); trav; trav = trav->next) { + if (fnmatch(xlator_match, trav->type, FNM_NOESCAPE) == 0) { + gf_msg_debug("glusterd", 0, "Setting log level for xlator: %s", + trav->type); + ret = xlator_set_option(trav, "log-level", loglevel); + if (ret) + break; } + } - out: - return ret; +out: + return ret; } static int -server_spec_option_handler (volgen_graph_t *graph, - struct volopt_map_entry *vme, void *param) +server_spec_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - int ret = 0; - glusterd_volinfo_t *volinfo = NULL; + int ret = 0; + glusterd_volinfo_t *volinfo = NULL; - volinfo = param; + volinfo = param; - ret = server_auth_option_handler (graph, vme, NULL); - if (!ret) - ret = server_check_marker_off (graph, vme, volinfo); + ret = server_auth_option_handler(graph, vme, NULL); + if (!ret) + ret = server_check_marker_off(graph, vme, volinfo); - if (!ret) - ret = server_check_changelog_off (graph, vme, volinfo); + if (!ret) + ret = server_check_changelog_off(graph, vme, volinfo); - if (!ret) - ret = loglevel_option_handler (graph, vme, "brick"); + if (!ret) + ret = loglevel_option_handler(graph, vme, "brick"); - if (!ret) - ret = sys_loglevel_option_handler (graph, vme, "brick"); + if (!ret) + ret = sys_loglevel_option_handler(graph, vme, "brick"); - if (!ret) - ret = logger_option_handler (graph, vme, "brick"); + if (!ret) + ret = logger_option_handler(graph, vme, "brick"); - if (!ret) - ret = log_format_option_handler (graph, vme, "brick"); + if (!ret) + ret = log_format_option_handler(graph, vme, "brick"); - if (!ret) - ret = log_buf_size_option_handler (graph, vme, "brick"); + if (!ret) + ret = log_buf_size_option_handler(graph, vme, "brick"); - if (!ret) - ret = log_flush_timeout_option_handler (graph, vme, "brick"); + if (!ret) + ret = log_flush_timeout_option_handler(graph, vme, "brick"); - if (!ret) - ret = log_localtime_logging_option_handler (graph, vme, "brick"); + if (!ret) + ret = log_localtime_logging_option_handler(graph, vme, "brick"); - return ret; + return ret; } static int -server_spec_extended_option_handler (volgen_graph_t *graph, - struct volopt_map_entry *vme, void *param) +server_spec_extended_option_handler(volgen_graph_t *graph, + struct volopt_map_entry *vme, void *param) { - int ret = 0; - dict_t *dict = NULL; + int ret = 0; + dict_t *dict = NULL; - GF_ASSERT (param); - dict = (dict_t *)param; + GF_ASSERT(param); + dict = (dict_t *)param; - ret = server_auth_option_handler (graph, vme, NULL); - if (!ret) - ret = volgen_graph_set_xl_options (graph, dict); + ret = server_auth_option_handler(graph, vme, NULL); + if (!ret) + ret = volgen_graph_set_xl_options(graph, dict); - return ret; + return ret; } -static void get_vol_tstamp_file (char *filename, glusterd_volinfo_t *volinfo); +static void +get_vol_tstamp_file(char *filename, glusterd_volinfo_t *volinfo); static int -gfproxy_server_graph_builder (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - dict_t *set_dict, void *param) -{ - xlator_t *xl = NULL; - /*char *value = NULL;*/ - char transt[16] = {0, }; - char key[1024] = {0, }; - /*char port_str[7] = {0, };*/ - int ret = 0; - char *username = NULL; - char *password = NULL; - /*int rclusters = 0;*/ - - /* We are a trusted client */ - ret = dict_set_uint32 (set_dict, "trusted-client", GF_CLIENT_TRUSTED); - if (ret != 0) - goto out; +gfproxy_server_graph_builder(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, void *param) +{ + xlator_t *xl = NULL; + /*char *value = NULL;*/ + char transt[16] = { + 0, + }; + char key[1024] = { + 0, + }; + /*char port_str[7] = {0, };*/ + int ret = 0; + char *username = NULL; + char *password = NULL; + /*int rclusters = 0;*/ + + /* We are a trusted client */ + ret = dict_set_uint32(set_dict, "trusted-client", GF_CLIENT_TRUSTED); + if (ret != 0) + goto out; + + ret = dict_set_int32n(set_dict, "gfproxy-server", SLEN("gfproxy-server"), + 1); + if (ret != 0) + goto out; + + /* Build the client section of the graph first */ + build_client_graph(graph, volinfo, set_dict); + + /* Clear this setting so that future users of set_dict do not end up + * thinking they are a gfproxy server */ + dict_deln(set_dict, "gfproxy-server", SLEN("gfproxy-server")); + dict_deln(set_dict, "trusted-client", SLEN("trusted-client")); + + /* Then add the server to it */ + get_vol_transport_type(volinfo, transt); + xl = volgen_graph_add(graph, "protocol/server", volinfo->volname); + if (!xl) + goto out; + + ret = xlator_set_option(xl, "transport-type", transt); + if (ret != 0) + goto out; + + /* Set username and password */ + username = glusterd_auth_get_username(volinfo); + password = glusterd_auth_get_password(volinfo); + if (username) { + snprintf(key, sizeof(key), "auth.login.gfproxyd-%s.allow", + volinfo->volname); + ret = xlator_set_option(xl, key, username); + if (ret) + return -1; + } - ret = dict_set_int32n (set_dict, "gfproxy-server", - SLEN ("gfproxy-server"), 1); + if (password) { + snprintf(key, sizeof(key), "auth.login.%s.password", username); + ret = xlator_set_option(xl, key, password); if (ret != 0) - goto out; - - /* Build the client section of the graph first */ - build_client_graph (graph, volinfo, set_dict); + goto out; + } - /* Clear this setting so that future users of set_dict do not end up - * thinking they are a gfproxy server */ - dict_deln (set_dict, "gfproxy-server", SLEN ("gfproxy-server")); - dict_deln (set_dict, "trusted-client", SLEN ("trusted-client")); - - /* Then add the server to it */ - get_vol_transport_type (volinfo, transt); - xl = volgen_graph_add (graph, "protocol/server", volinfo->volname); - if (!xl) - goto out; - - ret = xlator_set_option (xl, "transport-type", transt); - if (ret != 0) - goto out; - - /* Set username and password */ - username = glusterd_auth_get_username (volinfo); - password = glusterd_auth_get_password (volinfo); - if (username) { - snprintf (key, sizeof (key), - "auth.login.gfproxyd-%s.allow", - volinfo->volname); - ret = xlator_set_option (xl, key, username); - if (ret) - return -1; - } - - if (password) { - snprintf (key, sizeof (key), "auth.login.%s.password", - username); - ret = xlator_set_option (xl, key, password); - if (ret != 0) - goto out; - } - - snprintf (key, sizeof (key), "gfproxyd-%s", volinfo->volname); - ret = xlator_set_option (xl, "auth-path", key); + snprintf(key, sizeof(key), "gfproxyd-%s", volinfo->volname); + ret = xlator_set_option(xl, "auth-path", key); out: - return ret; + return ret; } static int -brick_graph_add_posix (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_posix(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - char tmpstr[10] = {0,}; - int ret = -1; - gf_boolean_t quota_enabled = _gf_true; - gf_boolean_t trash_enabled = _gf_false; - gf_boolean_t pgfid_feat = _gf_false; - char *value = NULL; - xlator_t *xl = NULL; - - if (!graph || !volinfo || !set_dict || !brickinfo) - goto out; - - ret = glusterd_volinfo_get (volinfo, VKEY_FEATURES_QUOTA, &value); - if (value) { - ret = gf_string2boolean (value, "a_enabled); - if (ret) - goto out; - } + char tmpstr[10] = { + 0, + }; + int ret = -1; + gf_boolean_t quota_enabled = _gf_true; + gf_boolean_t trash_enabled = _gf_false; + gf_boolean_t pgfid_feat = _gf_false; + char *value = NULL; + xlator_t *xl = NULL; + + if (!graph || !volinfo || !set_dict || !brickinfo) + goto out; + + ret = glusterd_volinfo_get(volinfo, VKEY_FEATURES_QUOTA, &value); + if (value) { + ret = gf_string2boolean(value, "a_enabled); + if (ret) + goto out; + } - ret = glusterd_volinfo_get (volinfo, VKEY_FEATURES_TRASH, &value); - if (value) { - ret = gf_string2boolean (value, &trash_enabled); - if (ret) - goto out; - } + ret = glusterd_volinfo_get(volinfo, VKEY_FEATURES_TRASH, &value); + if (value) { + ret = gf_string2boolean(value, &trash_enabled); + if (ret) + goto out; + } - ret = glusterd_volinfo_get (volinfo, - "update-link-count-parent", - &value); - if (value) { - ret = gf_string2boolean (value, &pgfid_feat); - if (ret) - goto out; - } + ret = glusterd_volinfo_get(volinfo, "update-link-count-parent", &value); + if (value) { + ret = gf_string2boolean(value, &pgfid_feat); + if (ret) + goto out; + } - ret = -1; + ret = -1; - xl = volgen_graph_add (graph, "storage/posix", volinfo->volname); - if (!xl) - goto out; + xl = volgen_graph_add(graph, "storage/posix", volinfo->volname); + if (!xl) + goto out; - ret = xlator_set_option (xl, "directory", brickinfo->path); - if (ret) - goto out; + ret = xlator_set_option(xl, "directory", brickinfo->path); + if (ret) + goto out; - ret = xlator_set_option (xl, "volume-id", - uuid_utoa (volinfo->volume_id)); - if (ret) - goto out; + ret = xlator_set_option(xl, "volume-id", uuid_utoa(volinfo->volume_id)); + if (ret) + goto out; - if (quota_enabled || pgfid_feat || trash_enabled) { - ret = xlator_set_option (xl, "update-link-count-parent", - "on"); - if (ret) { - goto out; - } + if (quota_enabled || pgfid_feat || trash_enabled) { + ret = xlator_set_option(xl, "update-link-count-parent", "on"); + if (ret) { + goto out; } + } - snprintf (tmpstr, sizeof (tmpstr), "%d", brickinfo->fs_share_count); - ret = xlator_set_option (xl, "shared-brick-count", tmpstr); + snprintf(tmpstr, sizeof(tmpstr), "%d", brickinfo->fs_share_count); + ret = xlator_set_option(xl, "shared-brick-count", tmpstr); out: - return ret; + return ret; } static int -brick_graph_add_selinux (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_selinux(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - xlator_t *xl = NULL; - int ret = -1; + xlator_t *xl = NULL; + int ret = -1; - if (!graph || !volinfo) - goto out; + if (!graph || !volinfo) + goto out; - xl = volgen_graph_add (graph, "features/selinux", volinfo->volname); - if (!xl) - goto out; + xl = volgen_graph_add(graph, "features/selinux", volinfo->volname); + if (!xl) + goto out; - ret = 0; + ret = 0; out: - return ret; + return ret; } static int -brick_graph_add_trash (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_trash(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - int ret = -1; - xlator_t *xl = NULL; - - xl = volgen_graph_add (graph, "features/trash", volinfo->volname); - if (!xl) - goto out; - ret = xlator_set_option (xl, "trash-dir", ".trashcan"); - if (ret) - goto out; - ret = xlator_set_option (xl, "brick-path", brickinfo->path); - if (ret) - goto out; - ret = xlator_set_option (xl, "trash-internal-op", "off"); - if (ret) - goto out; + int ret = -1; + xlator_t *xl = NULL; + + xl = volgen_graph_add(graph, "features/trash", volinfo->volname); + if (!xl) + goto out; + ret = xlator_set_option(xl, "trash-dir", ".trashcan"); + if (ret) + goto out; + ret = xlator_set_option(xl, "brick-path", brickinfo->path); + if (ret) + goto out; + ret = xlator_set_option(xl, "trash-internal-op", "off"); + if (ret) + goto out; out: - return ret; + return ret; } static int -brick_graph_add_decompounder (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) -{ - xlator_t *xl = NULL; - xlator_t *this = NULL; - glusterd_conf_t *conf = NULL; - int ret = -1; - - this = THIS; - GF_VALIDATE_OR_GOTO ("glusterd", this, out); - conf = this->private; - GF_VALIDATE_OR_GOTO (this->name, conf, out); - - xl = volgen_graph_add_as (graph, "performance/decompounder", - brickinfo->path); - if (xl) - ret = 0; +brick_graph_add_decompounder(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +{ + xlator_t *xl = NULL; + xlator_t *this = NULL; + glusterd_conf_t *conf = NULL; + int ret = -1; + + this = THIS; + GF_VALIDATE_OR_GOTO("glusterd", this, out); + conf = this->private; + GF_VALIDATE_OR_GOTO(this->name, conf, out); + + xl = volgen_graph_add_as(graph, "performance/decompounder", + brickinfo->path); + if (xl) + ret = 0; out: - return ret; + return ret; } static int -brick_graph_add_arbiter (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_arbiter(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - xlator_t *xl = NULL; - glusterd_brickinfo_t *last = NULL; - int ret = -1; + xlator_t *xl = NULL; + glusterd_brickinfo_t *last = NULL; + int ret = -1; - if (volinfo->arbiter_count != 1) - return 0; + if (volinfo->arbiter_count != 1) + return 0; - /* Add arbiter only if it is the last (i.e. 3rd) brick. */ - last = get_last_brick_of_brick_group (volinfo, brickinfo); - if (last != brickinfo) - return 0; + /* Add arbiter only if it is the last (i.e. 3rd) brick. */ + last = get_last_brick_of_brick_group(volinfo, brickinfo); + if (last != brickinfo) + return 0; - xl = volgen_graph_add (graph, "features/arbiter", volinfo->volname); - if (!xl) - goto out; - ret = 0; + xl = volgen_graph_add(graph, "features/arbiter", volinfo->volname); + if (!xl) + goto out; + ret = 0; out: - return ret; + return ret; } static int -brick_graph_add_bd (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_bd(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - int ret = -1; + int ret = -1; - if (!graph || !volinfo || !set_dict || !brickinfo) - goto out; + if (!graph || !volinfo || !set_dict || !brickinfo) + goto out; - ret = 0; + ret = 0; #ifdef HAVE_BD_XLATOR - if (*brickinfo->vg != '\0') { - xlator_t *xl = NULL; - /* Now add BD v2 xlator if volume is BD type */ - xl = volgen_graph_add (graph, "storage/bd", volinfo->volname); - if (!xl) { - ret = -1; - goto out; - } + if (*brickinfo->vg != '\0') { + xlator_t *xl = NULL; + /* Now add BD v2 xlator if volume is BD type */ + xl = volgen_graph_add(graph, "storage/bd", volinfo->volname); + if (!xl) { + ret = -1; + goto out; + } - ret = xlator_set_option (xl, "device", "vg"); - if (ret) - goto out; + ret = xlator_set_option(xl, "device", "vg"); + if (ret) + goto out; - ret = xlator_set_option (xl, "export", brickinfo->vg); - if (ret) - goto out; - } + ret = xlator_set_option(xl, "export", brickinfo->vg); + if (ret) + goto out; + } #endif out: - return ret; + return ret; } static int -brick_graph_add_bitrot_stub (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, +brick_graph_add_bitrot_stub(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - xlator_t *xl = NULL; - int ret = -1; - char *value = NULL; - xlator_t *this = THIS; - - if (!graph || !volinfo || !set_dict || !brickinfo) - goto out; - - xl = volgen_graph_add (graph, "features/bitrot-stub", volinfo->volname); - if (!xl) - goto out; - - ret = xlator_set_option (xl, "export", brickinfo->path); - if (ret) { - gf_log (this->name, GF_LOG_WARNING, "failed to set the export " - "option in bit-rot-stub"); - goto out; - } - - ret = glusterd_volinfo_get (volinfo, VKEY_FEATURES_BITROT, &value); - ret = xlator_set_option (xl, "bitrot", value); - if (ret) - gf_log (this->name, GF_LOG_WARNING, "failed to set bitrot " - "enable option in bit-rot-stub"); + xlator_t *xl = NULL; + int ret = -1; + char *value = NULL; + xlator_t *this = THIS; + + if (!graph || !volinfo || !set_dict || !brickinfo) + goto out; + + xl = volgen_graph_add(graph, "features/bitrot-stub", volinfo->volname); + if (!xl) + goto out; + + ret = xlator_set_option(xl, "export", brickinfo->path); + if (ret) { + gf_log(this->name, GF_LOG_WARNING, + "failed to set the export " + "option in bit-rot-stub"); + goto out; + } + + ret = glusterd_volinfo_get(volinfo, VKEY_FEATURES_BITROT, &value); + ret = xlator_set_option(xl, "bitrot", value); + if (ret) + gf_log(this->name, GF_LOG_WARNING, + "failed to set bitrot " + "enable option in bit-rot-stub"); out: - return ret; + return ret; } static int -brick_graph_add_changelog (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) -{ - xlator_t *xl = NULL; - char changelog_basepath[PATH_MAX] = {0,}; - int ret = -1; - int32_t len = 0; - - if (!graph || !volinfo || !set_dict || !brickinfo) - goto out; - - xl = volgen_graph_add (graph, "features/changelog", volinfo->volname); - if (!xl) - goto out; - - ret = xlator_set_option (xl, "changelog-brick", brickinfo->path); - if (ret) - goto out; - - len = snprintf (changelog_basepath, sizeof (changelog_basepath), - "%s/%s", brickinfo->path, ".glusterfs/changelogs"); - if ((len < 0) || (len >= sizeof(changelog_basepath))) { - ret = -1; - goto out; - } - ret = xlator_set_option (xl, "changelog-dir", changelog_basepath); - if (ret) - goto out; +brick_graph_add_changelog(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +{ + xlator_t *xl = NULL; + char changelog_basepath[PATH_MAX] = { + 0, + }; + int ret = -1; + int32_t len = 0; + + if (!graph || !volinfo || !set_dict || !brickinfo) + goto out; + + xl = volgen_graph_add(graph, "features/changelog", volinfo->volname); + if (!xl) + goto out; + + ret = xlator_set_option(xl, "changelog-brick", brickinfo->path); + if (ret) + goto out; + + len = snprintf(changelog_basepath, sizeof(changelog_basepath), "%s/%s", + brickinfo->path, ".glusterfs/changelogs"); + if ((len < 0) || (len >= sizeof(changelog_basepath))) { + ret = -1; + goto out; + } + ret = xlator_set_option(xl, "changelog-dir", changelog_basepath); + if (ret) + goto out; out: - return ret; + return ret; } #if USE_GFDB /* only add changetimerecorder when GFDB is enabled */ static int -brick_graph_add_changetimerecorder (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - dict_t *set_dict, - glusterd_brickinfo_t *brickinfo) -{ - xlator_t *xl = NULL; - int ret = -1; - char *brickname = NULL; - char *path = NULL; - char index_basepath[PATH_MAX] = {0}; - char *hotbrick = NULL; - - if (!graph || !volinfo || !set_dict || !brickinfo) - goto out; +brick_graph_add_changetimerecorder(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, + dict_t *set_dict, + glusterd_brickinfo_t *brickinfo) +{ + xlator_t *xl = NULL; + int ret = -1; + char *brickname = NULL; + char *path = NULL; + char index_basepath[PATH_MAX] = {0}; + char *hotbrick = NULL; - path = brickinfo->path; + if (!graph || !volinfo || !set_dict || !brickinfo) + goto out; - xl = volgen_graph_add (graph, "features/changetimerecorder", - volinfo->volname); - if (!xl) - goto out; + path = brickinfo->path; + xl = volgen_graph_add(graph, "features/changetimerecorder", + volinfo->volname); + if (!xl) + goto out; - ret = xlator_set_option (xl, "db-type", "sqlite3"); - if (ret) - goto out; + ret = xlator_set_option(xl, "db-type", "sqlite3"); + if (ret) + goto out; - if (!set_dict || dict_get_str (set_dict, "hot-brick", &hotbrick)) - hotbrick = "off"; + if (!set_dict || dict_get_str(set_dict, "hot-brick", &hotbrick)) + hotbrick = "off"; - ret = xlator_set_option (xl, "hot-brick", hotbrick); - if (ret) - goto out; + ret = xlator_set_option(xl, "hot-brick", hotbrick); + if (ret) + goto out; - brickname = strrchr(path, '/') + 1; - snprintf (index_basepath, sizeof (index_basepath), "%s.db", - brickname); - ret = xlator_set_option (xl, "db-name", index_basepath); - if (ret) - goto out; + brickname = strrchr(path, '/') + 1; + snprintf(index_basepath, sizeof(index_basepath), "%s.db", brickname); + ret = xlator_set_option(xl, "db-name", index_basepath); + if (ret) + goto out; - snprintf (index_basepath, sizeof (index_basepath), "%s/%s", - path, ".glusterfs/"); - ret = xlator_set_option (xl, "db-path", index_basepath); - if (ret) - goto out; + snprintf(index_basepath, sizeof(index_basepath), "%s/%s", path, + ".glusterfs/"); + ret = xlator_set_option(xl, "db-path", index_basepath); + if (ret) + goto out; - ret = xlator_set_option (xl, "record-exit", "off"); - if (ret) - goto out; + ret = xlator_set_option(xl, "record-exit", "off"); + if (ret) + goto out; - ret = xlator_set_option (xl, "ctr_link_consistency", "off"); - if (ret) - goto out; + ret = xlator_set_option(xl, "ctr_link_consistency", "off"); + if (ret) + goto out; - ret = xlator_set_option (xl, "ctr_lookupheal_link_timeout", "300"); - if (ret) - goto out; + ret = xlator_set_option(xl, "ctr_lookupheal_link_timeout", "300"); + if (ret) + goto out; - ret = xlator_set_option (xl, "ctr_lookupheal_inode_timeout", "300"); - if (ret) - goto out; + ret = xlator_set_option(xl, "ctr_lookupheal_inode_timeout", "300"); + if (ret) + goto out; - ret = xlator_set_option (xl, "record-entry", "on"); - if (ret) - goto out; + ret = xlator_set_option(xl, "record-entry", "on"); + if (ret) + goto out; out: - return ret; + return ret; } #endif /* USE_GFDB */ static int -brick_graph_add_acl (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_acl(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - xlator_t *xl = NULL; - int ret = -1; + xlator_t *xl = NULL; + int ret = -1; - if (!graph || !volinfo || !set_dict) - goto out; + if (!graph || !volinfo || !set_dict) + goto out; - xl = volgen_graph_add (graph, "features/access-control", - volinfo->volname); - if (!xl) - goto out; + xl = volgen_graph_add(graph, "features/access-control", volinfo->volname); + if (!xl) + goto out; - ret = 0; + ret = 0; out: - return ret; + return ret; } static int -brick_graph_add_locks (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_locks(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { + xlator_t *xl = NULL; + int ret = -1; - xlator_t *xl = NULL; - int ret = -1; + if (!graph || !volinfo || !set_dict) + goto out; - if (!graph || !volinfo || !set_dict) - goto out; - - xl = volgen_graph_add (graph, "features/locks", - volinfo->volname); - if (!xl) - goto out; + xl = volgen_graph_add(graph, "features/locks", volinfo->volname); + if (!xl) + goto out; - ret = 0; + ret = 0; out: - return ret; + return ret; } /* Add this before (above) io-threads because it's not thread-safe yet. */ static int -brick_graph_add_fdl (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_fdl(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { + xlator_t *xl = NULL; + int ret = -1; - xlator_t *xl = NULL; - int ret = -1; + if (!graph || !volinfo || !set_dict) + goto out; - if (!graph || !volinfo || !set_dict) - goto out; - - if (dict_get_str_boolean (set_dict, "features.fdl", 0)) { - xl = volgen_graph_add (graph, "experimental/fdl", - volinfo->volname); - if (!xl) - goto out; - } - ret = 0; + if (dict_get_str_boolean(set_dict, "features.fdl", 0)) { + xl = volgen_graph_add(graph, "experimental/fdl", volinfo->volname); + if (!xl) + goto out; + } + ret = 0; out: - return ret; + return ret; } static int -brick_graph_add_iot (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_iot(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { + xlator_t *xl = NULL; + int ret = -1; - xlator_t *xl = NULL; - int ret = -1; + if (!graph || !volinfo || !set_dict) + goto out; - if (!graph || !volinfo || !set_dict) - goto out; - - xl = volgen_graph_add (graph, "performance/io-threads", - volinfo->volname); - if (!xl) - goto out; - ret = 0; + xl = volgen_graph_add(graph, "performance/io-threads", volinfo->volname); + if (!xl) + goto out; + ret = 0; out: - return ret; + return ret; } static int -brick_graph_add_barrier (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_barrier(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { + xlator_t *xl = NULL; + int ret = -1; - xlator_t *xl = NULL; - int ret = -1; + if (!graph || !volinfo) + goto out; - if (!graph || !volinfo) - goto out; - - xl = volgen_graph_add (graph, "features/barrier", volinfo->volname); - if (!xl) - goto out; + xl = volgen_graph_add(graph, "features/barrier", volinfo->volname); + if (!xl) + goto out; - ret = 0; + ret = 0; out: - return ret; + return ret; } static int -brick_graph_add_sdfs (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_sdfs(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - xlator_t *xl = NULL; - int ret = -1; + xlator_t *xl = NULL; + int ret = -1; - if (!graph || !volinfo) - goto out; + if (!graph || !volinfo) + goto out; - if (!dict_get_str_boolean (set_dict, "features.sdfs", 0)) { - /* update only if option is enabled */ - ret = 0; - goto out; - } + if (!dict_get_str_boolean(set_dict, "features.sdfs", 0)) { + /* update only if option is enabled */ + ret = 0; + goto out; + } - xl = volgen_graph_add (graph, "features/sdfs", volinfo->volname); - if (!xl) - goto out; + xl = volgen_graph_add(graph, "features/sdfs", volinfo->volname); + if (!xl) + goto out; - ret = 0; + ret = 0; out: - return ret; + return ret; } static int -brick_graph_add_namespace (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_namespace(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - xlator_t *xl = NULL; - int ret = -1; + xlator_t *xl = NULL; + int ret = -1; - if (!graph || !volinfo || !set_dict) - goto out; + if (!graph || !volinfo || !set_dict) + goto out; - ret = dict_get_str_boolean (set_dict, "features.tag-namespaces", 0); - if (ret == -1) - goto out; + ret = dict_get_str_boolean(set_dict, "features.tag-namespaces", 0); + if (ret == -1) + goto out; - if (ret) { - xl = volgen_graph_add (graph, "features/namespace", volinfo->volname); - if (!xl) - goto out; - } + if (ret) { + xl = volgen_graph_add(graph, "features/namespace", volinfo->volname); + if (!xl) + goto out; + } - ret = 0; + ret = 0; out: - return ret; + return ret; } xlator_t * -add_one_peer (volgen_graph_t *graph, glusterd_brickinfo_t *peer, - char *volname, uint16_t index) +add_one_peer(volgen_graph_t *graph, glusterd_brickinfo_t *peer, char *volname, + uint16_t index) { - xlator_t *kid; + xlator_t *kid; - kid = volgen_graph_add_nolink (graph, "protocol/client", - "%s-client-%u", volname, - index++); - if (!kid) { - return NULL; - } + kid = volgen_graph_add_nolink(graph, "protocol/client", "%s-client-%u", + volname, index++); + if (!kid) { + return NULL; + } - /* TBD: figure out where to get the proper transport list */ - if (xlator_set_option(kid, "transport-type", "socket")) { - return NULL; - } - if (xlator_set_option(kid, "remote-host", peer->hostname)) { - return NULL; - } - if (xlator_set_option(kid, "remote-subvolume", peer->path)) { - return NULL; - } - /* TBD: deal with RDMA, SSL */ + /* TBD: figure out where to get the proper transport list */ + if (xlator_set_option(kid, "transport-type", "socket")) { + return NULL; + } + if (xlator_set_option(kid, "remote-host", peer->hostname)) { + return NULL; + } + if (xlator_set_option(kid, "remote-subvolume", peer->path)) { + return NULL; + } + /* TBD: deal with RDMA, SSL */ - return kid; + return kid; } int -add_jbr_stuff (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - glusterd_brickinfo_t *brickinfo) -{ - xlator_t *me; - glusterd_brickinfo_t *peer; - glusterd_brickinfo_t *prev_peer; - char *leader_opt; - uint16_t index = 0; - xlator_t *kid; - - /* Create the JBR xlator, but defer linkage for now. */ - me = xlator_instantiate ("experimental/jbr", "%s-jbr", - volinfo->volname); - if (!me || volgen_xlator_link(me, first_of(graph))) { - return -1; - } - - /* Figure out if we should start as leader, mark appropriately. */ - peer = list_prev (brickinfo, &volinfo->bricks, - glusterd_brickinfo_t, brick_list); - leader_opt = (!peer || (peer->group != brickinfo->group)) ? "yes" - : "no"; - if (xlator_set_option(me, "leader", leader_opt)) { - /* - * TBD: fix memory leak ("me" and associated dictionary) - * There seems to be no function already to clean up a - * just-allocated translator object if something else fails. - * Apparently the convention elsewhere in this file is to return - * without freeing anything, but we can't keep being that sloppy - * forever. - */ - return -1; - } +add_jbr_stuff(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + glusterd_brickinfo_t *brickinfo) +{ + xlator_t *me; + glusterd_brickinfo_t *peer; + glusterd_brickinfo_t *prev_peer; + char *leader_opt; + uint16_t index = 0; + xlator_t *kid; + + /* Create the JBR xlator, but defer linkage for now. */ + me = xlator_instantiate("experimental/jbr", "%s-jbr", volinfo->volname); + if (!me || volgen_xlator_link(me, first_of(graph))) { + return -1; + } + /* Figure out if we should start as leader, mark appropriately. */ + peer = list_prev(brickinfo, &volinfo->bricks, glusterd_brickinfo_t, + brick_list); + leader_opt = (!peer || (peer->group != brickinfo->group)) ? "yes" : "no"; + if (xlator_set_option(me, "leader", leader_opt)) { /* - * Make sure we're at the beginning of the list of bricks in this - * replica set. This way all bricks' volfiles have peers in a - * consistent order. + * TBD: fix memory leak ("me" and associated dictionary) + * There seems to be no function already to clean up a + * just-allocated translator object if something else fails. + * Apparently the convention elsewhere in this file is to return + * without freeing anything, but we can't keep being that sloppy + * forever. */ - peer = brickinfo; - for (;;) { - prev_peer = list_prev (peer, &volinfo->bricks, - glusterd_brickinfo_t, brick_list); - if (!prev_peer || (prev_peer->group != brickinfo->group)) { - break; - } - peer = prev_peer; + return -1; + } + + /* + * Make sure we're at the beginning of the list of bricks in this + * replica set. This way all bricks' volfiles have peers in a + * consistent order. + */ + peer = brickinfo; + for (;;) { + prev_peer = list_prev(peer, &volinfo->bricks, glusterd_brickinfo_t, + brick_list); + if (!prev_peer || (prev_peer->group != brickinfo->group)) { + break; + } + peer = prev_peer; + } + + /* Actually add the peers. */ + do { + if (peer != brickinfo) { + gf_log("glusterd", GF_LOG_INFO, "%s:%s needs client for %s:%s", + brickinfo->hostname, brickinfo->path, peer->hostname, + peer->path); + kid = add_one_peer(graph, peer, volinfo->volname, index++); + if (!kid || volgen_xlator_link(me, kid)) { + return -1; + } } + peer = list_next(peer, &volinfo->bricks, glusterd_brickinfo_t, + brick_list); + } while (peer && (peer->group == brickinfo->group)); - /* Actually add the peers. */ - do { - if (peer != brickinfo) { - gf_log ("glusterd", GF_LOG_INFO, - "%s:%s needs client for %s:%s", - brickinfo->hostname, brickinfo->path, - peer->hostname, peer->path); - kid = add_one_peer (graph, peer, - volinfo->volname, index++); - if (!kid || volgen_xlator_link(me, kid)) { - return -1; - } - } - peer = list_next (peer, &volinfo->bricks, - glusterd_brickinfo_t, brick_list); - } while (peer && (peer->group == brickinfo->group)); - - /* Finish linkage to client file. */ - glusterfs_graph_set_first(&graph->graph, me); + /* Finish linkage to client file. */ + glusterfs_graph_set_first(&graph->graph, me); - return 0; + return 0; } static int -brick_graph_add_index (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_index(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - xlator_t *xl = NULL; - char *pending_xattr = NULL; - char index_basepath[PATH_MAX] = {0}; - int ret = -1; - int32_t len = 0; - - if (!graph || !volinfo || !brickinfo || !set_dict) - goto out; - - /* For JBR we don't need/want index. */ - if (glusterd_volinfo_get_boolean(volinfo, "cluster.jbr") > 0) { - return add_jbr_stuff (graph, volinfo, brickinfo); - } - - xl = volgen_graph_add (graph, "features/index", volinfo->volname); - if (!xl) - goto out; - - len = snprintf (index_basepath, sizeof (index_basepath), "%s/%s", - brickinfo->path, ".glusterfs/indices"); - if ((len < 0) || (len >= sizeof(index_basepath))) { - goto out; - } - - ret = xlator_set_option (xl, "index-base", index_basepath); + xlator_t *xl = NULL; + char *pending_xattr = NULL; + char index_basepath[PATH_MAX] = {0}; + int ret = -1; + int32_t len = 0; + + if (!graph || !volinfo || !brickinfo || !set_dict) + goto out; + + /* For JBR we don't need/want index. */ + if (glusterd_volinfo_get_boolean(volinfo, "cluster.jbr") > 0) { + return add_jbr_stuff(graph, volinfo, brickinfo); + } + + xl = volgen_graph_add(graph, "features/index", volinfo->volname); + if (!xl) + goto out; + + len = snprintf(index_basepath, sizeof(index_basepath), "%s/%s", + brickinfo->path, ".glusterfs/indices"); + if ((len < 0) || (len >= sizeof(index_basepath))) { + goto out; + } + + ret = xlator_set_option(xl, "index-base", index_basepath); + if (ret) + goto out; + if (volinfo->type == GF_CLUSTER_TYPE_DISPERSE) { + ret = xlator_set_option(xl, "xattrop64-watchlist", "trusted.ec.dirty"); if (ret) - goto out; - if (volinfo->type == GF_CLUSTER_TYPE_DISPERSE) { - ret = xlator_set_option (xl, "xattrop64-watchlist", - "trusted.ec.dirty"); - if (ret) - goto out; - } - if ((volinfo->type == GF_CLUSTER_TYPE_STRIPE_REPLICATE || - volinfo->type == GF_CLUSTER_TYPE_REPLICATE || - volinfo->type == GF_CLUSTER_TYPE_NONE)) { - ret = xlator_set_option (xl, "xattrop-dirty-watchlist", - "trusted.afr.dirty"); - if (ret) - goto out; - ret = gf_asprintf (&pending_xattr, "trusted.afr.%s-", - volinfo->volname); - if (ret < 0) - goto out; - ret = xlator_set_option (xl, "xattrop-pending-watchlist", - pending_xattr); - if (ret) - goto out; - } + goto out; + } + if ((volinfo->type == GF_CLUSTER_TYPE_STRIPE_REPLICATE || + volinfo->type == GF_CLUSTER_TYPE_REPLICATE || + volinfo->type == GF_CLUSTER_TYPE_NONE)) { + ret = xlator_set_option(xl, "xattrop-dirty-watchlist", + "trusted.afr.dirty"); + if (ret) + goto out; + ret = gf_asprintf(&pending_xattr, "trusted.afr.%s-", volinfo->volname); + if (ret < 0) + goto out; + ret = xlator_set_option(xl, "xattrop-pending-watchlist", pending_xattr); + if (ret) + goto out; + } out: - GF_FREE (pending_xattr); - return ret; + GF_FREE(pending_xattr); + return ret; } static int -brick_graph_add_marker (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_marker(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - int ret = -1; - xlator_t *xl = NULL; - char tstamp_file[PATH_MAX] = {0,}; - char volume_id[64] = {0,}; - char buf[32] = {0,}; - - if (!graph || !volinfo || !set_dict) - goto out; - - xl = volgen_graph_add (graph, "features/marker", volinfo->volname); - if (!xl) - goto out; - - gf_uuid_unparse (volinfo->volume_id, volume_id); - ret = xlator_set_option (xl, "volume-uuid", volume_id); - if (ret) - goto out; - get_vol_tstamp_file (tstamp_file, volinfo); - ret = xlator_set_option (xl, "timestamp-file", tstamp_file); - if (ret) - goto out; - - snprintf (buf, sizeof (buf), "%d", volinfo->quota_xattr_version); - ret = xlator_set_option (xl, "quota-version", buf); - if (ret) - goto out; + int ret = -1; + xlator_t *xl = NULL; + char tstamp_file[PATH_MAX] = { + 0, + }; + char volume_id[64] = { + 0, + }; + char buf[32] = { + 0, + }; + + if (!graph || !volinfo || !set_dict) + goto out; + + xl = volgen_graph_add(graph, "features/marker", volinfo->volname); + if (!xl) + goto out; + + gf_uuid_unparse(volinfo->volume_id, volume_id); + ret = xlator_set_option(xl, "volume-uuid", volume_id); + if (ret) + goto out; + get_vol_tstamp_file(tstamp_file, volinfo); + ret = xlator_set_option(xl, "timestamp-file", tstamp_file); + if (ret) + goto out; + + snprintf(buf, sizeof(buf), "%d", volinfo->quota_xattr_version); + ret = xlator_set_option(xl, "quota-version", buf); + if (ret) + goto out; out: - return ret; + return ret; } static int -brick_graph_add_quota (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_quota(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - int ret = -1; - xlator_t *xl = NULL; - char *value = NULL; + int ret = -1; + xlator_t *xl = NULL; + char *value = NULL; - if (!graph || !volinfo || !set_dict) - goto out; + if (!graph || !volinfo || !set_dict) + goto out; - xl = volgen_graph_add (graph, "features/quota", volinfo->volname); - if (!xl) - goto out; + xl = volgen_graph_add(graph, "features/quota", volinfo->volname); + if (!xl) + goto out; - ret = xlator_set_option (xl, "volume-uuid", volinfo->volname); - if (ret) - goto out; + ret = xlator_set_option(xl, "volume-uuid", volinfo->volname); + if (ret) + goto out; - ret = glusterd_volinfo_get (volinfo, VKEY_FEATURES_QUOTA, &value); - if (value) { - ret = xlator_set_option (xl, "server-quota", value); - if (ret) - goto out; - } + ret = glusterd_volinfo_get(volinfo, VKEY_FEATURES_QUOTA, &value); + if (value) { + ret = xlator_set_option(xl, "server-quota", value); + if (ret) + goto out; + } out: - return ret; + return ret; } static int -brick_graph_add_ro (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_ro(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - int ret = -1; - xlator_t *xl = NULL; + int ret = -1; + xlator_t *xl = NULL; - if (!graph || !volinfo || !set_dict) - goto out; + if (!graph || !volinfo || !set_dict) + goto out; - if (dict_get_str_boolean (set_dict, "features.read-only", 0) && - (dict_get_str_boolean (set_dict, "features.worm", 0) || - dict_get_str_boolean (set_dict, "features.worm-file-level", 0))) { - gf_msg (THIS->name, GF_LOG_ERROR, errno, - GD_MSG_DICT_GET_FAILED, - "read-only and worm cannot be set together"); - ret = -1; - goto out; - } + if (dict_get_str_boolean(set_dict, "features.read-only", 0) && + (dict_get_str_boolean(set_dict, "features.worm", 0) || + dict_get_str_boolean(set_dict, "features.worm-file-level", 0))) { + gf_msg(THIS->name, GF_LOG_ERROR, errno, GD_MSG_DICT_GET_FAILED, + "read-only and worm cannot be set together"); + ret = -1; + goto out; + } - xl = volgen_graph_add (graph, "features/read-only", volinfo->volname); - if (!xl) - return -1; - ret = xlator_set_option (xl, "read-only", "off"); - if (ret) - return -1; + xl = volgen_graph_add(graph, "features/read-only", volinfo->volname); + if (!xl) + return -1; + ret = xlator_set_option(xl, "read-only", "off"); + if (ret) + return -1; - ret = 0; + ret = 0; out: - return ret; + return ret; } static int -brick_graph_add_worm (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_worm(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - int ret = -1; - xlator_t *xl = NULL; + int ret = -1; + xlator_t *xl = NULL; - if (!graph || !volinfo || !set_dict) - goto out; + if (!graph || !volinfo || !set_dict) + goto out; - if (dict_get_str_boolean (set_dict, "features.read-only", 0) && - (dict_get_str_boolean (set_dict, "features.worm", 0) || - dict_get_str_boolean (set_dict, "features.worm-file-level", 0))) { - gf_msg (THIS->name, GF_LOG_ERROR, 0, - GD_MSG_INCOMPATIBLE_VALUE, - "read-only and worm cannot be set together"); - ret = -1; - goto out; - } + if (dict_get_str_boolean(set_dict, "features.read-only", 0) && + (dict_get_str_boolean(set_dict, "features.worm", 0) || + dict_get_str_boolean(set_dict, "features.worm-file-level", 0))) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_INCOMPATIBLE_VALUE, + "read-only and worm cannot be set together"); + ret = -1; + goto out; + } - xl = volgen_graph_add (graph, "features/worm", volinfo->volname); - if (!xl) - return -1; + xl = volgen_graph_add(graph, "features/worm", volinfo->volname); + if (!xl) + return -1; - ret = 0; + ret = 0; out: - return ret; + return ret; } static int -brick_graph_add_cdc (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) -{ - int ret = -1; - xlator_t *xl = NULL; - - if (!graph || !volinfo || !set_dict) - goto out; - - /* Check for compress volume option, and add it to the graph on - * server side */ - ret = dict_get_str_boolean (set_dict, "network.compression", 0); - if (ret == -1) - goto out; - if (ret) { - xl = volgen_graph_add (graph, "features/cdc", - volinfo->volname); - if (!xl) { - ret = -1; - goto out; - } - ret = xlator_set_option (xl, "mode", "server"); - if (ret) - goto out; +brick_graph_add_cdc(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +{ + int ret = -1; + xlator_t *xl = NULL; + + if (!graph || !volinfo || !set_dict) + goto out; + + /* Check for compress volume option, and add it to the graph on + * server side */ + ret = dict_get_str_boolean(set_dict, "network.compression", 0); + if (ret == -1) + goto out; + if (ret) { + xl = volgen_graph_add(graph, "features/cdc", volinfo->volname); + if (!xl) { + ret = -1; + goto out; } + ret = xlator_set_option(xl, "mode", "server"); + if (ret) + goto out; + } out: - return ret; + return ret; } static int -brick_graph_add_io_stats (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_io_stats(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - int ret = -1; - xlator_t *xl = NULL; + int ret = -1; + xlator_t *xl = NULL; - if (!graph || !volinfo || !set_dict || !brickinfo) - goto out; + if (!graph || !volinfo || !set_dict || !brickinfo) + goto out; - xl = volgen_graph_add (graph, "debug/io-stats", volinfo->volname); - if (!xl) - goto out; + xl = volgen_graph_add(graph, "debug/io-stats", volinfo->volname); + if (!xl) + goto out; - ret = xlator_set_option (xl, "unique-id", brickinfo->path); - if (ret) - goto out; + ret = xlator_set_option(xl, "unique-id", brickinfo->path); + if (ret) + goto out; - ret = 0; + ret = 0; out: - return ret; + return ret; } static int -brick_graph_add_upcall (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_upcall(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { + xlator_t *xl = NULL; + int ret = -1; - xlator_t *xl = NULL; - int ret = -1; + if (!graph || !volinfo || !set_dict) + goto out; - if (!graph || !volinfo || !set_dict) - goto out; + xl = volgen_graph_add(graph, "features/upcall", volinfo->volname); + if (!xl) { + gf_msg("glusterd", GF_LOG_WARNING, 0, GD_MSG_GRAPH_FEATURE_ADD_FAIL, + "failed to add features/upcall to graph"); + goto out; + } - xl = volgen_graph_add (graph, "features/upcall", volinfo->volname); - if (!xl) { - gf_msg ("glusterd", GF_LOG_WARNING, 0, - GD_MSG_GRAPH_FEATURE_ADD_FAIL, - "failed to add features/upcall to graph"); - goto out; - } - - ret = 0; + ret = 0; out: - return ret; + return ret; } static int -brick_graph_add_leases (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_leases(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { + xlator_t *xl = NULL; + int ret = -1; - xlator_t *xl = NULL; - int ret = -1; + if (!graph || !volinfo || !set_dict) + goto out; - if (!graph || !volinfo || !set_dict) - goto out; + xl = volgen_graph_add(graph, "features/leases", volinfo->volname); + if (!xl) { + gf_msg("glusterd", GF_LOG_WARNING, 0, GD_MSG_GRAPH_FEATURE_ADD_FAIL, + "failed to add features/leases to graph"); + goto out; + } - xl = volgen_graph_add (graph, "features/leases", volinfo->volname); - if (!xl) { - gf_msg ("glusterd", GF_LOG_WARNING, 0, - GD_MSG_GRAPH_FEATURE_ADD_FAIL, - "failed to add features/leases to graph"); - goto out; - } - - ret = 0; + ret = 0; out: - return ret; + return ret; } static int -brick_graph_add_server (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_server(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - int ret = -1; - xlator_t *xl = NULL; - char transt[16] = {0,}; - char *username = NULL; - char *password = NULL; - char key[1024] = {0}; - char *ssl_user = NULL; - char *volname = NULL; - char *address_family_data = NULL; - int32_t len = 0; - - if (!graph || !volinfo || !set_dict || !brickinfo) - goto out; - - get_vol_transport_type (volinfo, transt); - - username = glusterd_auth_get_username (volinfo); - password = glusterd_auth_get_password (volinfo); - - xl = volgen_graph_add (graph, "protocol/server", volinfo->volname); - if (!xl) - goto out; - - ret = xlator_set_option (xl, "transport-type", transt); + int ret = -1; + xlator_t *xl = NULL; + char transt[16] = { + 0, + }; + char *username = NULL; + char *password = NULL; + char key[1024] = {0}; + char *ssl_user = NULL; + char *volname = NULL; + char *address_family_data = NULL; + int32_t len = 0; + + if (!graph || !volinfo || !set_dict || !brickinfo) + goto out; + + get_vol_transport_type(volinfo, transt); + + username = glusterd_auth_get_username(volinfo); + password = glusterd_auth_get_password(volinfo); + + xl = volgen_graph_add(graph, "protocol/server", volinfo->volname); + if (!xl) + goto out; + + ret = xlator_set_option(xl, "transport-type", transt); + if (ret) + goto out; + + /*In the case of running multiple glusterds on a single machine, + * we should ensure that bricks don't listen on all IPs on that + * machine and break the IP based separation being brought about.*/ + if (dict_get(THIS->options, "transport.socket.bind-address")) { + ret = xlator_set_option(xl, "transport.socket.bind-address", + brickinfo->hostname); if (ret) - goto out; - - /*In the case of running multiple glusterds on a single machine, - * we should ensure that bricks don't listen on all IPs on that - * machine and break the IP based separation being brought about.*/ - if (dict_get (THIS->options, "transport.socket.bind-address")) { - ret = xlator_set_option (xl, "transport.socket.bind-address", - brickinfo->hostname); - if (ret) - return -1; - } - - RPC_SET_OPT(xl, SSL_OWN_CERT_OPT, "ssl-own-cert", return -1); - RPC_SET_OPT(xl, SSL_PRIVATE_KEY_OPT,"ssl-private-key", return -1); - RPC_SET_OPT(xl, SSL_CA_LIST_OPT, "ssl-ca-list", return -1); - RPC_SET_OPT(xl, SSL_CRL_PATH_OPT, "ssl-crl-path", return -1); - RPC_SET_OPT(xl, SSL_CERT_DEPTH_OPT, "ssl-cert-depth", return -1); - RPC_SET_OPT(xl, SSL_CIPHER_LIST_OPT,"ssl-cipher-list", return -1); - RPC_SET_OPT(xl, SSL_DH_PARAM_OPT, "ssl-dh-param", return -1); - RPC_SET_OPT(xl, SSL_EC_CURVE_OPT, "ssl-ec-curve", return -1); - - if (dict_get_str (volinfo->dict, "transport.address-family", - &address_family_data) == 0) { - ret = xlator_set_option (xl, "transport.address-family", + return -1; + } + + RPC_SET_OPT(xl, SSL_OWN_CERT_OPT, "ssl-own-cert", return -1); + RPC_SET_OPT(xl, SSL_PRIVATE_KEY_OPT, "ssl-private-key", return -1); + RPC_SET_OPT(xl, SSL_CA_LIST_OPT, "ssl-ca-list", return -1); + RPC_SET_OPT(xl, SSL_CRL_PATH_OPT, "ssl-crl-path", return -1); + RPC_SET_OPT(xl, SSL_CERT_DEPTH_OPT, "ssl-cert-depth", return -1); + RPC_SET_OPT(xl, SSL_CIPHER_LIST_OPT, "ssl-cipher-list", return -1); + RPC_SET_OPT(xl, SSL_DH_PARAM_OPT, "ssl-dh-param", return -1); + RPC_SET_OPT(xl, SSL_EC_CURVE_OPT, "ssl-ec-curve", return -1); + + if (dict_get_str(volinfo->dict, "transport.address-family", + &address_family_data) == 0) { + ret = xlator_set_option(xl, "transport.address-family", address_family_data); - if (ret) { - gf_log ("glusterd", GF_LOG_WARNING, - "failed to set transport.address-family"); - return -1; - } + if (ret) { + gf_log("glusterd", GF_LOG_WARNING, + "failed to set transport.address-family"); + return -1; } + } - if (username) { - len = snprintf (key, sizeof (key), "auth.login.%s.allow", - brickinfo->path); - if ((len < 0) || (len >= sizeof(key))) { - return -1; - } - - ret = xlator_set_option (xl, key, username); - if (ret) - return -1; + if (username) { + len = snprintf(key, sizeof(key), "auth.login.%s.allow", + brickinfo->path); + if ((len < 0) || (len >= sizeof(key))) { + return -1; } - if (password) { - snprintf (key, sizeof (key), "auth.login.%s.password", - username); - - ret = xlator_set_option (xl, key, password); - if (ret) - return -1; - } + ret = xlator_set_option(xl, key, username); + if (ret) + return -1; + } - snprintf (key, sizeof (key), "auth-path"); + if (password) { + snprintf(key, sizeof(key), "auth.login.%s.password", username); - ret = xlator_set_option (xl, key, brickinfo->path); + ret = xlator_set_option(xl, key, password); if (ret) - return -1; + return -1; + } - volname = volinfo->is_snap_volume ? - volinfo->parent_volname : volinfo->volname; + snprintf(key, sizeof(key), "auth-path"); + ret = xlator_set_option(xl, key, brickinfo->path); + if (ret) + return -1; - if (volname && !strcmp (volname, GLUSTER_SHARED_STORAGE)) { - snprintf (key, sizeof (key), "strict-auth-accept"); + volname = volinfo->is_snap_volume ? volinfo->parent_volname + : volinfo->volname; - ret = xlator_set_option (xl, key, "true"); - if (ret) - return -1; - } + if (volname && !strcmp(volname, GLUSTER_SHARED_STORAGE)) { + snprintf(key, sizeof(key), "strict-auth-accept"); - if (dict_get_str (volinfo->dict, "auth.ssl-allow", &ssl_user) == 0) { - len = snprintf (key, sizeof (key), "auth.login.%s.ssl-allow", - brickinfo->path); - if ((len < 0) || (len >= sizeof(key))) { - return -1; - } + ret = xlator_set_option(xl, key, "true"); + if (ret) + return -1; + } - ret = xlator_set_option (xl, key, ssl_user); - if (ret) - return -1; + if (dict_get_str(volinfo->dict, "auth.ssl-allow", &ssl_user) == 0) { + len = snprintf(key, sizeof(key), "auth.login.%s.ssl-allow", + brickinfo->path); + if ((len < 0) || (len >= sizeof(key))) { + return -1; } + ret = xlator_set_option(xl, key, ssl_user); + if (ret) + return -1; + } + out: - return ret; + return ret; } static int -brick_graph_add_pump (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, glusterd_brickinfo_t *brickinfo) +brick_graph_add_pump(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, glusterd_brickinfo_t *brickinfo) { - int ret = -1; - int pump = 0; - xlator_t *xl = NULL; - xlator_t *txl = NULL; - xlator_t *rbxl = NULL; - char *username = NULL; - char *password = NULL; - char *ptranst = NULL; - char *address_family_data = NULL; + int ret = -1; + int pump = 0; + xlator_t *xl = NULL; + xlator_t *txl = NULL; + xlator_t *rbxl = NULL; + char *username = NULL; + char *password = NULL; + char *ptranst = NULL; + char *address_family_data = NULL; + + if (!graph || !volinfo || !set_dict) + goto out; + + ret = dict_get_int32(volinfo->dict, "enable-pump", &pump); + if (ret == -ENOENT) + ret = pump = 0; + if (ret) + return -1; + username = glusterd_auth_get_username(volinfo); + password = glusterd_auth_get_password(volinfo); - if (!graph || !volinfo || !set_dict) - goto out; + if (pump) { + txl = first_of(graph); - ret = dict_get_int32 (volinfo->dict, "enable-pump", &pump); - if (ret == -ENOENT) - ret = pump = 0; - if (ret) - return -1; + rbxl = volgen_graph_add_nolink(graph, "protocol/client", + "%s-replace-brick", volinfo->volname); + if (!rbxl) + return -1; - username = glusterd_auth_get_username (volinfo); - password = glusterd_auth_get_password (volinfo); - - if (pump) { - txl = first_of (graph); - - rbxl = volgen_graph_add_nolink (graph, "protocol/client", - "%s-replace-brick", - volinfo->volname); - if (!rbxl) - return -1; - - ptranst = glusterd_get_trans_type_rb (volinfo->transport_type); - if (NULL == ptranst) - return -1; - - RPC_SET_OPT(rbxl, SSL_OWN_CERT_OPT, "ssl-own-cert", - return -1); - RPC_SET_OPT(rbxl, SSL_PRIVATE_KEY_OPT,"ssl-private-key", - return -1); - RPC_SET_OPT(rbxl, SSL_CA_LIST_OPT, "ssl-ca-list", - return -1); - RPC_SET_OPT(rbxl, SSL_CRL_PATH_OPT, "ssl-crl-path", - return -1); - RPC_SET_OPT(rbxl, SSL_CERT_DEPTH_OPT, "ssl-cert-depth", - return -1); - RPC_SET_OPT(rbxl, SSL_CIPHER_LIST_OPT,"ssl-cipher-list", - return -1); - RPC_SET_OPT(rbxl, SSL_DH_PARAM_OPT, "ssl-dh-param", - return -1); - RPC_SET_OPT(rbxl, SSL_EC_CURVE_OPT, "ssl-ec-curve", - return -1); - - if (username) { - ret = xlator_set_option (rbxl, "username", username); - if (ret) - return -1; - } + ptranst = glusterd_get_trans_type_rb(volinfo->transport_type); + if (NULL == ptranst) + return -1; - if (password) { - ret = xlator_set_option (rbxl, "password", password); - if (ret) - return -1; - } + RPC_SET_OPT(rbxl, SSL_OWN_CERT_OPT, "ssl-own-cert", return -1); + RPC_SET_OPT(rbxl, SSL_PRIVATE_KEY_OPT, "ssl-private-key", return -1); + RPC_SET_OPT(rbxl, SSL_CA_LIST_OPT, "ssl-ca-list", return -1); + RPC_SET_OPT(rbxl, SSL_CRL_PATH_OPT, "ssl-crl-path", return -1); + RPC_SET_OPT(rbxl, SSL_CERT_DEPTH_OPT, "ssl-cert-depth", return -1); + RPC_SET_OPT(rbxl, SSL_CIPHER_LIST_OPT, "ssl-cipher-list", return -1); + RPC_SET_OPT(rbxl, SSL_DH_PARAM_OPT, "ssl-dh-param", return -1); + RPC_SET_OPT(rbxl, SSL_EC_CURVE_OPT, "ssl-ec-curve", return -1); - ret = xlator_set_option (rbxl, "transport-type", ptranst); - GF_FREE (ptranst); - if (ret) - return -1; - - if (dict_get_str (volinfo->dict, "transport.address-family", - &address_family_data) == 0) { - ret = xlator_set_option (rbxl, - "transport.address-family", - address_family_data); - if (ret) { - gf_log ("glusterd", GF_LOG_WARNING, - "failed to set transport.address-family"); - return -1; - } - } + if (username) { + ret = xlator_set_option(rbxl, "username", username); + if (ret) + return -1; + } - xl = volgen_graph_add_nolink (graph, "cluster/pump", "%s-pump", - volinfo->volname); - if (!xl) - return -1; - ret = volgen_xlator_link (xl, txl); - if (ret) - return -1; - ret = volgen_xlator_link (xl, rbxl); - if (ret) - return -1; + if (password) { + ret = xlator_set_option(rbxl, "password", password); + if (ret) + return -1; } + ret = xlator_set_option(rbxl, "transport-type", ptranst); + GF_FREE(ptranst); + if (ret) + return -1; + + if (dict_get_str(volinfo->dict, "transport.address-family", + &address_family_data) == 0) { + ret = xlator_set_option(rbxl, "transport.address-family", + address_family_data); + if (ret) { + gf_log("glusterd", GF_LOG_WARNING, + "failed to set transport.address-family"); + return -1; + } + } + + xl = volgen_graph_add_nolink(graph, "cluster/pump", "%s-pump", + volinfo->volname); + if (!xl) + return -1; + ret = volgen_xlator_link(xl, txl); + if (ret) + return -1; + ret = volgen_xlator_link(xl, rbxl); + if (ret) + return -1; + } + out: - return ret; + return ret; } - /* The order of xlator definition here determines * the topology of the brick graph */ static volgen_brick_xlator_t server_graph_table[] = { - {brick_graph_add_server, NULL}, - {brick_graph_add_decompounder, "decompounder"}, - {brick_graph_add_io_stats, "NULL"}, - {brick_graph_add_sdfs, "sdfs"}, - {brick_graph_add_namespace, "namespace"}, - {brick_graph_add_cdc, NULL}, - {brick_graph_add_quota, "quota"}, - {brick_graph_add_index, "index"}, - {brick_graph_add_barrier, NULL}, - {brick_graph_add_marker, "marker"}, - {brick_graph_add_selinux, "selinux"}, - {brick_graph_add_fdl, "fdl"}, - {brick_graph_add_iot, "io-threads"}, - {brick_graph_add_upcall, "upcall"}, - {brick_graph_add_leases, "leases"}, - {brick_graph_add_pump, NULL}, - {brick_graph_add_ro, NULL}, - {brick_graph_add_worm, NULL}, - {brick_graph_add_locks, "locks"}, - {brick_graph_add_acl, "acl"}, - {brick_graph_add_bitrot_stub, "bitrot-stub"}, - {brick_graph_add_changelog, "changelog"}, + {brick_graph_add_server, NULL}, + {brick_graph_add_decompounder, "decompounder"}, + {brick_graph_add_io_stats, "NULL"}, + {brick_graph_add_sdfs, "sdfs"}, + {brick_graph_add_namespace, "namespace"}, + {brick_graph_add_cdc, NULL}, + {brick_graph_add_quota, "quota"}, + {brick_graph_add_index, "index"}, + {brick_graph_add_barrier, NULL}, + {brick_graph_add_marker, "marker"}, + {brick_graph_add_selinux, "selinux"}, + {brick_graph_add_fdl, "fdl"}, + {brick_graph_add_iot, "io-threads"}, + {brick_graph_add_upcall, "upcall"}, + {brick_graph_add_leases, "leases"}, + {brick_graph_add_pump, NULL}, + {brick_graph_add_ro, NULL}, + {brick_graph_add_worm, NULL}, + {brick_graph_add_locks, "locks"}, + {brick_graph_add_acl, "acl"}, + {brick_graph_add_bitrot_stub, "bitrot-stub"}, + {brick_graph_add_changelog, "changelog"}, #if USE_GFDB /* changetimerecorder depends on gfdb */ - {brick_graph_add_changetimerecorder, "changetimerecorder"}, + {brick_graph_add_changetimerecorder, "changetimerecorder"}, #endif - {brick_graph_add_bd, "bd"}, - {brick_graph_add_trash, "trash"}, - {brick_graph_add_arbiter, "arbiter"}, - {brick_graph_add_posix, "posix"}, + {brick_graph_add_bd, "bd"}, + {brick_graph_add_trash, "trash"}, + {brick_graph_add_arbiter, "arbiter"}, + {brick_graph_add_posix, "posix"}, }; static glusterd_server_xlator_t -get_server_xlator (char *xlator) +get_server_xlator(char *xlator) { - int i = 0; - int size = sizeof (server_graph_table)/sizeof (server_graph_table[0]); + int i = 0; + int size = sizeof(server_graph_table) / sizeof(server_graph_table[0]); - for (i = 0; i < size; i++) { - if (!server_graph_table[i].dbg_key) - continue; - if (strcmp (xlator, server_graph_table[i].dbg_key)) - return GF_XLATOR_SERVER; - } + for (i = 0; i < size; i++) { + if (!server_graph_table[i].dbg_key) + continue; + if (strcmp(xlator, server_graph_table[i].dbg_key)) + return GF_XLATOR_SERVER; + } - return GF_XLATOR_NONE; + return GF_XLATOR_NONE; } static glusterd_client_xlator_t -get_client_xlator (char *xlator) +get_client_xlator(char *xlator) { - glusterd_client_xlator_t subvol = GF_CLNT_XLATOR_NONE; + glusterd_client_xlator_t subvol = GF_CLNT_XLATOR_NONE; - if (strcmp (xlator, "client") == 0) - subvol = GF_CLNT_XLATOR_FUSE; + if (strcmp(xlator, "client") == 0) + subvol = GF_CLNT_XLATOR_FUSE; - return subvol; + return subvol; } static int -debugxl_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, +debugxl_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, void *param) { - char *volname = NULL; - gf_boolean_t enabled = _gf_false; - - volname = param; + char *volname = NULL; + gf_boolean_t enabled = _gf_false; - if (strcmp (vme->option, "!debug") != 0) - return 0; + volname = param; - if (!strcmp (vme->key , "debug.trace") || - !strcmp (vme->key, "debug.error-gen") || - !strcmp (vme->key, "debug.delay-gen")) { - if (get_server_xlator (vme->value) == GF_XLATOR_NONE && - get_client_xlator (vme->value) == GF_CLNT_XLATOR_NONE) - return 0; - } + if (strcmp(vme->option, "!debug") != 0) + return 0; - if (gf_string2boolean (vme->value, &enabled) == -1) - goto add_graph; - if (!enabled) - return 0; + if (!strcmp(vme->key, "debug.trace") || + !strcmp(vme->key, "debug.error-gen") || + !strcmp(vme->key, "debug.delay-gen")) { + if (get_server_xlator(vme->value) == GF_XLATOR_NONE && + get_client_xlator(vme->value) == GF_CLNT_XLATOR_NONE) + return 0; + } + + if (gf_string2boolean(vme->value, &enabled) == -1) + goto add_graph; + if (!enabled) + return 0; add_graph: - if (strcmp (vme->value, "off") == 0) - return 0; - if (volgen_graph_add (graph, vme->voltype, volname)) - return 0; - else - return -1; + if (strcmp(vme->value, "off") == 0) + return 0; + if (volgen_graph_add(graph, vme->voltype, volname)) + return 0; + else + return -1; } int -check_and_add_debug_xl (volgen_graph_t *graph, dict_t *set_dict, char *volname, - char *xlname) +check_and_add_debug_xl(volgen_graph_t *graph, dict_t *set_dict, char *volname, + char *xlname) { - int i = 0; - int ret = 0; - char *value_str = NULL; - static char *xls[] = {"debug.trace", "debug.error-gen", - "debug.delay-gen", NULL}; + int i = 0; + int ret = 0; + char *value_str = NULL; + static char *xls[] = {"debug.trace", "debug.error-gen", "debug.delay-gen", + NULL}; - if (!xlname) - goto out; + if (!xlname) + goto out; - while (xls[i]) { - ret = dict_get_str (set_dict, xls[i], &value_str); - if (!ret) { - if (strcmp (xlname, value_str) == 0) { - ret = volgen_graph_set_options_generic (graph, - set_dict, volname, + while (xls[i]) { + ret = dict_get_str(set_dict, xls[i], &value_str); + if (!ret) { + if (strcmp(xlname, value_str) == 0) { + ret = volgen_graph_set_options_generic(graph, set_dict, volname, &debugxl_option_handler); - if (ret) - goto out; - } - } - i++; + if (ret) + goto out; + } } - ret = 0; + i++; + } + ret = 0; out: - return ret; + return ret; } static int -server_graph_builder (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, void *param) +server_graph_builder(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, void *param) { - int ret = 0; - char *xlator = NULL; - char *loglevel = NULL; - int i = 0; - - - i = sizeof (server_graph_table)/sizeof (server_graph_table[0]) - 1; - - while (i >= 0) { - ret = server_graph_table[i].builder (graph, volinfo, set_dict, - param); - if (ret) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_BUILD_GRAPH_FAILED, "Builing graph " - "failed for server graph table entry: %d", i); - goto out; - } + int ret = 0; + char *xlator = NULL; + char *loglevel = NULL; + int i = 0; - ret = check_and_add_debug_xl (graph, set_dict, - volinfo->volname, - server_graph_table[i].dbg_key); - if (ret) - goto out; + i = sizeof(server_graph_table) / sizeof(server_graph_table[0]) - 1; - i--; + while (i >= 0) { + ret = server_graph_table[i].builder(graph, volinfo, set_dict, param); + if (ret) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_BUILD_GRAPH_FAILED, + "Builing graph " + "failed for server graph table entry: %d", + i); + goto out; } + ret = check_and_add_debug_xl(graph, set_dict, volinfo->volname, + server_graph_table[i].dbg_key); + if (ret) + goto out; - ret = dict_get_str (set_dict, "xlator", &xlator); + i--; + } - /* got a cli log level request */ - if (!ret) { - ret = dict_get_str (set_dict, "loglevel", &loglevel); - if (ret) { - gf_msg ("glusterd", GF_LOG_ERROR, errno, - GD_MSG_DICT_GET_FAILED, "could not get both" - " translator name and loglevel for log level request"); - goto out; - } + ret = dict_get_str(set_dict, "xlator", &xlator); + + /* got a cli log level request */ + if (!ret) { + ret = dict_get_str(set_dict, "loglevel", &loglevel); + if (ret) { + gf_msg("glusterd", GF_LOG_ERROR, errno, GD_MSG_DICT_GET_FAILED, + "could not get both" + " translator name and loglevel for log level request"); + goto out; } + } - ret = volgen_graph_set_options_generic (graph, set_dict, - (xlator && loglevel) ? (void *)set_dict : volinfo, - (xlator && loglevel) ? &server_spec_extended_option_handler : - &server_spec_option_handler); + ret = volgen_graph_set_options_generic( + graph, set_dict, (xlator && loglevel) ? (void *)set_dict : volinfo, + (xlator && loglevel) ? &server_spec_extended_option_handler + : &server_spec_option_handler); - out: - return ret; +out: + return ret; } - /* builds a graph for server role , with option overrides in mod_dict */ static int -build_server_graph (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *mod_dict, glusterd_brickinfo_t *brickinfo) +build_server_graph(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *mod_dict, glusterd_brickinfo_t *brickinfo) { - return build_graph_generic (graph, volinfo, mod_dict, brickinfo, - &server_graph_builder); + return build_graph_generic(graph, volinfo, mod_dict, brickinfo, + &server_graph_builder); } static int -perfxl_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, - void *param) +perfxl_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - gf_boolean_t enabled = _gf_false; - glusterd_volinfo_t *volinfo = NULL; - xlator_t *this = NULL; - glusterd_conf_t *priv = NULL; + gf_boolean_t enabled = _gf_false; + glusterd_volinfo_t *volinfo = NULL; + xlator_t *this = NULL; + glusterd_conf_t *priv = NULL; - GF_VALIDATE_OR_GOTO ("glusterd", param, out); - volinfo = param; - this = THIS; - GF_VALIDATE_OR_GOTO ("glusterd", this, out); - priv = this->private; - GF_VALIDATE_OR_GOTO ("glusterd", priv, out); + GF_VALIDATE_OR_GOTO("glusterd", param, out); + volinfo = param; + this = THIS; + GF_VALIDATE_OR_GOTO("glusterd", this, out); + priv = this->private; + GF_VALIDATE_OR_GOTO("glusterd", priv, out); - if (strcmp (vme->option, "!perf") != 0) - return 0; - - if (gf_string2boolean (vme->value, &enabled) == -1) - return -1; - if (!enabled) - return 0; + if (strcmp(vme->option, "!perf") != 0) + return 0; - /* Check op-version before adding the 'open-behind' xlator in the graph - */ - if (!strcmp (vme->key, "performance.open-behind") && - (vme->op_version > volinfo->client_op_version)) - return 0; + if (gf_string2boolean(vme->value, &enabled) == -1) + return -1; + if (!enabled) + return 0; - if (priv->op_version < GD_OP_VERSION_3_12_2) { - /* For replicate volumes do not load io-threads as it affects - * performance - */ - if (!strcmp (vme->key, "performance.client-io-threads") && - (GF_CLUSTER_TYPE_STRIPE_REPLICATE == volinfo->type || - GF_CLUSTER_TYPE_REPLICATE == volinfo->type)) - return 0; - } + /* Check op-version before adding the 'open-behind' xlator in the graph + */ + if (!strcmp(vme->key, "performance.open-behind") && + (vme->op_version > volinfo->client_op_version)) + return 0; - /* if VKEY_READDIR_AHEAD is enabled and parallel readdir is - * not enabled then load readdir-ahead here else it will be - * loaded as a child of dht */ - if (!strcmp (vme->key, VKEY_READDIR_AHEAD) && - glusterd_volinfo_get_boolean (volinfo, VKEY_PARALLEL_READDIR)) - return 0; + if (priv->op_version < GD_OP_VERSION_3_12_2) { + /* For replicate volumes do not load io-threads as it affects + * performance + */ + if (!strcmp(vme->key, "performance.client-io-threads") && + (GF_CLUSTER_TYPE_STRIPE_REPLICATE == volinfo->type || + GF_CLUSTER_TYPE_REPLICATE == volinfo->type)) + return 0; + } + + /* if VKEY_READDIR_AHEAD is enabled and parallel readdir is + * not enabled then load readdir-ahead here else it will be + * loaded as a child of dht */ + if (!strcmp(vme->key, VKEY_READDIR_AHEAD) && + glusterd_volinfo_get_boolean(volinfo, VKEY_PARALLEL_READDIR)) + return 0; - if (volgen_graph_add (graph, vme->voltype, volinfo->volname)) - return 0; + if (volgen_graph_add(graph, vme->voltype, volinfo->volname)) + return 0; out: - return -1; + return -1; } static int -gfproxy_server_perfxl_option_handler (volgen_graph_t *graph, - struct volopt_map_entry *vme, - void *param) +gfproxy_server_perfxl_option_handler(volgen_graph_t *graph, + struct volopt_map_entry *vme, void *param) { + GF_ASSERT(param); - GF_ASSERT (param); - - /* write-behind is the *not* allowed for gfproxy-servers */ - if (strstr (vme->key, "write-behind")) { - return 0; - } + /* write-behind is the *not* allowed for gfproxy-servers */ + if (strstr(vme->key, "write-behind")) { + return 0; + } - perfxl_option_handler (graph, vme, param); + perfxl_option_handler(graph, vme, param); - return 0; + return 0; } static int -gfproxy_client_perfxl_option_handler (volgen_graph_t *graph, - struct volopt_map_entry *vme, - void *param) +gfproxy_client_perfxl_option_handler(volgen_graph_t *graph, + struct volopt_map_entry *vme, void *param) { + GF_ASSERT(param); - GF_ASSERT (param); - - /* write-behind is the only allowed "perf" for gfproxy-clients */ - if (!strstr (vme->key, "write-behind")) - return 0; + /* write-behind is the only allowed "perf" for gfproxy-clients */ + if (!strstr(vme->key, "write-behind")) + return 0; - perfxl_option_handler (graph, vme, param); + perfxl_option_handler(graph, vme, param); - return 0; + return 0; } - static int -nfsperfxl_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, - void *param) +nfsperfxl_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - char *volname = NULL; - gf_boolean_t enabled = _gf_false; + char *volname = NULL; + gf_boolean_t enabled = _gf_false; - volname = param; + volname = param; - if (strcmp (vme->option, "!nfsperf") != 0) - return 0; + if (strcmp(vme->option, "!nfsperf") != 0) + return 0; - if (gf_string2boolean (vme->value, &enabled) == -1) - return -1; - if (!enabled) - return 0; + if (gf_string2boolean(vme->value, &enabled) == -1) + return -1; + if (!enabled) + return 0; - if (volgen_graph_add (graph, vme->voltype, volname)) - return 0; - else - return -1; + if (volgen_graph_add(graph, vme->voltype, volname)) + return 0; + else + return -1; } #if (HAVE_LIB_XML) int -end_sethelp_xml_doc (xmlTextWriterPtr writer) +end_sethelp_xml_doc(xmlTextWriterPtr writer) { - int ret = -1; - - ret = xmlTextWriterEndElement(writer); - if (ret < 0) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_XML_TEXT_WRITE_FAIL, "Could not end an " - "xmlElement"); - ret = -1; - goto out; - } - ret = xmlTextWriterEndDocument (writer); - if (ret < 0) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_XML_TEXT_WRITE_FAIL, "Could not end an " - "xmlDocument"); - ret = -1; - goto out; - } - ret = 0; - out: - gf_msg_debug ("glusterd", 0, "Returning %d", ret); - return ret; + int ret = -1; + ret = xmlTextWriterEndElement(writer); + if (ret < 0) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_XML_TEXT_WRITE_FAIL, + "Could not end an " + "xmlElement"); + ret = -1; + goto out; + } + ret = xmlTextWriterEndDocument(writer); + if (ret < 0) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_XML_TEXT_WRITE_FAIL, + "Could not end an " + "xmlDocument"); + ret = -1; + goto out; + } + ret = 0; +out: + gf_msg_debug("glusterd", 0, "Returning %d", ret); + return ret; } int -init_sethelp_xml_doc (xmlTextWriterPtr *writer, xmlBufferPtr *buf) +init_sethelp_xml_doc(xmlTextWriterPtr *writer, xmlBufferPtr *buf) { - int ret = -1; - - if (!writer || !buf) - goto out; - - *buf = xmlBufferCreateSize (8192); - if (buf == NULL) { - gf_msg ("glusterd", GF_LOG_ERROR, ENOMEM, - GD_MSG_NO_MEMORY, "Error creating the xml " - "buffer"); - ret = -1; - goto out; - } + int ret = -1; - xmlBufferSetAllocationScheme (*buf,XML_BUFFER_ALLOC_DOUBLEIT); - - *writer = xmlNewTextWriterMemory(*buf, 0); - if (writer == NULL) { - gf_msg ("glusterd", GF_LOG_ERROR, ENOMEM, - GD_MSG_NO_MEMORY, " Error creating the xml " - "writer"); - ret = -1; - goto out; - } - - ret = xmlTextWriterStartDocument(*writer, "1.0", "UTF-8", "yes"); - if (ret < 0) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_XML_DOC_START_FAIL, "Error While starting the " - "xmlDoc"); - goto out; - } + if (!writer || !buf) + goto out; - ret = xmlTextWriterStartElement(*writer, (xmlChar *)"options"); - if (ret < 0) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_XML_ELE_CREATE_FAIL, "Could not create an " - "xmlElement"); - ret = -1; - goto out; - } + *buf = xmlBufferCreateSize(8192); + if (buf == NULL) { + gf_msg("glusterd", GF_LOG_ERROR, ENOMEM, GD_MSG_NO_MEMORY, + "Error creating the xml " + "buffer"); + ret = -1; + goto out; + } + xmlBufferSetAllocationScheme(*buf, XML_BUFFER_ALLOC_DOUBLEIT); - ret = 0; + *writer = xmlNewTextWriterMemory(*buf, 0); + if (writer == NULL) { + gf_msg("glusterd", GF_LOG_ERROR, ENOMEM, GD_MSG_NO_MEMORY, + " Error creating the xml " + "writer"); + ret = -1; + goto out; + } + + ret = xmlTextWriterStartDocument(*writer, "1.0", "UTF-8", "yes"); + if (ret < 0) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_XML_DOC_START_FAIL, + "Error While starting the " + "xmlDoc"); + goto out; + } + + ret = xmlTextWriterStartElement(*writer, (xmlChar *)"options"); + if (ret < 0) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_XML_ELE_CREATE_FAIL, + "Could not create an " + "xmlElement"); + ret = -1; + goto out; + } - out: - gf_msg_debug ("glusterd", 0, "Returning %d", ret); - return ret; + ret = 0; +out: + gf_msg_debug("glusterd", 0, "Returning %d", ret); + return ret; } int -xml_add_volset_element (xmlTextWriterPtr writer, const char *name, - const char *def_val, const char *dscrpt) +xml_add_volset_element(xmlTextWriterPtr writer, const char *name, + const char *def_val, const char *dscrpt) { + int ret = -1; - int ret = -1; - - GF_ASSERT (name); - - ret = xmlTextWriterStartElement(writer, (xmlChar *) "option"); - if (ret < 0) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_XML_ELE_CREATE_FAIL, "Could not create an " - "xmlElemetnt"); - ret = -1; - goto out; - } - - ret = xmlTextWriterWriteFormatElement(writer, (xmlChar*)"defaultValue", - "%s", def_val); - if (ret < 0) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_XML_ELE_CREATE_FAIL, "Could not create an " - "xmlElemetnt"); - ret = -1; - goto out; - } - - ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"description", - "%s", dscrpt ); - if (ret < 0) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_XML_ELE_CREATE_FAIL, "Could not create an " - "xmlElemetnt"); - ret = -1; - goto out; - } + GF_ASSERT(name); - ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *) "name", "%s", - name); - if (ret < 0) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_XML_ELE_CREATE_FAIL, "Could not create an " - "xmlElemetnt"); - ret = -1; - goto out; - } - - ret = xmlTextWriterEndElement(writer); - if (ret < 0) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_XML_ELE_CREATE_FAIL, "Could not end an " - "xmlElemetnt"); - ret = -1; - goto out; - } - - ret = 0; - out: - gf_msg_debug ("glusterd", 0, "Returning %d", ret); - return ret; + ret = xmlTextWriterStartElement(writer, (xmlChar *)"option"); + if (ret < 0) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_XML_ELE_CREATE_FAIL, + "Could not create an " + "xmlElemetnt"); + ret = -1; + goto out; + } + + ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"defaultValue", + "%s", def_val); + if (ret < 0) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_XML_ELE_CREATE_FAIL, + "Could not create an " + "xmlElemetnt"); + ret = -1; + goto out; + } + + ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"description", + "%s", dscrpt); + if (ret < 0) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_XML_ELE_CREATE_FAIL, + "Could not create an " + "xmlElemetnt"); + ret = -1; + goto out; + } + + ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"name", "%s", + name); + if (ret < 0) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_XML_ELE_CREATE_FAIL, + "Could not create an " + "xmlElemetnt"); + ret = -1; + goto out; + } + + ret = xmlTextWriterEndElement(writer); + if (ret < 0) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_XML_ELE_CREATE_FAIL, + "Could not end an " + "xmlElemetnt"); + ret = -1; + goto out; + } + ret = 0; +out: + gf_msg_debug("glusterd", 0, "Returning %d", ret); + return ret; } #endif int -_get_xlator_opt_key_from_vme ( struct volopt_map_entry *vme, char **key) -{ - int ret = 0; - - GF_ASSERT (vme); - GF_ASSERT (key); - - - if (!strcmp (vme->key, AUTH_ALLOW_MAP_KEY)) - *key = gf_strdup (AUTH_ALLOW_OPT_KEY); - else if (!strcmp (vme->key, AUTH_REJECT_MAP_KEY)) - *key = gf_strdup (AUTH_REJECT_OPT_KEY); - else if (!strcmp (vme->key, NFS_DISABLE_MAP_KEY)) - *key = gf_strdup (NFS_DISABLE_OPT_KEY); - else { - if (vme->option) { - if (vme->option[0] == '!') { - *key = vme->option + 1; - if (!*key[0]) - ret = -1; - } else { - *key = vme->option; - } - } else { - *key = strchr (vme->key, '.'); - if (*key) { - (*key) ++; - if (!*key[0]) - ret = -1; - } else { - ret = -1; - } - } +_get_xlator_opt_key_from_vme(struct volopt_map_entry *vme, char **key) +{ + int ret = 0; + + GF_ASSERT(vme); + GF_ASSERT(key); + + if (!strcmp(vme->key, AUTH_ALLOW_MAP_KEY)) + *key = gf_strdup(AUTH_ALLOW_OPT_KEY); + else if (!strcmp(vme->key, AUTH_REJECT_MAP_KEY)) + *key = gf_strdup(AUTH_REJECT_OPT_KEY); + else if (!strcmp(vme->key, NFS_DISABLE_MAP_KEY)) + *key = gf_strdup(NFS_DISABLE_OPT_KEY); + else { + if (vme->option) { + if (vme->option[0] == '!') { + *key = vme->option + 1; + if (!*key[0]) + ret = -1; + } else { + *key = vme->option; + } + } else { + *key = strchr(vme->key, '.'); + if (*key) { + (*key)++; + if (!*key[0]) + ret = -1; + } else { + ret = -1; + } } - if (ret) - gf_msg ("glusterd", GF_LOG_ERROR, EINVAL, - GD_MSG_INVALID_ENTRY, "Wrong entry found in " - "glusterd_volopt_map entry %s", vme->key); - else - gf_msg_debug ("glusterd", 0, "Returning %d", ret); + } + if (ret) + gf_msg("glusterd", GF_LOG_ERROR, EINVAL, GD_MSG_INVALID_ENTRY, + "Wrong entry found in " + "glusterd_volopt_map entry %s", + vme->key); + else + gf_msg_debug("glusterd", 0, "Returning %d", ret); - return ret; + return ret; } void -_free_xlator_opt_key (char *key) +_free_xlator_opt_key(char *key) { - GF_ASSERT (key); + GF_ASSERT(key); - if (!strcmp (key, AUTH_ALLOW_OPT_KEY) || - !strcmp (key, AUTH_REJECT_OPT_KEY) || - !strcmp (key, NFS_DISABLE_OPT_KEY)) - GF_FREE (key); + if (!strcmp(key, AUTH_ALLOW_OPT_KEY) || !strcmp(key, AUTH_REJECT_OPT_KEY) || + !strcmp(key, NFS_DISABLE_OPT_KEY)) + GF_FREE(key); - return; + return; } static xlator_t * -volgen_graph_build_client (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - char *hostname, char *port, - char *subvol, char *xl_id, - char *transt, dict_t *set_dict) -{ - xlator_t *xl = NULL; - int ret = -2; - uint32_t client_type = GF_CLIENT_OTHER; - char *str = NULL; - char *ssl_str = NULL; - gf_boolean_t ssl_bool = _gf_false; - char *address_family_data = NULL; - - GF_ASSERT (graph); - GF_ASSERT (subvol); - GF_ASSERT (xl_id); - GF_ASSERT (transt); - - xl = volgen_graph_add_nolink (graph, "protocol/client", - "%s", xl_id); - if (!xl) - goto err; +volgen_graph_build_client(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + char *hostname, char *port, char *subvol, char *xl_id, + char *transt, dict_t *set_dict) +{ + xlator_t *xl = NULL; + int ret = -2; + uint32_t client_type = GF_CLIENT_OTHER; + char *str = NULL; + char *ssl_str = NULL; + gf_boolean_t ssl_bool = _gf_false; + char *address_family_data = NULL; + + GF_ASSERT(graph); + GF_ASSERT(subvol); + GF_ASSERT(xl_id); + GF_ASSERT(transt); + + xl = volgen_graph_add_nolink(graph, "protocol/client", "%s", xl_id); + if (!xl) + goto err; + + ret = xlator_set_option(xl, "ping-timeout", "42"); + if (ret) + goto err; + + if (hostname) { + ret = xlator_set_option(xl, "remote-host", hostname); + if (ret) + goto err; + } - ret = xlator_set_option (xl, "ping-timeout", "42"); + if (port) { + ret = xlator_set_option(xl, "remote-port", port); if (ret) - goto err; + goto err; + } - if (hostname) { - ret = xlator_set_option (xl, "remote-host", hostname); - if (ret) - goto err; - } + ret = xlator_set_option(xl, "remote-subvolume", subvol); + if (ret) + goto err; - if (port) { - ret = xlator_set_option (xl, "remote-port", port); - if (ret) - goto err; + ret = xlator_set_option(xl, "transport-type", transt); + if (ret) + goto err; + + if (dict_get_str(volinfo->dict, "transport.address-family", + &address_family_data) == 0) { + ret = xlator_set_option(xl, "transport.address-family", + address_family_data); + if (ret) { + gf_log("glusterd", GF_LOG_WARNING, + "failed to set transport.address-family"); + goto err; } + } - ret = xlator_set_option (xl, "remote-subvolume", subvol); - if (ret) - goto err; + ret = dict_get_uint32(set_dict, "trusted-client", &client_type); - ret = xlator_set_option (xl, "transport-type", transt); - if (ret) + if (!ret && (client_type == GF_CLIENT_TRUSTED || + client_type == GF_CLIENT_TRUSTED_PROXY)) { + str = NULL; + str = glusterd_auth_get_username(volinfo); + if (str) { + ret = xlator_set_option(xl, "username", str); + if (ret) goto err; - - if (dict_get_str (volinfo->dict, "transport.address-family", - &address_family_data) == 0) { - ret = xlator_set_option (xl, - "transport.address-family", - address_family_data); - if (ret) { - gf_log ("glusterd", GF_LOG_WARNING, - "failed to set transport.address-family"); - goto err; - } } - ret = dict_get_uint32 (set_dict, "trusted-client", - &client_type); - - if (!ret && (client_type == GF_CLIENT_TRUSTED - || client_type == GF_CLIENT_TRUSTED_PROXY)) { - str = NULL; - str = glusterd_auth_get_username (volinfo); - if (str) { - ret = xlator_set_option (xl, "username", - str); - if (ret) - goto err; - } - - str = glusterd_auth_get_password (volinfo); - if (str) { - ret = xlator_set_option (xl, "password", - str); - if (ret) - goto err; - } + str = glusterd_auth_get_password(volinfo); + if (str) { + ret = xlator_set_option(xl, "password", str); + if (ret) + goto err; } + } - if (dict_get_str(set_dict,"client.ssl",&ssl_str) == 0) { - if (gf_string2boolean(ssl_str,&ssl_bool) == 0) { - if (ssl_bool) { - ret = xlator_set_option(xl, - "transport.socket.ssl-enabled", + if (dict_get_str(set_dict, "client.ssl", &ssl_str) == 0) { + if (gf_string2boolean(ssl_str, &ssl_bool) == 0) { + if (ssl_bool) { + ret = xlator_set_option(xl, "transport.socket.ssl-enabled", "true"); - if (ret) { - goto err; - } - } + if (ret) { + goto err; } + } } + } - RPC_SET_OPT(xl, SSL_OWN_CERT_OPT, "ssl-own-cert", goto err); - RPC_SET_OPT(xl, SSL_PRIVATE_KEY_OPT,"ssl-private-key", goto err); - RPC_SET_OPT(xl, SSL_CA_LIST_OPT, "ssl-ca-list", goto err); - RPC_SET_OPT(xl, SSL_CRL_PATH_OPT, "ssl-crl-path", goto err); - RPC_SET_OPT(xl, SSL_CERT_DEPTH_OPT, "ssl-cert-depth", goto err); - RPC_SET_OPT(xl, SSL_CIPHER_LIST_OPT,"ssl-cipher-list", goto err); - RPC_SET_OPT(xl, SSL_DH_PARAM_OPT, "ssl-dh-param", goto err); - RPC_SET_OPT(xl, SSL_EC_CURVE_OPT, "ssl-ec-curve", goto err); + RPC_SET_OPT(xl, SSL_OWN_CERT_OPT, "ssl-own-cert", goto err); + RPC_SET_OPT(xl, SSL_PRIVATE_KEY_OPT, "ssl-private-key", goto err); + RPC_SET_OPT(xl, SSL_CA_LIST_OPT, "ssl-ca-list", goto err); + RPC_SET_OPT(xl, SSL_CRL_PATH_OPT, "ssl-crl-path", goto err); + RPC_SET_OPT(xl, SSL_CERT_DEPTH_OPT, "ssl-cert-depth", goto err); + RPC_SET_OPT(xl, SSL_CIPHER_LIST_OPT, "ssl-cipher-list", goto err); + RPC_SET_OPT(xl, SSL_DH_PARAM_OPT, "ssl-dh-param", goto err); + RPC_SET_OPT(xl, SSL_EC_CURVE_OPT, "ssl-ec-curve", goto err); - return xl; + return xl; err: - return NULL; + return NULL; } static int -volgen_graph_build_clients (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, void *param) -{ - int i = 0; - int ret = -1; - char transt[16] = {0,}; - glusterd_brickinfo_t *brick = NULL; - xlator_t *xl = NULL; - - if (volinfo->brick_count == 0) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_VOLUME_INCONSISTENCY, - "volume inconsistency: brick count is 0"); - goto out; - } - - if ((volinfo->type != GF_CLUSTER_TYPE_TIER) && - (volinfo->dist_leaf_count < volinfo->brick_count) && - ((volinfo->brick_count % volinfo->dist_leaf_count) != 0)) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_VOLUME_INCONSISTENCY, - "volume inconsistency: " - "total number of bricks (%d) is not divisible with " - "number of bricks per cluster (%d) in a multi-cluster " - "setup", - volinfo->brick_count, volinfo->dist_leaf_count); - goto out; +volgen_graph_build_clients(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, void *param) +{ + int i = 0; + int ret = -1; + char transt[16] = { + 0, + }; + glusterd_brickinfo_t *brick = NULL; + xlator_t *xl = NULL; + + if (volinfo->brick_count == 0) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_VOLUME_INCONSISTENCY, + "volume inconsistency: brick count is 0"); + goto out; + } + + if ((volinfo->type != GF_CLUSTER_TYPE_TIER) && + (volinfo->dist_leaf_count < volinfo->brick_count) && + ((volinfo->brick_count % volinfo->dist_leaf_count) != 0)) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_VOLUME_INCONSISTENCY, + "volume inconsistency: " + "total number of bricks (%d) is not divisible with " + "number of bricks per cluster (%d) in a multi-cluster " + "setup", + volinfo->brick_count, volinfo->dist_leaf_count); + goto out; + } + + get_transport_type(volinfo, set_dict, transt, _gf_false); + + if (!strcmp(transt, "tcp,rdma")) + strcpy(transt, "tcp"); + + i = 0; + cds_list_for_each_entry(brick, &volinfo->bricks, brick_list) + { + xl = volgen_graph_build_client(graph, volinfo, brick->hostname, NULL, + brick->path, brick->brick_id, transt, + set_dict); + if (!xl) { + ret = -1; + goto out; } - get_transport_type (volinfo, set_dict, transt, _gf_false); - - if (!strcmp (transt, "tcp,rdma")) - strcpy (transt, "tcp"); - - i = 0; - cds_list_for_each_entry (brick, &volinfo->bricks, brick_list) { - xl = volgen_graph_build_client (graph, volinfo, - brick->hostname, - NULL, - brick->path, - brick->brick_id, - transt, set_dict); - if (!xl) { - ret = -1; - goto out; - } - - i++; - } + i++; + } - if (i != volinfo->brick_count) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_VOLUME_INCONSISTENCY, - "volume inconsistency: actual number of bricks (%d) " - "differs from brick count (%d)", i, - volinfo->brick_count); + if (i != volinfo->brick_count) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_VOLUME_INCONSISTENCY, + "volume inconsistency: actual number of bricks (%d) " + "differs from brick count (%d)", + i, volinfo->brick_count); - ret = -1; - goto out; - } - ret = 0; + ret = -1; + goto out; + } + ret = 0; out: - return ret; + return ret; } static int -volgen_graph_build_clients_for_tier_shd (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - dict_t *set_dict) -{ - int ret = 0; - glusterd_volinfo_t *dup_volinfo = NULL; - gf_boolean_t is_hot_tier = _gf_false; - gf_boolean_t is_hot_shd = _gf_false; - gf_boolean_t is_cold_shd = _gf_false; - - is_cold_shd = glusterd_is_shd_compatible_type - (volinfo->tier_info.cold_type); - is_hot_shd = glusterd_is_shd_compatible_type - (volinfo->tier_info.hot_type); - - if (is_cold_shd && is_hot_shd) { - ret = volgen_graph_build_clients (graph, volinfo, - set_dict, NULL); - return ret; - } +volgen_graph_build_clients_for_tier_shd(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, + dict_t *set_dict) +{ + int ret = 0; + glusterd_volinfo_t *dup_volinfo = NULL; + gf_boolean_t is_hot_tier = _gf_false; + gf_boolean_t is_hot_shd = _gf_false; + gf_boolean_t is_cold_shd = _gf_false; - if (is_cold_shd) { - ret = glusterd_create_sub_tier_volinfo (volinfo, &dup_volinfo, - is_hot_tier, - volinfo->volname); - if (ret) - goto out; - ret = volgen_graph_build_clients (graph, dup_volinfo, - set_dict, NULL); - if (ret) - goto out; - } - if (is_hot_shd) { - is_hot_tier = _gf_true; - ret = glusterd_create_sub_tier_volinfo (volinfo, &dup_volinfo, - is_hot_tier, - volinfo->volname); - if (ret) - goto out; - ret = volgen_graph_build_clients (graph, dup_volinfo, - set_dict, NULL); - if (ret) - goto out; - } -out: - if (dup_volinfo) - glusterd_volinfo_delete (dup_volinfo); + is_cold_shd = glusterd_is_shd_compatible_type(volinfo->tier_info.cold_type); + is_hot_shd = glusterd_is_shd_compatible_type(volinfo->tier_info.hot_type); + + if (is_cold_shd && is_hot_shd) { + ret = volgen_graph_build_clients(graph, volinfo, set_dict, NULL); return ret; + } + + if (is_cold_shd) { + ret = glusterd_create_sub_tier_volinfo(volinfo, &dup_volinfo, + is_hot_tier, volinfo->volname); + if (ret) + goto out; + ret = volgen_graph_build_clients(graph, dup_volinfo, set_dict, NULL); + if (ret) + goto out; + } + if (is_hot_shd) { + is_hot_tier = _gf_true; + ret = glusterd_create_sub_tier_volinfo(volinfo, &dup_volinfo, + is_hot_tier, volinfo->volname); + if (ret) + goto out; + ret = volgen_graph_build_clients(graph, dup_volinfo, set_dict, NULL); + if (ret) + goto out; + } +out: + if (dup_volinfo) + glusterd_volinfo_delete(dup_volinfo); + return ret; } static int -volgen_link_bricks (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, char *xl_type, - char *xl_namefmt, size_t child_count, - size_t sub_count, size_t start_count, - xlator_t *trav) -{ - int i = 0; - int j = start_count; - xlator_t *xl = NULL; - char *volname = NULL; - int ret = -1; - - if (child_count == 0) +volgen_link_bricks(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + char *xl_type, char *xl_namefmt, size_t child_count, + size_t sub_count, size_t start_count, xlator_t *trav) +{ + int i = 0; + int j = start_count; + xlator_t *xl = NULL; + char *volname = NULL; + int ret = -1; + + if (child_count == 0) + goto out; + volname = volinfo->volname; + + for (;; trav = trav->prev) { + if ((i % sub_count) == 0) { + xl = volgen_graph_add_nolink(graph, xl_type, xl_namefmt, volname, + j); + if (!xl) { + ret = -1; goto out; - volname = volinfo->volname; - - for (;; trav = trav->prev) { - if ((i % sub_count) == 0) { - xl = volgen_graph_add_nolink (graph, xl_type, - xl_namefmt, volname, j); - if (!xl) { - ret = -1; - goto out; - } - j++; - } + } + j++; + } - ret = volgen_xlator_link (xl, trav); - if (ret) - goto out; + ret = volgen_xlator_link(xl, trav); + if (ret) + goto out; - i++; - if (i == child_count) - break; - } + i++; + if (i == child_count) + break; + } - ret = j - start_count; + ret = j - start_count; out: - return ret; + return ret; } static int -volgen_link_bricks_from_list_tail_start (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - char *xl_type, - char *xl_namefmt, size_t child_count, - size_t sub_count, size_t start_count) +volgen_link_bricks_from_list_tail_start(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, + char *xl_type, char *xl_namefmt, + size_t child_count, size_t sub_count, + size_t start_count) { - xlator_t *trav = NULL; - size_t cnt = child_count; + xlator_t *trav = NULL; + size_t cnt = child_count; - if (!cnt) - return -1; + if (!cnt) + return -1; - for (trav = first_of(graph); --cnt; trav = trav->next) - ; + for (trav = first_of(graph); --cnt; trav = trav->next) + ; - return volgen_link_bricks (graph, volinfo, - xl_type, - xl_namefmt, - child_count, - sub_count, start_count, - trav); + return volgen_link_bricks(graph, volinfo, xl_type, xl_namefmt, child_count, + sub_count, start_count, trav); } static int -volgen_link_bricks_from_list_head_start (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - char *xl_type, - char *xl_namefmt, size_t child_count, - size_t sub_count, size_t start_count) +volgen_link_bricks_from_list_head_start(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, + char *xl_type, char *xl_namefmt, + size_t child_count, size_t sub_count, + size_t start_count) { - xlator_t *trav = NULL; + xlator_t *trav = NULL; - for (trav = first_of(graph); trav->next; trav = trav->next) - ; + for (trav = first_of(graph); trav->next; trav = trav->next) + ; - return volgen_link_bricks (graph, volinfo, - xl_type, - xl_namefmt, - child_count, - sub_count, start_count, - trav); + return volgen_link_bricks(graph, volinfo, xl_type, xl_namefmt, child_count, + sub_count, start_count, trav); } static int -volgen_link_bricks_from_list_tail (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - char *xl_type, - char *xl_namefmt, size_t child_count, - size_t sub_count) +volgen_link_bricks_from_list_tail(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, char *xl_type, + char *xl_namefmt, size_t child_count, + size_t sub_count) { - xlator_t *trav = NULL; - size_t cnt = child_count; + xlator_t *trav = NULL; + size_t cnt = child_count; - if (!cnt) - return -1; + if (!cnt) + return -1; - for (trav = first_of(graph); --cnt; trav = trav->next) - ; + for (trav = first_of(graph); --cnt; trav = trav->next) + ; - return volgen_link_bricks (graph, volinfo, - xl_type, - xl_namefmt, - child_count, - sub_count, 0, - trav); + return volgen_link_bricks(graph, volinfo, xl_type, xl_namefmt, child_count, + sub_count, 0, trav); } static int -volgen_link_bricks_from_list_head (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, char *xl_type, - char *xl_namefmt, size_t child_count, - size_t sub_count) +volgen_link_bricks_from_list_head(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, char *xl_type, + char *xl_namefmt, size_t child_count, + size_t sub_count) { - xlator_t *trav = NULL; + xlator_t *trav = NULL; - for (trav = first_of(graph); trav->next; trav = trav->next) - ; + for (trav = first_of(graph); trav->next; trav = trav->next) + ; - return volgen_link_bricks (graph, volinfo, - xl_type, - xl_namefmt, - child_count, - sub_count, 0, - trav); + return volgen_link_bricks(graph, volinfo, xl_type, xl_namefmt, child_count, + sub_count, 0, trav); } /** @@ -3566,2077 +3479,1970 @@ volgen_link_bricks_from_list_head (volgen_graph_t *graph, * Generates snapview-client */ static int -volgen_graph_build_snapview_client (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - char *volname, dict_t *set_dict) -{ - int ret = 0; - xlator_t *prev_top = NULL; - xlator_t *prot_clnt = NULL; - xlator_t *svc = NULL; - char transt [16] = {0,}; - char *svc_args[] = {"features/snapview-client", - "%s-snapview-client"}; - char subvol [1024] = {0,}; - char xl_id [1024] = {0,}; - - prev_top = (xlator_t *)(graph->graph.first); - - snprintf (subvol, sizeof (subvol), "snapd-%s", volinfo->volname); - snprintf (xl_id, sizeof (xl_id), "%s-snapd-client", volinfo->volname); - - get_transport_type (volinfo, set_dict, transt, _gf_false); - - prot_clnt = volgen_graph_build_client (graph, volinfo, - NULL, NULL, subvol, - xl_id, transt, set_dict); - if (!prot_clnt) { - ret = -1; - goto out; - } - - svc = volgen_graph_add_nolink (graph, svc_args[0], svc_args[1], - volname); - if (!svc) { - ret = -1; - goto out; - } - - /** - * Ordering the below two traslators (cur_top & prot_clnt) is important - * as snapview client implementation is built on the policy that - * normal volume path goes to FIRST_CHILD and snap world operations - * goes to SECOND_CHILD - **/ - ret = volgen_xlator_link (graph->graph.first, prev_top); - if (ret) { - gf_msg (THIS->name, GF_LOG_ERROR, 0, - GD_MSG_XLATOR_LINK_FAIL, "failed to link the " - "snapview-client to distribute"); - goto out; - } +volgen_graph_build_snapview_client(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, char *volname, + dict_t *set_dict) +{ + int ret = 0; + xlator_t *prev_top = NULL; + xlator_t *prot_clnt = NULL; + xlator_t *svc = NULL; + char transt[16] = { + 0, + }; + char *svc_args[] = {"features/snapview-client", "%s-snapview-client"}; + char subvol[1024] = { + 0, + }; + char xl_id[1024] = { + 0, + }; + + prev_top = (xlator_t *)(graph->graph.first); + + snprintf(subvol, sizeof(subvol), "snapd-%s", volinfo->volname); + snprintf(xl_id, sizeof(xl_id), "%s-snapd-client", volinfo->volname); + + get_transport_type(volinfo, set_dict, transt, _gf_false); + + prot_clnt = volgen_graph_build_client(graph, volinfo, NULL, NULL, subvol, + xl_id, transt, set_dict); + if (!prot_clnt) { + ret = -1; + goto out; + } - ret = volgen_xlator_link (graph->graph.first, prot_clnt); - if (ret) { - gf_msg (THIS->name, GF_LOG_ERROR, 0, - GD_MSG_XLATOR_LINK_FAIL, "failed to link the " - "snapview-client to snapview-server"); - goto out; - } + svc = volgen_graph_add_nolink(graph, svc_args[0], svc_args[1], volname); + if (!svc) { + ret = -1; + goto out; + } + + /** + * Ordering the below two traslators (cur_top & prot_clnt) is important + * as snapview client implementation is built on the policy that + * normal volume path goes to FIRST_CHILD and snap world operations + * goes to SECOND_CHILD + **/ + ret = volgen_xlator_link(graph->graph.first, prev_top); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_XLATOR_LINK_FAIL, + "failed to link the " + "snapview-client to distribute"); + goto out; + } + + ret = volgen_xlator_link(graph->graph.first, prot_clnt); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_XLATOR_LINK_FAIL, + "failed to link the " + "snapview-client to snapview-server"); + goto out; + } out: - return ret; + return ret; } gf_boolean_t -_xl_is_client_decommissioned (xlator_t *xl, glusterd_volinfo_t *volinfo) -{ - int ret = 0; - gf_boolean_t decommissioned = _gf_false; - char *hostname = NULL; - char *path = NULL; - - GF_ASSERT (!strcmp (xl->type, "protocol/client")); - ret = xlator_get_option (xl, "remote-host", &hostname); - if (ret) { - GF_ASSERT (0); - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_REMOTE_HOST_GET_FAIL, - "Failed to get remote-host " - "from client %s", xl->name); - goto out; - } - ret = xlator_get_option (xl, "remote-subvolume", &path); - if (ret) { - GF_ASSERT (0); - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_REMOTE_HOST_GET_FAIL, - "Failed to get remote-host " - "from client %s", xl->name); - goto out; - } - - decommissioned = glusterd_is_brick_decommissioned (volinfo, hostname, - path); +_xl_is_client_decommissioned(xlator_t *xl, glusterd_volinfo_t *volinfo) +{ + int ret = 0; + gf_boolean_t decommissioned = _gf_false; + char *hostname = NULL; + char *path = NULL; + + GF_ASSERT(!strcmp(xl->type, "protocol/client")); + ret = xlator_get_option(xl, "remote-host", &hostname); + if (ret) { + GF_ASSERT(0); + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_REMOTE_HOST_GET_FAIL, + "Failed to get remote-host " + "from client %s", + xl->name); + goto out; + } + ret = xlator_get_option(xl, "remote-subvolume", &path); + if (ret) { + GF_ASSERT(0); + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_REMOTE_HOST_GET_FAIL, + "Failed to get remote-host " + "from client %s", + xl->name); + goto out; + } + + decommissioned = glusterd_is_brick_decommissioned(volinfo, hostname, path); out: - return decommissioned; + return decommissioned; } gf_boolean_t -_xl_has_decommissioned_clients (xlator_t *xl, glusterd_volinfo_t *volinfo) -{ - xlator_list_t *xl_child = NULL; - gf_boolean_t decommissioned = _gf_false; - xlator_t *cxl = NULL; - - if (!xl) - goto out; - - if (!strcmp (xl->type, "protocol/client")) { - decommissioned = _xl_is_client_decommissioned (xl, volinfo); - goto out; - } - - xl_child = xl->children; - while (xl_child) { - cxl = xl_child->xlator; - /* this can go into 2 depths if the volume type - is stripe-replicate */ - decommissioned = _xl_has_decommissioned_clients (cxl, volinfo); - if (decommissioned) - break; - - xl_child = xl_child->next; - } +_xl_has_decommissioned_clients(xlator_t *xl, glusterd_volinfo_t *volinfo) +{ + xlator_list_t *xl_child = NULL; + gf_boolean_t decommissioned = _gf_false; + xlator_t *cxl = NULL; + + if (!xl) + goto out; + + if (!strcmp(xl->type, "protocol/client")) { + decommissioned = _xl_is_client_decommissioned(xl, volinfo); + goto out; + } + + xl_child = xl->children; + while (xl_child) { + cxl = xl_child->xlator; + /* this can go into 2 depths if the volume type + is stripe-replicate */ + decommissioned = _xl_has_decommissioned_clients(cxl, volinfo); + if (decommissioned) + break; + + xl_child = xl_child->next; + } out: - return decommissioned; + return decommissioned; } static int -_graph_get_decommissioned_children (xlator_t *dht, glusterd_volinfo_t *volinfo, - char **children) -{ - int ret = -1; - xlator_list_t *xl_child = NULL; - xlator_t *cxl = NULL; - gf_boolean_t comma = _gf_false; - - *children = NULL; - xl_child = dht->children; - while (xl_child) { - cxl = xl_child->xlator; - if (_xl_has_decommissioned_clients (cxl, volinfo)) { - if (!*children) { - *children = GF_CALLOC (16 * GF_UNIT_KB, 1, - gf_common_mt_char); - if (!*children) - goto out; - } - - if (comma) - strcat (*children, ","); - strcat (*children, cxl->name); - comma = _gf_true; - } - - xl_child = xl_child->next; - } - ret = 0; +_graph_get_decommissioned_children(xlator_t *dht, glusterd_volinfo_t *volinfo, + char **children) +{ + int ret = -1; + xlator_list_t *xl_child = NULL; + xlator_t *cxl = NULL; + gf_boolean_t comma = _gf_false; + + *children = NULL; + xl_child = dht->children; + while (xl_child) { + cxl = xl_child->xlator; + if (_xl_has_decommissioned_clients(cxl, volinfo)) { + if (!*children) { + *children = GF_CALLOC(16 * GF_UNIT_KB, 1, gf_common_mt_char); + if (!*children) + goto out; + } + + if (comma) + strcat(*children, ","); + strcat(*children, cxl->name); + comma = _gf_true; + } + + xl_child = xl_child->next; + } + ret = 0; out: - return ret; + return ret; } static int -volgen_graph_build_readdir_ahead (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - size_t child_count) +volgen_graph_build_readdir_ahead(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, + size_t child_count) { - int32_t clusters = 0; + int32_t clusters = 0; - if (graph->type == GF_QUOTAD || - graph->type == GF_SNAPD || - !glusterd_volinfo_get_boolean (volinfo, VKEY_PARALLEL_READDIR) || - !glusterd_volinfo_get_boolean (volinfo, VKEY_READDIR_AHEAD)) - goto out; + if (graph->type == GF_QUOTAD || graph->type == GF_SNAPD || + !glusterd_volinfo_get_boolean(volinfo, VKEY_PARALLEL_READDIR) || + !glusterd_volinfo_get_boolean(volinfo, VKEY_READDIR_AHEAD)) + goto out; - clusters = volgen_link_bricks_from_list_tail (graph, - volinfo, - "performance/readdir-ahead", - "%s-readdir-ahead-%d", - child_count, - 1); + clusters = volgen_link_bricks_from_list_tail( + graph, volinfo, "performance/readdir-ahead", "%s-readdir-ahead-%d", + child_count, 1); out: - return clusters; + return clusters; } static int -volgen_graph_build_dht_cluster (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, size_t child_count, - gf_boolean_t is_quotad) -{ - int32_t clusters = 0; - int ret = -1; - char *decommissioned_children = NULL; - xlator_t *dht = NULL; - char *voltype = "cluster/distribute"; - char *name_fmt = NULL; - - /* NUFA and Switch section */ - if (dict_get_str_boolean (volinfo->dict, "cluster.nufa", 0) && - dict_get_str_boolean (volinfo->dict, "cluster.switch", 0)) { - gf_msg (THIS->name, GF_LOG_ERROR, errno, - GD_MSG_DICT_GET_FAILED, - "nufa and switch cannot be set together"); - ret = -1; - goto out; - } +volgen_graph_build_dht_cluster(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, size_t child_count, + gf_boolean_t is_quotad) +{ + int32_t clusters = 0; + int ret = -1; + char *decommissioned_children = NULL; + xlator_t *dht = NULL; + char *voltype = "cluster/distribute"; + char *name_fmt = NULL; + + /* NUFA and Switch section */ + if (dict_get_str_boolean(volinfo->dict, "cluster.nufa", 0) && + dict_get_str_boolean(volinfo->dict, "cluster.switch", 0)) { + gf_msg(THIS->name, GF_LOG_ERROR, errno, GD_MSG_DICT_GET_FAILED, + "nufa and switch cannot be set together"); + ret = -1; + goto out; + } - /* Check for NUFA volume option, and change the voltype */ - if (dict_get_str_boolean (volinfo->dict, "cluster.nufa", 0)) - voltype = "cluster/nufa"; + /* Check for NUFA volume option, and change the voltype */ + if (dict_get_str_boolean(volinfo->dict, "cluster.nufa", 0)) + voltype = "cluster/nufa"; - /* Check for switch volume option, and change the voltype */ - if (dict_get_str_boolean (volinfo->dict, "cluster.switch", 0)) - voltype = "cluster/switch"; + /* Check for switch volume option, and change the voltype */ + if (dict_get_str_boolean(volinfo->dict, "cluster.switch", 0)) + voltype = "cluster/switch"; - if (is_quotad) - name_fmt = "%s"; - else - name_fmt = "%s-dht"; - - clusters = volgen_link_bricks_from_list_tail (graph, volinfo, - voltype, - name_fmt, - child_count, - child_count); - if (clusters < 0) - goto out; + if (is_quotad) + name_fmt = "%s"; + else + name_fmt = "%s-dht"; - if (volinfo->type == GF_CLUSTER_TYPE_TIER) { - ret = 0; - goto out; - } + clusters = volgen_link_bricks_from_list_tail( + graph, volinfo, voltype, name_fmt, child_count, child_count); + if (clusters < 0) + goto out; - dht = first_of (graph); - ret = _graph_get_decommissioned_children (dht, volinfo, - &decommissioned_children); - if (ret) - goto out; - if (decommissioned_children) { - ret = xlator_set_option (dht, "decommissioned-bricks", - decommissioned_children); - if (ret) - goto out; - } + if (volinfo->type == GF_CLUSTER_TYPE_TIER) { ret = 0; + goto out; + } + + dht = first_of(graph); + ret = _graph_get_decommissioned_children(dht, volinfo, + &decommissioned_children); + if (ret) + goto out; + if (decommissioned_children) { + ret = xlator_set_option(dht, "decommissioned-bricks", + decommissioned_children); + if (ret) + goto out; + } + ret = 0; out: - GF_FREE (decommissioned_children); - return ret; + GF_FREE(decommissioned_children); + return ret; } static int -volgen_graph_build_ec_clusters (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo) -{ - int i = 0; - int ret = 0; - int clusters = 0; - char *disperse_args[] = {"cluster/disperse", - "%s-disperse-%d"}; - xlator_t *ec = NULL; - char option[32] = {0}; - int start_count = 0; - - if (volinfo->tier_info.cur_tier_hot && - volinfo->tier_info.cold_type == GF_CLUSTER_TYPE_DISPERSE) - start_count = volinfo->tier_info.cold_brick_count/ - volinfo->tier_info.cold_disperse_count; - - clusters = volgen_link_bricks_from_list_tail_start (graph, volinfo, - disperse_args[0], - disperse_args[1], - volinfo->brick_count, - volinfo->disperse_count, - start_count); - if (clusters < 0) - goto out; - - sprintf(option, "%d", volinfo->redundancy_count); - ec = first_of (graph); - for (i = 0; i < clusters; i++) { - ret = xlator_set_option (ec, "redundancy", option); - if (ret) { - clusters = -1; - goto out; - } - - ec = ec->next; +volgen_graph_build_ec_clusters(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo) +{ + int i = 0; + int ret = 0; + int clusters = 0; + char *disperse_args[] = {"cluster/disperse", "%s-disperse-%d"}; + xlator_t *ec = NULL; + char option[32] = {0}; + int start_count = 0; + + if (volinfo->tier_info.cur_tier_hot && + volinfo->tier_info.cold_type == GF_CLUSTER_TYPE_DISPERSE) + start_count = volinfo->tier_info.cold_brick_count / + volinfo->tier_info.cold_disperse_count; + + clusters = volgen_link_bricks_from_list_tail_start( + graph, volinfo, disperse_args[0], disperse_args[1], + volinfo->brick_count, volinfo->disperse_count, start_count); + if (clusters < 0) + goto out; + + sprintf(option, "%d", volinfo->redundancy_count); + ec = first_of(graph); + for (i = 0; i < clusters; i++) { + ret = xlator_set_option(ec, "redundancy", option); + if (ret) { + clusters = -1; + goto out; } + + ec = ec->next; + } out: - return clusters; + return clusters; } static int -set_afr_pending_xattrs_option (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - int clusters) -{ - xlator_t *xlator = NULL; - xlator_t **afr_xlators_list = NULL; - xlator_t *this = NULL; - glusterd_conf_t *conf = NULL; - glusterd_brickinfo_t *brick = NULL; - char *ptr = NULL; - int i = 0; - int index = -1; - int ret = 0; - char *afr_xattrs_list = NULL; - int list_size = -1; - - this = THIS; - GF_VALIDATE_OR_GOTO ("glusterd", this, out); - conf = this->private; - GF_VALIDATE_OR_GOTO (this->name, conf, out); - - if (conf->op_version < GD_OP_VERSION_3_9_0) - return ret; - - /* (brick_id x rep.count) + (rep.count-1 commas) + NULL*/ - list_size = (1024 * volinfo->replica_count) + - (volinfo->replica_count - 1) + 1; - afr_xattrs_list = GF_CALLOC (1, list_size, gf_common_mt_char); - if (!afr_xattrs_list) - goto out; - - ptr = afr_xattrs_list; - afr_xlators_list = GF_CALLOC (clusters, sizeof (xlator_t *), - gf_common_mt_xlator_t); - if (!afr_xlators_list) - goto out; - - xlator = first_of (graph); +set_afr_pending_xattrs_option(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, int clusters) +{ + xlator_t *xlator = NULL; + xlator_t **afr_xlators_list = NULL; + xlator_t *this = NULL; + glusterd_conf_t *conf = NULL; + glusterd_brickinfo_t *brick = NULL; + char *ptr = NULL; + int i = 0; + int index = -1; + int ret = 0; + char *afr_xattrs_list = NULL; + int list_size = -1; + + this = THIS; + GF_VALIDATE_OR_GOTO("glusterd", this, out); + conf = this->private; + GF_VALIDATE_OR_GOTO(this->name, conf, out); + + if (conf->op_version < GD_OP_VERSION_3_9_0) + return ret; - for (i = 0, index = clusters - 1; i < clusters; i++) { - afr_xlators_list[index--] = xlator; - xlator = xlator->next; - } - - i = 1; - index = 0; - - cds_list_for_each_entry (brick, &volinfo->bricks, brick_list) { - if (index == clusters) - break; - strncat (ptr, brick->brick_id, strlen(brick->brick_id)); - if (i == volinfo->replica_count) { - ret = xlator_set_option (afr_xlators_list[index++], - "afr-pending-xattr", - afr_xattrs_list); - if (ret) - goto out; - memset (afr_xattrs_list, 0, list_size); - ptr = afr_xattrs_list; - i = 1; - continue; - } - ptr[strlen(brick->brick_id)] = ','; - ptr += strlen (brick->brick_id) + 1; - i++; - } + /* (brick_id x rep.count) + (rep.count-1 commas) + NULL*/ + list_size = (1024 * volinfo->replica_count) + (volinfo->replica_count - 1) + + 1; + afr_xattrs_list = GF_CALLOC(1, list_size, gf_common_mt_char); + if (!afr_xattrs_list) + goto out; + + ptr = afr_xattrs_list; + afr_xlators_list = GF_CALLOC(clusters, sizeof(xlator_t *), + gf_common_mt_xlator_t); + if (!afr_xlators_list) + goto out; + + xlator = first_of(graph); + + for (i = 0, index = clusters - 1; i < clusters; i++) { + afr_xlators_list[index--] = xlator; + xlator = xlator->next; + } + + i = 1; + index = 0; + + cds_list_for_each_entry(brick, &volinfo->bricks, brick_list) + { + if (index == clusters) + break; + strncat(ptr, brick->brick_id, strlen(brick->brick_id)); + if (i == volinfo->replica_count) { + ret = xlator_set_option(afr_xlators_list[index++], + "afr-pending-xattr", afr_xattrs_list); + if (ret) + goto out; + memset(afr_xattrs_list, 0, list_size); + ptr = afr_xattrs_list; + i = 1; + continue; + } + ptr[strlen(brick->brick_id)] = ','; + ptr += strlen(brick->brick_id) + 1; + i++; + } out: - GF_FREE (afr_xattrs_list); - GF_FREE (afr_xlators_list); - return ret; + GF_FREE(afr_xattrs_list); + GF_FREE(afr_xlators_list); + return ret; } static int -volgen_graph_build_afr_clusters (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo) -{ - int i = 0; - int ret = 0; - int clusters = 0; - char *replicate_type = NULL; - char *replicate_name = "%s-replicate-%d"; - xlator_t *afr = NULL; - char option[32] = {0}; - int start_count = 0; - - if (glusterd_volinfo_get_boolean(volinfo, "cluster.jbr") > 0) { - replicate_type = "experimental/jbrc"; - } else { - replicate_type = "cluster/replicate"; - } - - if (volinfo->tier_info.cold_type == GF_CLUSTER_TYPE_REPLICATE) - start_count = volinfo->tier_info.cold_brick_count / - volinfo->tier_info.cold_replica_count; - - if (volinfo->tier_info.cur_tier_hot) - clusters = volgen_link_bricks_from_list_head_start (graph, - volinfo, - replicate_type, - replicate_name, - volinfo->brick_count, - volinfo->replica_count, - start_count); - else - clusters = volgen_link_bricks_from_list_tail (graph, - volinfo, - replicate_type, - replicate_name, - volinfo->brick_count, - volinfo->replica_count); - - if (clusters < 0) - goto out; - - ret = set_afr_pending_xattrs_option (graph, volinfo, clusters); +volgen_graph_build_afr_clusters(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo) +{ + int i = 0; + int ret = 0; + int clusters = 0; + char *replicate_type = NULL; + char *replicate_name = "%s-replicate-%d"; + xlator_t *afr = NULL; + char option[32] = {0}; + int start_count = 0; + + if (glusterd_volinfo_get_boolean(volinfo, "cluster.jbr") > 0) { + replicate_type = "experimental/jbrc"; + } else { + replicate_type = "cluster/replicate"; + } + + if (volinfo->tier_info.cold_type == GF_CLUSTER_TYPE_REPLICATE) + start_count = volinfo->tier_info.cold_brick_count / + volinfo->tier_info.cold_replica_count; + + if (volinfo->tier_info.cur_tier_hot) + clusters = volgen_link_bricks_from_list_head_start( + graph, volinfo, replicate_type, replicate_name, + volinfo->brick_count, volinfo->replica_count, start_count); + else + clusters = volgen_link_bricks_from_list_tail( + graph, volinfo, replicate_type, replicate_name, + volinfo->brick_count, volinfo->replica_count); + + if (clusters < 0) + goto out; + + ret = set_afr_pending_xattrs_option(graph, volinfo, clusters); + if (ret) { + clusters = -1; + goto out; + } + if (!volinfo->arbiter_count) + goto out; + + afr = first_of(graph); + sprintf(option, "%d", volinfo->arbiter_count); + for (i = 0; i < clusters; i++) { + ret = xlator_set_option(afr, "arbiter-count", option); if (ret) { - clusters = -1; - goto out; - } - if (!volinfo->arbiter_count) - goto out; - - afr = first_of (graph); - sprintf(option, "%d", volinfo->arbiter_count); - for (i = 0; i < clusters; i++) { - ret = xlator_set_option (afr, "arbiter-count", option); - if (ret) { - clusters = -1; - goto out; - } - afr = afr->next; + clusters = -1; + goto out; } + afr = afr->next; + } out: - return clusters; + return clusters; } static int -volume_volgen_graph_build_clusters (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - gf_boolean_t is_quotad) -{ - char *tier_args[] = {"cluster/tier", - "%s-tier-%d"}; - char *stripe_args[] = {"cluster/stripe", - "%s-stripe-%d"}; - int rclusters = 0; - int clusters = 0; - int dist_count = 0; - int ret = -1; - char tmp_volname[GD_VOLUME_NAME_MAX_TIER] = {0, }; - - if (!volinfo->dist_leaf_count) - goto out; - - if (volinfo->dist_leaf_count == 1) - goto build_distribute; - - /* All other cases, it will have one or the other cluster type */ - switch (volinfo->type) { +volume_volgen_graph_build_clusters(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, + gf_boolean_t is_quotad) +{ + char *tier_args[] = {"cluster/tier", "%s-tier-%d"}; + char *stripe_args[] = {"cluster/stripe", "%s-stripe-%d"}; + int rclusters = 0; + int clusters = 0; + int dist_count = 0; + int ret = -1; + char tmp_volname[GD_VOLUME_NAME_MAX_TIER] = { + 0, + }; + + if (!volinfo->dist_leaf_count) + goto out; + + if (volinfo->dist_leaf_count == 1) + goto build_distribute; + + /* All other cases, it will have one or the other cluster type */ + switch (volinfo->type) { case GF_CLUSTER_TYPE_REPLICATE: - clusters = volgen_graph_build_afr_clusters (graph, volinfo); - if (clusters < 0) - goto out; - break; + clusters = volgen_graph_build_afr_clusters(graph, volinfo); + if (clusters < 0) + goto out; + break; case GF_CLUSTER_TYPE_STRIPE: - clusters = volgen_link_bricks_from_list_tail (graph, volinfo, - stripe_args[0], - stripe_args[1], - volinfo->brick_count, - volinfo->stripe_count); - if (clusters < 0) - goto out; - break; + clusters = volgen_link_bricks_from_list_tail( + graph, volinfo, stripe_args[0], stripe_args[1], + volinfo->brick_count, volinfo->stripe_count); + if (clusters < 0) + goto out; + break; case GF_CLUSTER_TYPE_TIER: - ret = volgen_link_bricks_from_list_head (graph, volinfo, - tier_args[0], - tier_args[1], - volinfo->brick_count, - volinfo->replica_count); - break; + ret = volgen_link_bricks_from_list_head( + graph, volinfo, tier_args[0], tier_args[1], + volinfo->brick_count, volinfo->replica_count); + break; case GF_CLUSTER_TYPE_STRIPE_REPLICATE: - /* Replicate after the clients, then stripe */ - if (volinfo->replica_count == 0) - goto out; - clusters = volgen_graph_build_afr_clusters (graph, volinfo); - if (clusters < 0) - goto out; - - rclusters = volinfo->brick_count / volinfo->replica_count; - GF_ASSERT (rclusters == clusters); - clusters = volgen_link_bricks_from_list_tail (graph, volinfo, - stripe_args[0], - stripe_args[1], - rclusters, - volinfo->stripe_count); - if (clusters < 0) - goto out; - break; - - case GF_CLUSTER_TYPE_DISPERSE: - clusters = volgen_graph_build_ec_clusters (graph, volinfo); - if (clusters < 0) - goto out; - - break; - default: - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_VOLUME_INCONSISTENCY, - "volume inconsistency: " - "unrecognized clustering type"); + /* Replicate after the clients, then stripe */ + if (volinfo->replica_count == 0) goto out; - } - -build_distribute: - dist_count = volinfo->brick_count / volinfo->dist_leaf_count; - if (!dist_count) { - ret = -1; - goto out; - } - if (volinfo->tier_info.hot_brick_count) { - if (snprintf (tmp_volname, GD_VOLUME_NAME_MAX_TIER, "%s", - volinfo->volname) >= GD_VOLUME_NAME_MAX_TIER) { - ret = -1; - goto out; - } - if (volinfo->tier_info.cur_tier_hot) - strcat (volinfo->volname, "-hot"); - else - strcat (volinfo->volname, "-cold"); - } - clusters = volgen_graph_build_readdir_ahead (graph, volinfo, - dist_count); - if (clusters < 0) + clusters = volgen_graph_build_afr_clusters(graph, volinfo); + if (clusters < 0) goto out; - ret = volgen_graph_build_dht_cluster (graph, volinfo, - dist_count, is_quotad); - if (volinfo->tier_info.hot_brick_count) - strcpy (volinfo->volname, tmp_volname); - if (ret) + rclusters = volinfo->brick_count / volinfo->replica_count; + GF_ASSERT(rclusters == clusters); + clusters = volgen_link_bricks_from_list_tail( + graph, volinfo, stripe_args[0], stripe_args[1], rclusters, + volinfo->stripe_count); + if (clusters < 0) goto out; + break; - ret = 0; -out: - return ret; -} - -static int -client_graph_set_rda_options (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - dict_t *set_dict) -{ - char *rda_cache_s = NULL; - int32_t ret = 0; - uint64_t rda_cache_size = 0; - char *rda_req_s = NULL; - uint64_t rda_req_size = 0; - uint64_t new_cache_size = 0; - char new_cache_size_str[50] = {0,}; - char new_req_size_str[50] = {0,}; - int dist_count = 0; - - dist_count = volinfo->brick_count / volinfo->dist_leaf_count; - if (dist_count <= 1) - goto out; - - if (graph->type == GF_QUOTAD || - graph->type == GF_SNAPD || - !glusterd_volinfo_get_boolean (volinfo, VKEY_PARALLEL_READDIR) || - !glusterd_volinfo_get_boolean (volinfo, VKEY_READDIR_AHEAD)) - goto out; - - /* glusterd_volinfo_get() will get the default value if nothing set - * explicitly. Hence it is important to check set_dict before checking - * glusterd_volinfo_get, so that we consider key value of the in - * progress volume set option. - */ - ret = dict_get_str (set_dict, VKEY_RDA_CACHE_LIMIT, &rda_cache_s); - if (ret < 0) { - ret = glusterd_volinfo_get (volinfo, VKEY_RDA_CACHE_LIMIT, - &rda_cache_s); - if (ret < 0) - goto out; - } - ret = gf_string2bytesize_uint64 (rda_cache_s, &rda_cache_size); - if (ret < 0) { - set_graph_errstr (graph, "invalid number format in option " - VKEY_RDA_CACHE_LIMIT); - goto out; - } - - ret = dict_get_str (set_dict, VKEY_RDA_REQUEST_SIZE, &rda_req_s); - if (ret < 0) { - ret = glusterd_volinfo_get (volinfo, VKEY_RDA_REQUEST_SIZE, - &rda_req_s); - if (ret < 0) - goto out; - } - ret = gf_string2bytesize_uint64 (rda_req_s, &rda_req_size); - if (ret < 0) { - set_graph_errstr (graph, "invalid number format in option " - VKEY_RDA_REQUEST_SIZE); + case GF_CLUSTER_TYPE_DISPERSE: + clusters = volgen_graph_build_ec_clusters(graph, volinfo); + if (clusters < 0) goto out; - } - if (rda_cache_size == 0 || rda_req_size == 0) { - set_graph_errstr (graph, "Value cannot be 0"); - ret = -1; - goto out; - } + break; + default: + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_VOLUME_INCONSISTENCY, + "volume inconsistency: " + "unrecognized clustering type"); + goto out; + } - new_cache_size = rda_cache_size / dist_count; - if (new_cache_size < rda_req_size) { - if (new_cache_size < 4 * 1024) - new_cache_size = rda_req_size = 4 * 1024; - else - rda_req_size = new_cache_size; - - snprintf (new_req_size_str, sizeof (new_req_size_str), - "%ld%s", rda_req_size, "B"); - ret = dict_set_dynstr_with_alloc (set_dict, - VKEY_RDA_REQUEST_SIZE, - new_req_size_str); - if (ret < 0) - goto out; +build_distribute: + dist_count = volinfo->brick_count / volinfo->dist_leaf_count; + if (!dist_count) { + ret = -1; + goto out; + } + if (volinfo->tier_info.hot_brick_count) { + if (snprintf(tmp_volname, GD_VOLUME_NAME_MAX_TIER, "%s", + volinfo->volname) >= GD_VOLUME_NAME_MAX_TIER) { + ret = -1; + goto out; } - - snprintf (new_cache_size_str, sizeof (new_cache_size_str), - "%ld%s", new_cache_size, "B"); - ret = dict_set_dynstr_with_alloc (set_dict, - VKEY_RDA_CACHE_LIMIT, - new_cache_size_str); - if (ret < 0) - goto out; - + if (volinfo->tier_info.cur_tier_hot) + strcat(volinfo->volname, "-hot"); + else + strcat(volinfo->volname, "-cold"); + } + clusters = volgen_graph_build_readdir_ahead(graph, volinfo, dist_count); + if (clusters < 0) + goto out; + + ret = volgen_graph_build_dht_cluster(graph, volinfo, dist_count, is_quotad); + if (volinfo->tier_info.hot_brick_count) + strcpy(volinfo->volname, tmp_volname); + if (ret) + goto out; + + ret = 0; out: - return ret; + return ret; } +static int +client_graph_set_rda_options(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict) +{ + char *rda_cache_s = NULL; + int32_t ret = 0; + uint64_t rda_cache_size = 0; + char *rda_req_s = NULL; + uint64_t rda_req_size = 0; + uint64_t new_cache_size = 0; + char new_cache_size_str[50] = { + 0, + }; + char new_req_size_str[50] = { + 0, + }; + int dist_count = 0; + + dist_count = volinfo->brick_count / volinfo->dist_leaf_count; + if (dist_count <= 1) + goto out; + + if (graph->type == GF_QUOTAD || graph->type == GF_SNAPD || + !glusterd_volinfo_get_boolean(volinfo, VKEY_PARALLEL_READDIR) || + !glusterd_volinfo_get_boolean(volinfo, VKEY_READDIR_AHEAD)) + goto out; + + /* glusterd_volinfo_get() will get the default value if nothing set + * explicitly. Hence it is important to check set_dict before checking + * glusterd_volinfo_get, so that we consider key value of the in + * progress volume set option. + */ + ret = dict_get_str(set_dict, VKEY_RDA_CACHE_LIMIT, &rda_cache_s); + if (ret < 0) { + ret = glusterd_volinfo_get(volinfo, VKEY_RDA_CACHE_LIMIT, &rda_cache_s); + if (ret < 0) + goto out; + } + ret = gf_string2bytesize_uint64(rda_cache_s, &rda_cache_size); + if (ret < 0) { + set_graph_errstr( + graph, "invalid number format in option " VKEY_RDA_CACHE_LIMIT); + goto out; + } + + ret = dict_get_str(set_dict, VKEY_RDA_REQUEST_SIZE, &rda_req_s); + if (ret < 0) { + ret = glusterd_volinfo_get(volinfo, VKEY_RDA_REQUEST_SIZE, &rda_req_s); + if (ret < 0) + goto out; + } + ret = gf_string2bytesize_uint64(rda_req_s, &rda_req_size); + if (ret < 0) { + set_graph_errstr( + graph, "invalid number format in option " VKEY_RDA_REQUEST_SIZE); + goto out; + } + + if (rda_cache_size == 0 || rda_req_size == 0) { + set_graph_errstr(graph, "Value cannot be 0"); + ret = -1; + goto out; + } -static int client_graph_set_perf_options(volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - dict_t *set_dict) -{ - data_t *tmp_data = NULL; - char *volname = NULL; - int ret = 0; - - /* - * Logic to make sure gfproxy-client gets custom performance translators - */ - ret = dict_get_str_boolean (set_dict, "gfproxy-client", 0); - if (ret == 1) { - return volgen_graph_set_options_generic ( - graph, set_dict, volinfo, - &gfproxy_client_perfxl_option_handler); - } - - /* - * Logic to make sure gfproxy-server gets custom performance translators - */ - ret = dict_get_str_boolean (set_dict, "gfproxy-server", 0); - if (ret == 1) { - return volgen_graph_set_options_generic ( - graph, set_dict, volinfo, - &gfproxy_server_perfxl_option_handler); - } + new_cache_size = rda_cache_size / dist_count; + if (new_cache_size < rda_req_size) { + if (new_cache_size < 4 * 1024) + new_cache_size = rda_req_size = 4 * 1024; + else + rda_req_size = new_cache_size; - /* - * Logic to make sure NFS doesn't have performance translators by - * default for a volume - */ - ret = client_graph_set_rda_options (graph, volinfo, set_dict); + snprintf(new_req_size_str, sizeof(new_req_size_str), "%ld%s", + rda_req_size, "B"); + ret = dict_set_dynstr_with_alloc(set_dict, VKEY_RDA_REQUEST_SIZE, + new_req_size_str); if (ret < 0) - return ret; + goto out; + } - volname = volinfo->volname; + snprintf(new_cache_size_str, sizeof(new_cache_size_str), "%ld%s", + new_cache_size, "B"); + ret = dict_set_dynstr_with_alloc(set_dict, VKEY_RDA_CACHE_LIMIT, + new_cache_size_str); + if (ret < 0) + goto out; - tmp_data = dict_get (set_dict, "nfs-volume-file"); - if (!tmp_data) - return volgen_graph_set_options_generic(graph, set_dict, - volinfo, - &perfxl_option_handler); - else - return volgen_graph_set_options_generic(graph, set_dict, - volname, - &nfsperfxl_option_handler); +out: + return ret; } static int -graph_set_generic_options (xlator_t *this, volgen_graph_t *graph, - dict_t *set_dict, char *identifier) -{ - int ret = 0; - - ret = volgen_graph_set_options_generic (graph, set_dict, "client", - &loglevel_option_handler); - - if (ret) - gf_msg (this->name, GF_LOG_WARNING, 0, - GD_MSG_GRAPH_SET_OPT_FAIL, - "changing %s log level" - " failed", identifier); - - ret = volgen_graph_set_options_generic (graph, set_dict, "client", - &sys_loglevel_option_handler); - if (ret) - gf_msg (this->name, GF_LOG_WARNING, 0, - GD_MSG_GRAPH_SET_OPT_FAIL, - "changing %s syslog " - "level failed", identifier); +client_graph_set_perf_options(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, dict_t *set_dict) +{ + data_t *tmp_data = NULL; + char *volname = NULL; + int ret = 0; + + /* + * Logic to make sure gfproxy-client gets custom performance translators + */ + ret = dict_get_str_boolean(set_dict, "gfproxy-client", 0); + if (ret == 1) { + return volgen_graph_set_options_generic( + graph, set_dict, volinfo, &gfproxy_client_perfxl_option_handler); + } + + /* + * Logic to make sure gfproxy-server gets custom performance translators + */ + ret = dict_get_str_boolean(set_dict, "gfproxy-server", 0); + if (ret == 1) { + return volgen_graph_set_options_generic( + graph, set_dict, volinfo, &gfproxy_server_perfxl_option_handler); + } + + /* + * Logic to make sure NFS doesn't have performance translators by + * default for a volume + */ + ret = client_graph_set_rda_options(graph, volinfo, set_dict); + if (ret < 0) + return ret; - ret = volgen_graph_set_options_generic (graph, set_dict, "client", - &logger_option_handler); + volname = volinfo->volname; - if (ret) - gf_msg (this->name, GF_LOG_WARNING, 0, - GD_MSG_GRAPH_SET_OPT_FAIL, - "changing %s logger" - " failed", identifier); + tmp_data = dict_get(set_dict, "nfs-volume-file"); + if (!tmp_data) + return volgen_graph_set_options_generic(graph, set_dict, volinfo, + &perfxl_option_handler); + else + return volgen_graph_set_options_generic(graph, set_dict, volname, + &nfsperfxl_option_handler); +} - ret = volgen_graph_set_options_generic (graph, set_dict, "client", - &log_format_option_handler); - if (ret) - gf_msg (this->name, GF_LOG_WARNING, 0, - GD_MSG_GRAPH_SET_OPT_FAIL, - "changing %s log format" - " failed", identifier); +static int +graph_set_generic_options(xlator_t *this, volgen_graph_t *graph, + dict_t *set_dict, char *identifier) +{ + int ret = 0; + + ret = volgen_graph_set_options_generic(graph, set_dict, "client", + &loglevel_option_handler); + + if (ret) + gf_msg(this->name, GF_LOG_WARNING, 0, GD_MSG_GRAPH_SET_OPT_FAIL, + "changing %s log level" + " failed", + identifier); + + ret = volgen_graph_set_options_generic(graph, set_dict, "client", + &sys_loglevel_option_handler); + if (ret) + gf_msg(this->name, GF_LOG_WARNING, 0, GD_MSG_GRAPH_SET_OPT_FAIL, + "changing %s syslog " + "level failed", + identifier); + + ret = volgen_graph_set_options_generic(graph, set_dict, "client", + &logger_option_handler); + + if (ret) + gf_msg(this->name, GF_LOG_WARNING, 0, GD_MSG_GRAPH_SET_OPT_FAIL, + "changing %s logger" + " failed", + identifier); + + ret = volgen_graph_set_options_generic(graph, set_dict, "client", + &log_format_option_handler); + if (ret) + gf_msg(this->name, GF_LOG_WARNING, 0, GD_MSG_GRAPH_SET_OPT_FAIL, + "changing %s log format" + " failed", + identifier); + + ret = volgen_graph_set_options_generic(graph, set_dict, "client", + &log_buf_size_option_handler); + if (ret) + gf_msg(this->name, GF_LOG_WARNING, 0, GD_MSG_GRAPH_SET_OPT_FAIL, + "Failed to change " + "log-buf-size option"); + + ret = volgen_graph_set_options_generic(graph, set_dict, "client", + &log_flush_timeout_option_handler); + if (ret) + gf_msg(this->name, GF_LOG_WARNING, 0, GD_MSG_GRAPH_SET_OPT_FAIL, + "Failed to change " + "log-flush-timeout option"); + + ret = volgen_graph_set_options_generic( + graph, set_dict, "client", &log_localtime_logging_option_handler); + if (ret) + gf_msg(this->name, GF_LOG_WARNING, 0, GD_MSG_GRAPH_SET_OPT_FAIL, + "Failed to change " + "log-localtime-logging option"); + return 0; +} - ret = volgen_graph_set_options_generic (graph, set_dict, "client", - &log_buf_size_option_handler); +static int +volume_volgen_graph_build_clusters_tier(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, + gf_boolean_t is_quotad) +{ + int ret = -1; + xlator_t *xl, *hxl, *cxl; + char *rule = NULL; + int st_brick_count = 0; + int st_replica_count = 0; + int st_disperse_count = 0; + int st_dist_leaf_count = 0; + int st_type = 0; + int dist_count = 0; + int start_count = 0; + char *decommissioned_children = NULL; + glusterd_volinfo_t *dup_volinfo = NULL; + gf_boolean_t is_hot_tier = _gf_false; + + st_brick_count = volinfo->brick_count; + st_replica_count = volinfo->replica_count; + st_disperse_count = volinfo->disperse_count; + st_type = volinfo->type; + st_dist_leaf_count = volinfo->dist_leaf_count; + + volinfo->dist_leaf_count = volinfo->tier_info.cold_dist_leaf_count; + volinfo->brick_count = volinfo->tier_info.cold_brick_count; + volinfo->replica_count = volinfo->tier_info.cold_replica_count; + volinfo->disperse_count = volinfo->tier_info.cold_disperse_count; + volinfo->redundancy_count = volinfo->tier_info.cold_redundancy_count; + volinfo->type = volinfo->tier_info.cold_type; + volinfo->tier_info.cur_tier_hot = 0; + ret = glusterd_create_sub_tier_volinfo(volinfo, &dup_volinfo, is_hot_tier, + volinfo->volname); + if (ret) + goto out; + + ret = volume_volgen_graph_build_clusters(graph, dup_volinfo, is_quotad); + if (ret) + goto out; + cxl = first_of(graph); + + volinfo->type = volinfo->tier_info.hot_type; + volinfo->brick_count = volinfo->tier_info.hot_brick_count; + volinfo->replica_count = volinfo->tier_info.hot_replica_count; + volinfo->dist_leaf_count = glusterd_get_dist_leaf_count(volinfo); + volinfo->disperse_count = 0; + volinfo->tier_info.cur_tier_hot = 1; + + dist_count = volinfo->brick_count / volinfo->dist_leaf_count; + + if (volinfo->tier_info.cold_type == GF_CLUSTER_TYPE_REPLICATE) { + start_count = volinfo->tier_info.cold_brick_count / + volinfo->tier_info.cold_replica_count; + } + + if (volinfo->dist_leaf_count != 1) { + ret = volgen_link_bricks_from_list_head_start( + graph, volinfo, "cluster/replicate", "%s-replicate-%d", + volinfo->brick_count, volinfo->replica_count, start_count); + if (ret != -1) { + ret = set_afr_pending_xattrs_option(graph, volinfo, ret); + if (ret) + goto out; + volgen_link_bricks_from_list_tail( + graph, volinfo, "cluster/distribute", "%s-hot-dht", dist_count, + dist_count); + } + } else { + ret = volgen_link_bricks_from_list_head( + graph, volinfo, "cluster/distribute", "%s-hot-dht", dist_count, + dist_count); + } + if (ret == -1) + goto out; + + hxl = first_of(graph); + + volinfo->type = GF_CLUSTER_TYPE_TIER; + if (!is_quotad) { + xl = volgen_graph_add_nolink(graph, "cluster/tier", "%s-%s", + volinfo->volname, "tier-dht"); + } else { + xl = volgen_graph_add_nolink(graph, "cluster/tier", "%s", + volinfo->volname); + } + if (!xl) + goto out; + + gf_asprintf(&rule, "%s-hot-dht", volinfo->volname); + + ret = xlator_set_option(xl, "rule", rule); + if (ret) + goto out; + + /*Each dht/tier layer must have a different xattr name*/ + ret = xlator_set_option(xl, "xattr-name", "trusted.tier.tier-dht"); + if (ret) + goto out; + + ret = volgen_xlator_link(xl, cxl); + ret = volgen_xlator_link(xl, hxl); + + st_type = GF_CLUSTER_TYPE_TIER; + + ret = _graph_get_decommissioned_children(xl, volinfo, + &decommissioned_children); + if (ret) + goto out; + if (decommissioned_children) { + ret = xlator_set_option(xl, "decommissioned-bricks", + decommissioned_children); if (ret) - gf_msg (this->name, GF_LOG_WARNING, 0, - GD_MSG_GRAPH_SET_OPT_FAIL, - "Failed to change " - "log-buf-size option"); + goto out; + } - ret = volgen_graph_set_options_generic (graph, set_dict, "client", - &log_flush_timeout_option_handler); - if (ret) - gf_msg (this->name, GF_LOG_WARNING, 0, - GD_MSG_GRAPH_SET_OPT_FAIL, - "Failed to change " - "log-flush-timeout option"); +out: + volinfo->brick_count = st_brick_count; + volinfo->replica_count = st_replica_count; + volinfo->disperse_count = st_disperse_count; + volinfo->type = st_type; + volinfo->dist_leaf_count = st_dist_leaf_count; + volinfo->tier_info.cur_tier_hot = 0; - ret = volgen_graph_set_options_generic (graph, set_dict, "client", - &log_localtime_logging_option_handler); - if (ret) - gf_msg (this->name, GF_LOG_WARNING, 0, - GD_MSG_GRAPH_SET_OPT_FAIL, - "Failed to change " - "log-localtime-logging option"); - return 0; + if (dup_volinfo) + glusterd_volinfo_delete(dup_volinfo); + GF_FREE(rule); + GF_FREE(decommissioned_children); + return ret; } static int -volume_volgen_graph_build_clusters_tier (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - gf_boolean_t is_quotad) -{ - int ret = -1; - xlator_t *xl, *hxl, *cxl; - char *rule = NULL; - int st_brick_count = 0; - int st_replica_count = 0; - int st_disperse_count = 0; - int st_dist_leaf_count = 0; - int st_type = 0; - int dist_count = 0; - int start_count = 0; - char *decommissioned_children = NULL; - glusterd_volinfo_t *dup_volinfo = NULL; - gf_boolean_t is_hot_tier = _gf_false; - - st_brick_count = volinfo->brick_count; - st_replica_count = volinfo->replica_count; - st_disperse_count = volinfo->disperse_count; - st_type = volinfo->type; - st_dist_leaf_count = volinfo->dist_leaf_count; - - volinfo->dist_leaf_count = volinfo->tier_info.cold_dist_leaf_count; - volinfo->brick_count = volinfo->tier_info.cold_brick_count; - volinfo->replica_count = volinfo->tier_info.cold_replica_count; - volinfo->disperse_count = volinfo->tier_info.cold_disperse_count; - volinfo->redundancy_count = volinfo->tier_info.cold_redundancy_count; - volinfo->type = volinfo->tier_info.cold_type; - volinfo->tier_info.cur_tier_hot = 0; - ret = glusterd_create_sub_tier_volinfo (volinfo, &dup_volinfo, - is_hot_tier, volinfo->volname); - if (ret) - goto out; - - ret = volume_volgen_graph_build_clusters (graph, dup_volinfo, - is_quotad); +client_graph_builder(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, void *param) +{ + int ret = 0; + xlator_t *xl = NULL; + char *volname = NULL; + glusterd_conf_t *conf = THIS->private; + char *tmp = NULL; + gf_boolean_t var = _gf_false; + gf_boolean_t ob = _gf_false; + int uss_enabled = -1; + xlator_t *this = THIS; + char *subvol = NULL; + size_t namelen = 0; + char *xl_id = NULL; + gf_boolean_t gfproxy_clnt = _gf_false; + + GF_ASSERT(this); + GF_ASSERT(conf); + + ret = dict_get_str_boolean(set_dict, "gfproxy-client", 0); + if (ret == -1) + goto out; + + volname = volinfo->volname; + if (ret == 0) { + ret = volgen_graph_build_clients(graph, volinfo, set_dict, param); if (ret) - goto out; - cxl = first_of(graph); - - volinfo->type = volinfo->tier_info.hot_type; - volinfo->brick_count = volinfo->tier_info.hot_brick_count; - volinfo->replica_count = volinfo->tier_info.hot_replica_count; - volinfo->dist_leaf_count = glusterd_get_dist_leaf_count(volinfo); - volinfo->disperse_count = 0; - volinfo->tier_info.cur_tier_hot = 1; - - dist_count = volinfo->brick_count / volinfo->dist_leaf_count; + goto out; - if (volinfo->tier_info.cold_type == GF_CLUSTER_TYPE_REPLICATE) { - start_count = volinfo->tier_info.cold_brick_count / - volinfo->tier_info.cold_replica_count; - } + if (volinfo->type == GF_CLUSTER_TYPE_TIER) + ret = volume_volgen_graph_build_clusters_tier(graph, volinfo, + _gf_false); + else + ret = volume_volgen_graph_build_clusters(graph, volinfo, _gf_false); - if (volinfo->dist_leaf_count != 1) { - ret = volgen_link_bricks_from_list_head_start - (graph, volinfo, - "cluster/replicate", - "%s-replicate-%d", - volinfo->brick_count, - volinfo->replica_count, - start_count); - if (ret != -1) { - ret = set_afr_pending_xattrs_option (graph, volinfo, - ret); - if (ret) - goto out; - volgen_link_bricks_from_list_tail (graph, volinfo, - "cluster/distribute", - "%s-hot-dht", - dist_count, - dist_count); - } - } else { - ret = volgen_link_bricks_from_list_head (graph, volinfo, - "cluster/distribute", - "%s-hot-dht", - dist_count, - dist_count); - } if (ret == -1) - goto out; - - hxl = first_of(graph); - - volinfo->type = GF_CLUSTER_TYPE_TIER; - if (!is_quotad) { - - xl = volgen_graph_add_nolink (graph, "cluster/tier", "%s-%s", - volinfo->volname, "tier-dht"); - } else { - xl = volgen_graph_add_nolink (graph, "cluster/tier", "%s", - volinfo->volname); - } - if (!xl) - goto out; - - gf_asprintf(&rule, "%s-hot-dht", volinfo->volname); - - ret = xlator_set_option(xl, "rule", rule); - if (ret) - goto out; - - /*Each dht/tier layer must have a different xattr name*/ - ret = xlator_set_option(xl, "xattr-name", "trusted.tier.tier-dht"); - if (ret) - goto out; - - ret = volgen_xlator_link (xl, cxl); - ret = volgen_xlator_link (xl, hxl); - - st_type = GF_CLUSTER_TYPE_TIER; - - ret = _graph_get_decommissioned_children (xl, volinfo, - &decommissioned_children); - if (ret) - goto out; - if (decommissioned_children) { - ret = xlator_set_option (xl, "decommissioned-bricks", - decommissioned_children); - if (ret) - goto out; + goto out; + } else { + gfproxy_clnt = _gf_true; + namelen = strlen(volinfo->volname) + SLEN("gfproxyd-") + 1; + subvol = alloca(namelen); + snprintf(subvol, namelen, "gfproxyd-%s", volinfo->volname); + + namelen = strlen(volinfo->volname) + SLEN("-gfproxy-client") + 1; + xl_id = alloca(namelen); + snprintf(xl_id, namelen, "%s-gfproxy-client", volinfo->volname); + volgen_graph_build_client(graph, volinfo, NULL, NULL, subvol, xl_id, + "tcp", set_dict); + } + + ret = dict_get_str_boolean(set_dict, "features.shard", _gf_false); + if (ret == -1) + goto out; + + if (ret) { + xl = volgen_graph_add(graph, "features/shard", volname); + if (!xl) { + ret = -1; + goto out; } + } - out: - volinfo->brick_count = st_brick_count; - volinfo->replica_count = st_replica_count; - volinfo->disperse_count = st_disperse_count; - volinfo->type = st_type; - volinfo->dist_leaf_count = st_dist_leaf_count; - volinfo->tier_info.cur_tier_hot = 0; - - if (dup_volinfo) - glusterd_volinfo_delete (dup_volinfo); - GF_FREE (rule); - GF_FREE (decommissioned_children); - return ret; -} - -static int -client_graph_builder (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, void *param) -{ - int ret = 0; - xlator_t *xl = NULL; - char *volname = NULL; - glusterd_conf_t *conf = THIS->private; - char *tmp = NULL; - gf_boolean_t var = _gf_false; - gf_boolean_t ob = _gf_false; - int uss_enabled = -1; - xlator_t *this = THIS; - char *subvol = NULL; - size_t namelen = 0; - char *xl_id = NULL; - gf_boolean_t gfproxy_clnt = _gf_false; - - GF_ASSERT (this); - GF_ASSERT (conf); - - ret = dict_get_str_boolean (set_dict, "gfproxy-client", 0); - if (ret == -1) - goto out; - - volname = volinfo->volname; - if (ret == 0) { - ret = volgen_graph_build_clients (graph, volinfo, set_dict, - param); - if (ret) - goto out; - - if (volinfo->type == GF_CLUSTER_TYPE_TIER) - ret = volume_volgen_graph_build_clusters_tier - (graph, volinfo, _gf_false); - else - ret = volume_volgen_graph_build_clusters - (graph, volinfo, _gf_false); + ret = dict_get_str_boolean(set_dict, "features.utime", _gf_false); + if (ret == -1) + goto out; - if (ret == -1) - goto out; - } else { - gfproxy_clnt = _gf_true; - namelen = strlen (volinfo->volname) + SLEN ("gfproxyd-") + 1; - subvol = alloca (namelen); - snprintf (subvol, namelen, "gfproxyd-%s", volinfo->volname); - - namelen = strlen (volinfo->volname) + - SLEN ("-gfproxy-client") + 1; - xl_id = alloca (namelen); - snprintf (xl_id, namelen, "%s-gfproxy-client", - volinfo->volname); - volgen_graph_build_client (graph, volinfo, NULL, NULL, - subvol, xl_id, "tcp", set_dict); + if (ret) { + xl = volgen_graph_add(graph, "features/utime", volname); + if (!xl) { + ret = -1; + goto out; } + } - ret = dict_get_str_boolean (set_dict, "features.shard", _gf_false); - if (ret == -1) - goto out; - - if (ret) { - xl = volgen_graph_add (graph, "features/shard", volname); - if (!xl) { - ret = -1; - goto out; - } + /* As of now snapshot volume is read-only. Read-only xlator is loaded + * in client graph so that AFR & DHT healing can be done in server. + */ + if (volinfo->is_snap_volume) { + xl = volgen_graph_add(graph, "features/read-only", volname); + if (!xl) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_GRAPH_FEATURE_ADD_FAIL, + "Failed to add " + "read-only feature to the graph of %s " + "snapshot with %s origin volume", + volname, volinfo->parent_volname); + ret = -1; + goto out; + } + ret = xlator_set_option(xl, "read-only", "on"); + if (ret) + goto out; + } + + /* Check for compress volume option, and add it to the graph on client side + */ + ret = dict_get_str_boolean(set_dict, "network.compression", 0); + if (ret == -1) + goto out; + if (ret) { + xl = volgen_graph_add(graph, "features/cdc", volname); + if (!xl) { + ret = -1; + goto out; } - - ret = dict_get_str_boolean (set_dict, "features.utime", _gf_false); - if (ret == -1) - goto out; - - if (ret) { - xl = volgen_graph_add (graph, "features/utime", volname); - if (!xl) { - ret = -1; - goto out; - } + ret = xlator_set_option(xl, "mode", "client"); + if (ret) + goto out; + } + + ret = dict_get_str_boolean(set_dict, "features.encryption", _gf_false); + if (ret == -1) + goto out; + if (ret) { + xl = volgen_graph_add(graph, "encryption/crypt", volname); + if (!xl) { + ret = -1; + goto out; } + } - /* As of now snapshot volume is read-only. Read-only xlator is loaded - * in client graph so that AFR & DHT healing can be done in server. - */ - if (volinfo->is_snap_volume) { - xl = volgen_graph_add (graph, "features/read-only", volname); - if (!xl) { - gf_msg (this->name, GF_LOG_ERROR, 0, - GD_MSG_GRAPH_FEATURE_ADD_FAIL, - "Failed to add " - "read-only feature to the graph of %s " - "snapshot with %s origin volume", - volname, volinfo->parent_volname); - ret = -1; - goto out; - } - ret = xlator_set_option (xl, "read-only", "on"); - if (ret) - goto out; - + /* gfproxy needs the quiesce translator */ + if (gfproxy_clnt) { + xl = volgen_graph_add(graph, "features/quiesce", volname); + if (!xl) { + ret = -1; + goto out; } + } - /* Check for compress volume option, and add it to the graph on client side */ - ret = dict_get_str_boolean (set_dict, "network.compression", 0); + if (conf->op_version == GD_OP_VERSION_MIN) { + ret = glusterd_volinfo_get_boolean(volinfo, VKEY_FEATURES_QUOTA); if (ret == -1) - goto out; + goto out; if (ret) { - xl = volgen_graph_add (graph, "features/cdc", volname); - if (!xl) { - ret = -1; - goto out; - } - ret = xlator_set_option (xl, "mode", "client"); - if (ret) - goto out; - } - - ret = dict_get_str_boolean (set_dict, "features.encryption", _gf_false); - if (ret == -1) + xl = volgen_graph_add(graph, "features/quota", volname); + if (!xl) { + ret = -1; goto out; - if (ret) { - xl = volgen_graph_add (graph, "encryption/crypt", volname); - if (!xl) { - ret = -1; - goto out; - } - } - - /* gfproxy needs the quiesce translator */ - if (gfproxy_clnt) { - xl = volgen_graph_add (graph, "features/quiesce", volname); - if (!xl) { - ret = -1; - goto out; - } + } } + } - if (conf->op_version == GD_OP_VERSION_MIN) { - ret = glusterd_volinfo_get_boolean (volinfo, - VKEY_FEATURES_QUOTA); - if (ret == -1) - goto out; - if (ret) { - xl = volgen_graph_add (graph, "features/quota", - volname); - if (!xl) { - ret = -1; - goto out; - } - } - } - - /* Do not allow changing read-after-open option if root-squash is - enabled. - */ - ret = dict_get_str (set_dict, "performance.read-after-open", &tmp); + /* Do not allow changing read-after-open option if root-squash is + enabled. + */ + ret = dict_get_str(set_dict, "performance.read-after-open", &tmp); + if (!ret) { + ret = dict_get_str(volinfo->dict, "server.root-squash", &tmp); if (!ret) { - ret = dict_get_str (volinfo->dict, "server.root-squash", &tmp); - if (!ret) { - ob = _gf_false; - ret = gf_string2boolean (tmp, &ob); - if (!ret && ob) { - gf_msg (this->name, GF_LOG_WARNING, 0, - GD_MSG_ROOT_SQUASH_ENABLED, - "root-squash is enabled. Please turn it" - " off to change read-after-open " - "option"); - ret = -1; - goto out; - } - } + ob = _gf_false; + ret = gf_string2boolean(tmp, &ob); + if (!ret && ob) { + gf_msg(this->name, GF_LOG_WARNING, 0, + GD_MSG_ROOT_SQUASH_ENABLED, + "root-squash is enabled. Please turn it" + " off to change read-after-open " + "option"); + ret = -1; + goto out; + } } + } - /* open behind causes problems when root-squash is enabled - (by allowing reads to happen even though the squashed user - does not have permissions to do so) as it fakes open to be - successful and later sends reads on anonymous fds. So when - root-squash is enabled, open-behind's option to read after - open is done is also enabled. - */ - ret = dict_get_str (set_dict, "server.root-squash", &tmp); - if (!ret) { - ret = gf_string2boolean (tmp, &var); - if (ret) - goto out; - - if (var) { - ret = dict_get_str (volinfo->dict, - "performance.read-after-open", - &tmp); - if (!ret) { - ret = gf_string2boolean (tmp, &ob); - /* go ahead with turning read-after-open on - even if string2boolean conversion fails, - OR if read-after-open option is turned off - */ - if (ret || !ob) - ret = dict_set_str (set_dict, - "performance.read-after-open", - "yes"); - } else { - ret = dict_set_str (set_dict, - "performance.read-after-open", - "yes"); - } - } else { - /* When root-squash has to be turned off, open-behind's - read-after-open option should be reset to what was - there before root-squash was turned on. If the option - cannot be found in volinfo's dict, it means that - option was not set before turning on root-squash. - */ - ob = _gf_false; - ret = dict_get_str (volinfo->dict, - "performance.read-after-open", - &tmp); - if (!ret) { - ret = gf_string2boolean (tmp, &ob); - - if (!ret && ob) { - ret = dict_set_str (set_dict, - "performance.read-after-open", - "yes"); - } - } - /* consider operation is failure only if read-after-open - option is enabled and could not set into set_dict - */ - if (!ob) - ret = 0; - } - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, 0, - GD_MSG_ROOT_SQUASH_FAILED, - "setting " - "open behind option as part of root " - "squash failed"); - goto out; + /* open behind causes problems when root-squash is enabled + (by allowing reads to happen even though the squashed user + does not have permissions to do so) as it fakes open to be + successful and later sends reads on anonymous fds. So when + root-squash is enabled, open-behind's option to read after + open is done is also enabled. + */ + ret = dict_get_str(set_dict, "server.root-squash", &tmp); + if (!ret) { + ret = gf_string2boolean(tmp, &var); + if (ret) + goto out; + + if (var) { + ret = dict_get_str(volinfo->dict, "performance.read-after-open", + &tmp); + if (!ret) { + ret = gf_string2boolean(tmp, &ob); + /* go ahead with turning read-after-open on + even if string2boolean conversion fails, + OR if read-after-open option is turned off + */ + if (ret || !ob) + ret = dict_set_str(set_dict, "performance.read-after-open", + "yes"); + } else { + ret = dict_set_str(set_dict, "performance.read-after-open", + "yes"); + } + } else { + /* When root-squash has to be turned off, open-behind's + read-after-open option should be reset to what was + there before root-squash was turned on. If the option + cannot be found in volinfo's dict, it means that + option was not set before turning on root-squash. + */ + ob = _gf_false; + ret = dict_get_str(volinfo->dict, "performance.read-after-open", + &tmp); + if (!ret) { + ret = gf_string2boolean(tmp, &ob); + + if (!ret && ob) { + ret = dict_set_str(set_dict, "performance.read-after-open", + "yes"); } + } + /* consider operation is failure only if read-after-open + option is enabled and could not set into set_dict + */ + if (!ob) + ret = 0; } - - ret = dict_get_str_boolean (set_dict, "server.manage-gids", _gf_false); - if (ret != -1) { - ret = dict_set_str (set_dict, "client.send-gids", - ret ? "false" : "true"); - if (ret) - gf_msg (THIS->name, GF_LOG_WARNING, errno, - GD_MSG_DICT_SET_FAILED, "changing client" - " protocol option failed"); - } - - ret = client_graph_set_perf_options(graph, volinfo, set_dict); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, 0, GD_MSG_ROOT_SQUASH_FAILED, + "setting " + "open behind option as part of root " + "squash failed"); + goto out; + } + } + + ret = dict_get_str_boolean(set_dict, "server.manage-gids", _gf_false); + if (ret != -1) { + ret = dict_set_str(set_dict, "client.send-gids", + ret ? "false" : "true"); if (ret) - goto out; - - uss_enabled = dict_get_str_boolean (set_dict, "features.uss", - _gf_false); - if (uss_enabled == -1) - goto out; - if (uss_enabled && !volinfo->is_snap_volume) { - - ret = volgen_graph_build_snapview_client - (graph, volinfo, - volname, set_dict); - if (ret == -1) - goto out; - } + gf_msg(THIS->name, GF_LOG_WARNING, errno, GD_MSG_DICT_SET_FAILED, + "changing client" + " protocol option failed"); + } + + ret = client_graph_set_perf_options(graph, volinfo, set_dict); + if (ret) + goto out; + + uss_enabled = dict_get_str_boolean(set_dict, "features.uss", _gf_false); + if (uss_enabled == -1) + goto out; + if (uss_enabled && !volinfo->is_snap_volume) { + ret = volgen_graph_build_snapview_client(graph, volinfo, volname, + set_dict); + if (ret == -1) + goto out; + } - /* add debug translators depending on the options */ - ret = check_and_add_debug_xl (graph, set_dict, volname, - "client"); - if (ret) - return -1; + /* add debug translators depending on the options */ + ret = check_and_add_debug_xl(graph, set_dict, volname, "client"); + if (ret) + return -1; - ret = dict_get_str_boolean (set_dict, "features.cloudsync", _gf_false); - if (ret == -1) - goto out; + ret = dict_get_str_boolean(set_dict, "features.cloudsync", _gf_false); + if (ret == -1) + goto out; - if (ret) { - xl = volgen_graph_add (graph, "features/cloudsync", volname); - if (!xl) { - ret = -1; - goto out; - } + if (ret) { + xl = volgen_graph_add(graph, "features/cloudsync", volname); + if (!xl) { + ret = -1; + goto out; } + } - ret = -1; - xl = volgen_graph_add_as (graph, "debug/io-stats", volname); - if (!xl) - goto out; + ret = -1; + xl = volgen_graph_add_as(graph, "debug/io-stats", volname); + if (!xl) + goto out; - ret = graph_set_generic_options (this, graph, set_dict, "client"); + ret = graph_set_generic_options(this, graph, set_dict, "client"); out: - return ret; + return ret; } - /* builds a graph for client role , with option overrides in mod_dict */ static int -build_client_graph (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *mod_dict) +build_client_graph(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *mod_dict) { - return build_graph_generic (graph, volinfo, mod_dict, NULL, - &client_graph_builder); + return build_graph_generic(graph, volinfo, mod_dict, NULL, + &client_graph_builder); } -char *gd_shd_options[] = { - "!self-heal-daemon", - "!heal-timeout", - NULL -}; +char *gd_shd_options[] = {"!self-heal-daemon", "!heal-timeout", NULL}; -char* -gd_get_matching_option (char **options, char *option) +char * +gd_get_matching_option(char **options, char *option) { - while (*options && strcmp (*options, option)) - options++; - return *options; + while (*options && strcmp(*options, option)) + options++; + return *options; } static int -bitrot_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, - void *param) +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; + xlator_t *xl = NULL; + char *bitrot_option = NULL; + int ret = 0; - 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); - } + xl = first_of(graph); - if (ret) - return -1; + 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); } - return ret; + if (ret) + return -1; + } + + return ret; } static int -scrubber_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, - void *param) +scrubber_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - xlator_t *xl = NULL; - char *scrub_option = NULL; - int ret = 0; - + xlator_t *xl = NULL; + char *scrub_option = NULL; + int ret = 0; - xl = first_of (graph); + xl = first_of(graph); - if (!strcmp (vme->option, "scrub-throttle")) { - ret = gf_asprintf (&scrub_option, "scrub-throttle"); - if (ret != -1) { - ret = xlator_set_option (xl, scrub_option, vme->value); - GF_FREE (scrub_option); - } - - if (ret) - return -1; + if (!strcmp(vme->option, "scrub-throttle")) { + ret = gf_asprintf(&scrub_option, "scrub-throttle"); + if (ret != -1) { + ret = xlator_set_option(xl, scrub_option, vme->value); + GF_FREE(scrub_option); } - if (!strcmp (vme->option, "scrub-frequency")) { - ret = gf_asprintf (&scrub_option, "scrub-freq"); - if (ret != -1) { - ret = xlator_set_option (xl, scrub_option, vme->value); - GF_FREE (scrub_option); - } + if (ret) + return -1; + } - if (ret) - return -1; + if (!strcmp(vme->option, "scrub-frequency")) { + ret = gf_asprintf(&scrub_option, "scrub-freq"); + if (ret != -1) { + ret = xlator_set_option(xl, scrub_option, vme->value); + GF_FREE(scrub_option); } - if (!strcmp (vme->option, "scrubber")) { - if (!strcmp (vme->value, "pause")) { - ret = gf_asprintf (&scrub_option, "scrub-state"); - if (ret != -1) { - ret = xlator_set_option (xl, scrub_option, - vme->value); - GF_FREE (scrub_option); - } - - if (ret) - return -1; - } + if (ret) + return -1; + } + + if (!strcmp(vme->option, "scrubber")) { + if (!strcmp(vme->value, "pause")) { + ret = gf_asprintf(&scrub_option, "scrub-state"); + if (ret != -1) { + ret = xlator_set_option(xl, scrub_option, vme->value); + GF_FREE(scrub_option); + } + + if (ret) + return -1; } + } - return ret; + return ret; } static int -shd_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, - void *param) -{ - int ret = 0; - struct volopt_map_entry new_vme = {0}; - char *shd_option = NULL; - - shd_option = gd_get_matching_option (gd_shd_options, vme->option); - if ((vme->option[0] == '!') && !shd_option) - goto out; - new_vme = *vme; - if (shd_option) { - new_vme.option = shd_option + 1;//option with out '!' - } - - ret = no_filter_option_handler (graph, &new_vme, param); +shd_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) +{ + int ret = 0; + struct volopt_map_entry new_vme = {0}; + char *shd_option = NULL; + + shd_option = gd_get_matching_option(gd_shd_options, vme->option); + if ((vme->option[0] == '!') && !shd_option) + goto out; + new_vme = *vme; + if (shd_option) { + new_vme.option = shd_option + 1; // option with out '!' + } + + ret = no_filter_option_handler(graph, &new_vme, param); out: - return ret; + return ret; } static int -nfs_option_handler (volgen_graph_t *graph, - struct volopt_map_entry *vme, void *param) +nfs_option_handler(volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { - xlator_t *xl = NULL; - char *aa = NULL; - int ret = 0; - glusterd_volinfo_t *volinfo = NULL; - - volinfo = param; + xlator_t *xl = NULL; + char *aa = NULL; + int ret = 0; + glusterd_volinfo_t *volinfo = NULL; - xl = first_of (graph); + volinfo = param; - if (!volinfo || (volinfo->volname[0] == '\0')) - return 0; + xl = first_of(graph); - if (!vme || (vme->option[0] == '\0')) - return 0; + if (!volinfo || (volinfo->volname[0] == '\0')) + return 0; - if (! strcmp (vme->option, "!rpc-auth.addr.*.allow")) { - ret = gf_asprintf (&aa, "rpc-auth.addr.%s.allow", - volinfo->volname); + if (!vme || (vme->option[0] == '\0')) + return 0; - if (ret != -1) { - ret = xlator_set_option (xl, aa, vme->value); - GF_FREE (aa); - } + if (!strcmp(vme->option, "!rpc-auth.addr.*.allow")) { + ret = gf_asprintf(&aa, "rpc-auth.addr.%s.allow", volinfo->volname); - if (ret) - return -1; + if (ret != -1) { + ret = xlator_set_option(xl, aa, vme->value); + GF_FREE(aa); } - if (! strcmp (vme->option, "!rpc-auth.addr.*.reject")) { - ret = gf_asprintf (&aa, "rpc-auth.addr.%s.reject", - volinfo->volname); + if (ret) + return -1; + } - if (ret != -1) { - ret = xlator_set_option (xl, aa, vme->value); - GF_FREE (aa); - } + if (!strcmp(vme->option, "!rpc-auth.addr.*.reject")) { + ret = gf_asprintf(&aa, "rpc-auth.addr.%s.reject", volinfo->volname); - if (ret) - return -1; + if (ret != -1) { + ret = xlator_set_option(xl, aa, vme->value); + GF_FREE(aa); } - if (! strcmp (vme->option, "!rpc-auth.auth-unix.*")) { - ret = gf_asprintf (&aa, "rpc-auth.auth-unix.%s", - volinfo->volname); + if (ret) + return -1; + } - if (ret != -1) { - ret = xlator_set_option (xl, aa, vme->value); - GF_FREE (aa); - } + if (!strcmp(vme->option, "!rpc-auth.auth-unix.*")) { + ret = gf_asprintf(&aa, "rpc-auth.auth-unix.%s", volinfo->volname); - if (ret) - return -1; + if (ret != -1) { + ret = xlator_set_option(xl, aa, vme->value); + GF_FREE(aa); } - if (! strcmp (vme->option, "!rpc-auth.auth-null.*")) { - ret = gf_asprintf (&aa, "rpc-auth.auth-null.%s", - volinfo->volname); - if (ret != -1) { - ret = xlator_set_option (xl, aa, vme->value); - GF_FREE (aa); - } + if (ret) + return -1; + } + if (!strcmp(vme->option, "!rpc-auth.auth-null.*")) { + ret = gf_asprintf(&aa, "rpc-auth.auth-null.%s", volinfo->volname); - if (ret) - return -1; + if (ret != -1) { + ret = xlator_set_option(xl, aa, vme->value); + GF_FREE(aa); } - if (! strcmp (vme->option, "!nfs3.*.trusted-sync")) { - ret = gf_asprintf (&aa, "nfs3.%s.trusted-sync", - volinfo->volname); + if (ret) + return -1; + } - if (ret != -1) { - ret = xlator_set_option (xl, aa, vme->value); - GF_FREE (aa); - } + if (!strcmp(vme->option, "!nfs3.*.trusted-sync")) { + ret = gf_asprintf(&aa, "nfs3.%s.trusted-sync", volinfo->volname); - if (ret) - return -1; + if (ret != -1) { + ret = xlator_set_option(xl, aa, vme->value); + GF_FREE(aa); } - if (! strcmp (vme->option, "!nfs3.*.trusted-write")) { - ret = gf_asprintf (&aa, "nfs3.%s.trusted-write", - volinfo->volname); + if (ret) + return -1; + } - if (ret != -1) { - ret = xlator_set_option (xl, aa, vme->value); - GF_FREE (aa); - } + if (!strcmp(vme->option, "!nfs3.*.trusted-write")) { + ret = gf_asprintf(&aa, "nfs3.%s.trusted-write", volinfo->volname); - if (ret) - return -1; + if (ret != -1) { + ret = xlator_set_option(xl, aa, vme->value); + GF_FREE(aa); } - if (! strcmp (vme->option, "!nfs3.*.volume-access")) { - ret = gf_asprintf (&aa, "nfs3.%s.volume-access", - volinfo->volname); + if (ret) + return -1; + } - if (ret != -1) { - ret = xlator_set_option (xl, aa, vme->value); - GF_FREE (aa); - } + if (!strcmp(vme->option, "!nfs3.*.volume-access")) { + ret = gf_asprintf(&aa, "nfs3.%s.volume-access", volinfo->volname); - if (ret) - return -1; + if (ret != -1) { + ret = xlator_set_option(xl, aa, vme->value); + GF_FREE(aa); } - if (! strcmp (vme->option, "!nfs3.*.export-dir")) { - ret = gf_asprintf (&aa, "nfs3.%s.export-dir", - volinfo->volname); + if (ret) + return -1; + } - if (ret != -1) { - ret = gf_canonicalize_path (vme->value); - if (ret) - return -1; + if (!strcmp(vme->option, "!nfs3.*.export-dir")) { + ret = gf_asprintf(&aa, "nfs3.%s.export-dir", volinfo->volname); - ret = xlator_set_option (xl, aa, vme->value); - GF_FREE (aa); - } + if (ret != -1) { + ret = gf_canonicalize_path(vme->value); + if (ret) + return -1; - if (ret) - return -1; + ret = xlator_set_option(xl, aa, vme->value); + GF_FREE(aa); } + if (ret) + return -1; + } + if (!strcmp(vme->option, "!rpc-auth.ports.*.insecure")) { + ret = gf_asprintf(&aa, "rpc-auth.ports.%s.insecure", volinfo->volname); - if (! strcmp (vme->option, "!rpc-auth.ports.*.insecure")) { - ret = gf_asprintf (&aa, "rpc-auth.ports.%s.insecure", - volinfo->volname); - - if (ret != -1) { - ret = xlator_set_option (xl, aa, vme->value); - GF_FREE (aa); - } - - if (ret) - return -1; + if (ret != -1) { + ret = xlator_set_option(xl, aa, vme->value); + GF_FREE(aa); } + if (ret) + return -1; + } - if (! strcmp (vme->option, "!nfs-disable")) { - ret = gf_asprintf (&aa, "nfs.%s.disable", - volinfo->volname); - - if (ret != -1) { - ret = xlator_set_option (xl, aa, vme->value); - GF_FREE (aa); - } + if (!strcmp(vme->option, "!nfs-disable")) { + ret = gf_asprintf(&aa, "nfs.%s.disable", volinfo->volname); - if (ret) - return -1; + if (ret != -1) { + ret = xlator_set_option(xl, aa, vme->value); + GF_FREE(aa); } - if ((strcmp (vme->voltype, "nfs/server") == 0) && - (vme->option && vme->option[0]!='!') ) { - ret = xlator_set_option (xl, vme->option, vme->value); - if (ret) - return -1; - } + if (ret) + return -1; + } + if ((strcmp(vme->voltype, "nfs/server") == 0) && + (vme->option && vme->option[0] != '!')) { + ret = xlator_set_option(xl, vme->option, vme->value); + if (ret) + return -1; + } - return 0; + return 0; } -char* -volgen_get_shd_key (int type) +char * +volgen_get_shd_key(int type) { - char *key = NULL; + char *key = NULL; - switch (type) { + switch (type) { case GF_CLUSTER_TYPE_REPLICATE: case GF_CLUSTER_TYPE_STRIPE_REPLICATE: - key = "cluster.self-heal-daemon"; - break; + key = "cluster.self-heal-daemon"; + break; case GF_CLUSTER_TYPE_DISPERSE: - key = "cluster.disperse-self-heal-daemon"; - break; + key = "cluster.disperse-self-heal-daemon"; + break; default: - key = NULL; - break; - } + key = NULL; + break; + } - return key; + return key; } static gf_boolean_t -volgen_is_shd_compatible_xl (char *xl_type) +volgen_is_shd_compatible_xl(char *xl_type) { - char *shd_xls[] = {"cluster/replicate", "cluster/disperse", - NULL}; - if (gf_get_index_by_elem (shd_xls, xl_type) != -1) - return _gf_true; + char *shd_xls[] = {"cluster/replicate", "cluster/disperse", NULL}; + if (gf_get_index_by_elem(shd_xls, xl_type) != -1) + return _gf_true; - return _gf_false; + return _gf_false; } static int -volgen_graph_set_iam_shd (volgen_graph_t *graph) +volgen_graph_set_iam_shd(volgen_graph_t *graph) { - xlator_t *trav; - int ret = 0; + xlator_t *trav; + int ret = 0; - for (trav = first_of (graph); trav; trav = trav->next) { - if (!volgen_is_shd_compatible_xl (trav->type)) - continue; + for (trav = first_of(graph); trav; trav = trav->next) { + if (!volgen_is_shd_compatible_xl(trav->type)) + continue; - ret = xlator_set_option (trav, "iam-self-heal-daemon", "yes"); - if (ret) - break; - } - return ret; + ret = xlator_set_option(trav, "iam-self-heal-daemon", "yes"); + if (ret) + break; + } + return ret; } static int -glusterd_prepare_shd_volume_options_for_tier (glusterd_volinfo_t *volinfo, - dict_t *set_dict) +glusterd_prepare_shd_volume_options_for_tier(glusterd_volinfo_t *volinfo, + dict_t *set_dict) { - int ret = -1; - char *key = NULL; + int ret = -1; + char *key = NULL; - key = volgen_get_shd_key (volinfo->tier_info.cold_type); - if (key) { - ret = dict_set_str (set_dict, key, "enable"); - if (ret) - goto out; - } + key = volgen_get_shd_key(volinfo->tier_info.cold_type); + if (key) { + ret = dict_set_str(set_dict, key, "enable"); + if (ret) + goto out; + } - key = volgen_get_shd_key (volinfo->tier_info.hot_type); - if (key) { - ret = dict_set_str (set_dict, key, "enable"); - if (ret) - goto out; - } + key = volgen_get_shd_key(volinfo->tier_info.hot_type); + if (key) { + ret = dict_set_str(set_dict, key, "enable"); + if (ret) + goto out; + } out: - return ret; + return ret; } static int -prepare_shd_volume_options (glusterd_volinfo_t *volinfo, - dict_t *mod_dict, dict_t *set_dict) +prepare_shd_volume_options(glusterd_volinfo_t *volinfo, dict_t *mod_dict, + dict_t *set_dict) { - char *key = NULL; - int ret = 0; + char *key = NULL; + int ret = 0; - if (volinfo->type == GF_CLUSTER_TYPE_TIER) { - ret = glusterd_prepare_shd_volume_options_for_tier (volinfo, - set_dict); - if (ret) - goto out; - } else { - key = volgen_get_shd_key (volinfo->type); - if (!key) { - ret = -1; - goto out; - } - ret = dict_set_str (set_dict, key, "enable"); - if (ret) - goto out; - } - - ret = dict_set_uint32 (set_dict, "trusted-client", GF_CLIENT_TRUSTED); + if (volinfo->type == GF_CLUSTER_TYPE_TIER) { + ret = glusterd_prepare_shd_volume_options_for_tier(volinfo, set_dict); if (ret) - goto out; + goto out; + } else { + key = volgen_get_shd_key(volinfo->type); + if (!key) { + ret = -1; + goto out; + } + ret = dict_set_str(set_dict, key, "enable"); + if (ret) + goto out; + } - dict_copy (volinfo->dict, set_dict); - if (mod_dict) - dict_copy (mod_dict, set_dict); + ret = dict_set_uint32(set_dict, "trusted-client", GF_CLIENT_TRUSTED); + if (ret) + goto out; + + dict_copy(volinfo->dict, set_dict); + if (mod_dict) + dict_copy(mod_dict, set_dict); out: - return ret; + return ret; } static int -build_afr_ec_clusters (volgen_graph_t *graph, glusterd_volinfo_t *volinfo) +build_afr_ec_clusters(volgen_graph_t *graph, glusterd_volinfo_t *volinfo) { - - int clusters = -1; - switch (volinfo->type) { + int clusters = -1; + switch (volinfo->type) { case GF_CLUSTER_TYPE_REPLICATE: case GF_CLUSTER_TYPE_STRIPE_REPLICATE: - clusters = volgen_graph_build_afr_clusters (graph, volinfo); - break; + clusters = volgen_graph_build_afr_clusters(graph, volinfo); + break; case GF_CLUSTER_TYPE_DISPERSE: - clusters = volgen_graph_build_ec_clusters (graph, volinfo); - break; - } - return clusters; + clusters = volgen_graph_build_ec_clusters(graph, volinfo); + break; + } + return clusters; } static int -build_afr_ec_clusters_for_tier (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - dict_t *set_dict) -{ - int ret = 0; - glusterd_volinfo_t *dup_volinfo[2] = {NULL, NULL}; - int clusters = 0; - int i = 0; - gf_boolean_t is_hot_tier = _gf_false; - - if (glusterd_is_shd_compatible_type (volinfo->tier_info.cold_type)) { - ret = glusterd_create_sub_tier_volinfo (volinfo, - &dup_volinfo[0], - is_hot_tier, - volinfo->volname); - if (ret) - goto out; - } - if (glusterd_is_shd_compatible_type (volinfo->tier_info.hot_type)) { - is_hot_tier = _gf_true; - ret = glusterd_create_sub_tier_volinfo (volinfo, - &dup_volinfo[1], - is_hot_tier, - volinfo->volname); - if (ret) - goto out; - dup_volinfo[1]->tier_info.cur_tier_hot = 1; - } - - for (i = 0; i < 2; i++) { - if (!dup_volinfo[i]) - continue; - ret = build_afr_ec_clusters (graph, dup_volinfo[i]); - if (ret < 0) - goto out; - clusters += ret; - } - ret = 0; +build_afr_ec_clusters_for_tier(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, dict_t *set_dict) +{ + int ret = 0; + glusterd_volinfo_t *dup_volinfo[2] = {NULL, NULL}; + int clusters = 0; + int i = 0; + gf_boolean_t is_hot_tier = _gf_false; + + if (glusterd_is_shd_compatible_type(volinfo->tier_info.cold_type)) { + ret = glusterd_create_sub_tier_volinfo(volinfo, &dup_volinfo[0], + is_hot_tier, volinfo->volname); + if (ret) + goto out; + } + if (glusterd_is_shd_compatible_type(volinfo->tier_info.hot_type)) { + is_hot_tier = _gf_true; + ret = glusterd_create_sub_tier_volinfo(volinfo, &dup_volinfo[1], + is_hot_tier, volinfo->volname); + if (ret) + goto out; + dup_volinfo[1]->tier_info.cur_tier_hot = 1; + } + + for (i = 0; i < 2; i++) { + if (!dup_volinfo[i]) + continue; + ret = build_afr_ec_clusters(graph, dup_volinfo[i]); + if (ret < 0) + goto out; + clusters += ret; + } + ret = 0; out: - for (i = 0; i < 2; i++) { - if (dup_volinfo[i]) - glusterd_volinfo_delete (dup_volinfo[i]); - } + for (i = 0; i < 2; i++) { + if (dup_volinfo[i]) + glusterd_volinfo_delete(dup_volinfo[i]); + } - if (ret) - clusters = -1; + if (ret) + clusters = -1; - return clusters; + return clusters; } - - static int -build_shd_clusters (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict) +build_shd_clusters(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict) { - int ret = 0; - int clusters = -1; + int ret = 0; + int clusters = -1; - if (volinfo->type == GF_CLUSTER_TYPE_TIER) { - ret = volgen_graph_build_clients_for_tier_shd (graph, volinfo, - set_dict); - if (ret) - goto out; + if (volinfo->type == GF_CLUSTER_TYPE_TIER) { + ret = volgen_graph_build_clients_for_tier_shd(graph, volinfo, set_dict); + if (ret) + goto out; - clusters = build_afr_ec_clusters_for_tier (graph, volinfo, - set_dict); - } else { - ret = volgen_graph_build_clients (graph, volinfo, - set_dict, NULL); - if (ret) - goto out; - clusters = build_afr_ec_clusters (graph, volinfo); - } + clusters = build_afr_ec_clusters_for_tier(graph, volinfo, set_dict); + } else { + ret = volgen_graph_build_clients(graph, volinfo, set_dict, NULL); + if (ret) + goto out; + clusters = build_afr_ec_clusters(graph, volinfo); + } out: - return clusters; + return clusters; } gf_boolean_t -gd_is_self_heal_enabled (glusterd_volinfo_t *volinfo, dict_t *dict) +gd_is_self_heal_enabled(glusterd_volinfo_t *volinfo, dict_t *dict) { + char *shd_key = NULL; + gf_boolean_t shd_enabled = _gf_false; - char *shd_key = NULL; - gf_boolean_t shd_enabled = _gf_false; + GF_VALIDATE_OR_GOTO("glusterd", volinfo, out); - GF_VALIDATE_OR_GOTO ("glusterd", volinfo, out); - - switch (volinfo->type) { + switch (volinfo->type) { case GF_CLUSTER_TYPE_REPLICATE: case GF_CLUSTER_TYPE_STRIPE_REPLICATE: case GF_CLUSTER_TYPE_DISPERSE: - shd_key = volgen_get_shd_key (volinfo->type); - shd_enabled = dict_get_str_boolean (dict, shd_key, - _gf_true); - break; + shd_key = volgen_get_shd_key(volinfo->type); + shd_enabled = dict_get_str_boolean(dict, shd_key, _gf_true); + break; case GF_CLUSTER_TYPE_TIER: - shd_key = volgen_get_shd_key (volinfo->tier_info.cold_type); - if (shd_key) - shd_enabled = dict_get_str_boolean (dict, shd_key, - _gf_true); + shd_key = volgen_get_shd_key(volinfo->tier_info.cold_type); + if (shd_key) + shd_enabled = dict_get_str_boolean(dict, shd_key, _gf_true); - shd_key = volgen_get_shd_key (volinfo->tier_info.hot_type); - if (shd_key) - shd_enabled |= dict_get_str_boolean (dict, shd_key, - _gf_true); + shd_key = volgen_get_shd_key(volinfo->tier_info.hot_type); + if (shd_key) + shd_enabled |= dict_get_str_boolean(dict, shd_key, _gf_true); - break; + break; default: - break; - } + break; + } out: - return shd_enabled; + return shd_enabled; } int -build_rebalance_volfile (glusterd_volinfo_t *volinfo, char *filepath, - dict_t *mod_dict) +build_rebalance_volfile(glusterd_volinfo_t *volinfo, char *filepath, + dict_t *mod_dict) { - volgen_graph_t graph = {0,}; - xlator_t *xl = NULL; - int ret = -1; - xlator_t *this = NULL; - dict_t *set_dict = NULL; + volgen_graph_t graph = { + 0, + }; + xlator_t *xl = NULL; + int ret = -1; + xlator_t *this = NULL; + dict_t *set_dict = NULL; - this = THIS; + this = THIS; - graph.type = GF_REBALANCED; + graph.type = GF_REBALANCED; - if (volinfo->brick_count <= volinfo->dist_leaf_count) { - /* - * Volume is not a distribute volume or - * contains only 1 brick, no need to create - * the volfiles. - */ - return 0; - } + if (volinfo->brick_count <= volinfo->dist_leaf_count) { + /* + * Volume is not a distribute volume or + * contains only 1 brick, no need to create + * the volfiles. + */ + return 0; + } - set_dict = dict_copy_with_ref (volinfo->dict, NULL); - if (!set_dict) - return -1; + set_dict = dict_copy_with_ref(volinfo->dict, NULL); + if (!set_dict) + return -1; - if (mod_dict) { - dict_copy (mod_dict, set_dict); - /* XXX dict_copy swallows errors */ - } + if (mod_dict) { + dict_copy(mod_dict, set_dict); + /* XXX dict_copy swallows errors */ + } - /* Rebalance is always a trusted client*/ - ret = dict_set_uint32 (set_dict, "trusted-client", GF_CLIENT_TRUSTED); - if (ret) - return -1; + /* Rebalance is always a trusted client*/ + ret = dict_set_uint32(set_dict, "trusted-client", GF_CLIENT_TRUSTED); + if (ret) + return -1; - ret = volgen_graph_build_clients (&graph, volinfo, set_dict, NULL); - if (ret) - goto out; + ret = volgen_graph_build_clients(&graph, volinfo, set_dict, NULL); + if (ret) + goto out; - if (volinfo->type == GF_CLUSTER_TYPE_TIER) - ret = volume_volgen_graph_build_clusters_tier - (&graph, volinfo, _gf_false); - else - ret = volume_volgen_graph_build_clusters - (&graph, volinfo, _gf_false); + if (volinfo->type == GF_CLUSTER_TYPE_TIER) + ret = volume_volgen_graph_build_clusters_tier(&graph, volinfo, + _gf_false); + else + ret = volume_volgen_graph_build_clusters(&graph, volinfo, _gf_false); - if (ret) - goto out; + if (ret) + goto out; - xl = volgen_graph_add_as (&graph, "debug/io-stats", volinfo->volname); - if (!xl) { - ret = -1; - goto out; - } + xl = volgen_graph_add_as(&graph, "debug/io-stats", volinfo->volname); + if (!xl) { + ret = -1; + goto out; + } - ret = graph_set_generic_options (this, &graph, set_dict, - "rebalance-daemon"); - if (ret) - goto out; + ret = graph_set_generic_options(this, &graph, set_dict, "rebalance-daemon"); + if (ret) + goto out; - ret = volgen_graph_set_options_generic (&graph, set_dict, volinfo, - basic_option_handler); + ret = volgen_graph_set_options_generic(&graph, set_dict, volinfo, + basic_option_handler); - if (!ret) - ret = volgen_write_volfile (&graph, filepath); + if (!ret) + ret = volgen_write_volfile(&graph, filepath); out: - volgen_graph_free (&graph); + volgen_graph_free(&graph); - dict_unref (set_dict); + dict_unref(set_dict); - return ret; + return ret; } - static int -build_shd_volume_graph (xlator_t *this, volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, - dict_t *mod_dict, dict_t *set_dict, - gf_boolean_t graph_check, gf_boolean_t *valid_config) +build_shd_volume_graph(xlator_t *this, volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, dict_t *mod_dict, + dict_t *set_dict, gf_boolean_t graph_check, + gf_boolean_t *valid_config) { - volgen_graph_t cgraph = {0}; - int ret = 0; - int clusters = -1; + volgen_graph_t cgraph = {0}; + int ret = 0; + int clusters = -1; - if (!graph_check && (volinfo->status != GLUSTERD_STATUS_STARTED)) - goto out; + if (!graph_check && (volinfo->status != GLUSTERD_STATUS_STARTED)) + goto out; - if (!glusterd_is_shd_compatible_volume (volinfo)) - goto out; + if (!glusterd_is_shd_compatible_volume(volinfo)) + goto out; - /* Shd graph is valid only when there is at least one - * replica/disperse volume is present - */ - *valid_config = _gf_true; + /* Shd graph is valid only when there is at least one + * replica/disperse volume is present + */ + *valid_config = _gf_true; - ret = prepare_shd_volume_options (volinfo, mod_dict, set_dict); - if (ret) - goto out; + ret = prepare_shd_volume_options(volinfo, mod_dict, set_dict); + if (ret) + goto out; - clusters = build_shd_clusters (&cgraph, volinfo, set_dict); - if (clusters < 0) { - ret = -1; - goto out; - } + clusters = build_shd_clusters(&cgraph, volinfo, set_dict); + if (clusters < 0) { + ret = -1; + goto out; + } - ret = volgen_graph_set_options_generic (&cgraph, set_dict, - volinfo, shd_option_handler); - if (ret) - goto out; + ret = volgen_graph_set_options_generic(&cgraph, set_dict, volinfo, + shd_option_handler); + if (ret) + goto out; - ret = volgen_graph_set_iam_shd (&cgraph); - if (ret) - goto out; + ret = volgen_graph_set_iam_shd(&cgraph); + if (ret) + goto out; - ret = volgen_graph_merge_sub (graph, &cgraph, clusters); - if (ret) - goto out; + ret = volgen_graph_merge_sub(graph, &cgraph, clusters); + if (ret) + goto out; - ret = graph_set_generic_options (this, graph, set_dict, - "self-heal daemon"); + ret = graph_set_generic_options(this, graph, set_dict, "self-heal daemon"); out: - return ret; + return ret; } int -build_shd_graph (volgen_graph_t *graph, dict_t *mod_dict) -{ - glusterd_volinfo_t *voliter = NULL; - xlator_t *this = NULL; - glusterd_conf_t *priv = NULL; - dict_t *set_dict = NULL; - int ret = 0; - gf_boolean_t valid_config = _gf_false; - xlator_t *iostxl = NULL; - gf_boolean_t graph_check = _gf_false; - - this = THIS; - priv = this->private; - - set_dict = dict_new (); - if (!set_dict) { - ret = -ENOMEM; - goto out; - } - - if (mod_dict) - graph_check = dict_get_str_boolean (mod_dict, "graph-check", 0); - iostxl = volgen_graph_add_as (graph, "debug/io-stats", "glustershd"); - if (!iostxl) { - ret = -1; - goto out; - } - - cds_list_for_each_entry (voliter, &priv->volumes, vol_list) { - ret = build_shd_volume_graph (this, graph, voliter, - mod_dict, set_dict, - graph_check, &valid_config); - ret = dict_reset (set_dict); - if (ret) - goto out; - } +build_shd_graph(volgen_graph_t *graph, dict_t *mod_dict) +{ + glusterd_volinfo_t *voliter = NULL; + xlator_t *this = NULL; + glusterd_conf_t *priv = NULL; + dict_t *set_dict = NULL; + int ret = 0; + gf_boolean_t valid_config = _gf_false; + xlator_t *iostxl = NULL; + gf_boolean_t graph_check = _gf_false; + + this = THIS; + priv = this->private; + + set_dict = dict_new(); + if (!set_dict) { + ret = -ENOMEM; + goto out; + } + + if (mod_dict) + graph_check = dict_get_str_boolean(mod_dict, "graph-check", 0); + iostxl = volgen_graph_add_as(graph, "debug/io-stats", "glustershd"); + if (!iostxl) { + ret = -1; + goto out; + } + + cds_list_for_each_entry(voliter, &priv->volumes, vol_list) + { + ret = build_shd_volume_graph(this, graph, voliter, mod_dict, set_dict, + graph_check, &valid_config); + ret = dict_reset(set_dict); + if (ret) + goto out; + } out: - if (set_dict) - dict_unref (set_dict); - if (!valid_config) - ret = -EINVAL; - return ret; + if (set_dict) + dict_unref(set_dict); + if (!valid_config) + ret = -EINVAL; + return ret; } static int -volgen_graph_set_iam_nfsd (const volgen_graph_t *graph) +volgen_graph_set_iam_nfsd(const volgen_graph_t *graph) { - xlator_t *trav; - int ret = 0; + xlator_t *trav; + int ret = 0; - for (trav = first_of ((volgen_graph_t *)graph); trav; - trav = trav->next) { - if (strcmp (trav->type, "cluster/replicate") != 0) - continue; + for (trav = first_of((volgen_graph_t *)graph); trav; trav = trav->next) { + if (strcmp(trav->type, "cluster/replicate") != 0) + continue; - ret = xlator_set_option (trav, "iam-nfs-daemon", "yes"); - if (ret) - break; - } - return ret; + ret = xlator_set_option(trav, "iam-nfs-daemon", "yes"); + if (ret) + break; + } + return ret; } /* builds a graph for nfs server role, with option overrides in mod_dict */ int -build_nfs_graph (volgen_graph_t *graph, dict_t *mod_dict) -{ - volgen_graph_t cgraph = {0,}; - glusterd_volinfo_t *voliter = NULL; - xlator_t *this = NULL; - glusterd_conf_t *priv = NULL; - dict_t *set_dict = NULL; - xlator_t *nfsxl = NULL; - char *skey = NULL; - int ret = 0; - char nfs_xprt[16] = {0,}; - char *volname = NULL; - data_t *data = NULL; - - this = THIS; - GF_ASSERT (this); - priv = this->private; - GF_ASSERT (priv); - - set_dict = dict_new (); - if (!set_dict) { - gf_msg ("glusterd", GF_LOG_ERROR, ENOMEM, - GD_MSG_NO_MEMORY, - "Out of memory"); - return -1; - } +build_nfs_graph(volgen_graph_t *graph, dict_t *mod_dict) +{ + volgen_graph_t cgraph = { + 0, + }; + glusterd_volinfo_t *voliter = NULL; + xlator_t *this = NULL; + glusterd_conf_t *priv = NULL; + dict_t *set_dict = NULL; + xlator_t *nfsxl = NULL; + char *skey = NULL; + int ret = 0; + char nfs_xprt[16] = { + 0, + }; + char *volname = NULL; + data_t *data = NULL; + + this = THIS; + GF_ASSERT(this); + priv = this->private; + GF_ASSERT(priv); + + set_dict = dict_new(); + if (!set_dict) { + gf_msg("glusterd", GF_LOG_ERROR, ENOMEM, GD_MSG_NO_MEMORY, + "Out of memory"); + return -1; + } - nfsxl = volgen_graph_add_as (graph, "nfs/server", "nfs-server"); - if (!nfsxl) { - ret = -1; - goto out; - } - ret = xlator_set_option (nfsxl, "nfs.dynamic-volumes", "on"); - if (ret) - goto out; + nfsxl = volgen_graph_add_as(graph, "nfs/server", "nfs-server"); + if (!nfsxl) { + ret = -1; + goto out; + } + ret = xlator_set_option(nfsxl, "nfs.dynamic-volumes", "on"); + if (ret) + goto out; - ret = xlator_set_option (nfsxl, "nfs.nlm", "on"); - if (ret) - goto out; + ret = xlator_set_option(nfsxl, "nfs.nlm", "on"); + if (ret) + goto out; - ret = xlator_set_option (nfsxl, "nfs.drc", "off"); - if (ret) - goto out; + ret = xlator_set_option(nfsxl, "nfs.drc", "off"); + if (ret) + goto out; - cds_list_for_each_entry (voliter, &priv->volumes, vol_list) { - if (voliter->status != GLUSTERD_STATUS_STARTED) - continue; + cds_list_for_each_entry(voliter, &priv->volumes, vol_list) + { + if (voliter->status != GLUSTERD_STATUS_STARTED) + continue; - if (dict_get_str_boolean (voliter->dict, NFS_DISABLE_MAP_KEY, 0)) - continue; + if (dict_get_str_boolean(voliter->dict, NFS_DISABLE_MAP_KEY, 0)) + continue; - ret = gf_asprintf (&skey, "rpc-auth.addr.%s.allow", - voliter->volname); - if (ret == -1) { - gf_msg ("glusterd", GF_LOG_ERROR, ENOMEM, - GD_MSG_NO_MEMORY, "Out of memory"); - goto out; - } - ret = xlator_set_option (nfsxl, skey, "*"); - GF_FREE (skey); - if (ret) - goto out; - - ret = gf_asprintf (&skey, "nfs3.%s.volume-id", - voliter->volname); - if (ret == -1) { - gf_msg ("glusterd", GF_LOG_ERROR, 0, - GD_MSG_NO_MEMORY, "Out of memory"); - goto out; - } - ret = xlator_set_option (nfsxl, skey, uuid_utoa (voliter->volume_id)); - GF_FREE (skey); - if (ret) - goto out; - - /* If both RDMA and TCP are the transport_type, use TCP for NFS - * client protocols, because tcp,rdma volume can be created in - * servers which does not have rdma supported hardware - * The transport type specified here is client transport type - * which is used for communication between gluster-nfs and brick - * processes. - * User can specify client transport for tcp,rdma volume using - * nfs.transport-type, if it is not set by user default - * one will be tcp. - */ - memset (&cgraph, 0, sizeof (cgraph)); - if (mod_dict) - get_transport_type (voliter, mod_dict, nfs_xprt, _gf_true); - else - get_transport_type (voliter, voliter->dict, nfs_xprt, _gf_true); - - ret = dict_set_str (set_dict, "performance.stat-prefetch", "off"); - if (ret) - goto out; + ret = gf_asprintf(&skey, "rpc-auth.addr.%s.allow", voliter->volname); + if (ret == -1) { + gf_msg("glusterd", GF_LOG_ERROR, ENOMEM, GD_MSG_NO_MEMORY, + "Out of memory"); + goto out; + } + ret = xlator_set_option(nfsxl, skey, "*"); + GF_FREE(skey); + if (ret) + goto out; - ret = dict_set_str (set_dict, "performance.client-io-threads", - "off"); - if (ret) - goto out; + ret = gf_asprintf(&skey, "nfs3.%s.volume-id", voliter->volname); + if (ret == -1) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_NO_MEMORY, + "Out of memory"); + goto out; + } + ret = xlator_set_option(nfsxl, skey, uuid_utoa(voliter->volume_id)); + GF_FREE(skey); + if (ret) + goto out; + + /* If both RDMA and TCP are the transport_type, use TCP for NFS + * client protocols, because tcp,rdma volume can be created in + * servers which does not have rdma supported hardware + * The transport type specified here is client transport type + * which is used for communication between gluster-nfs and brick + * processes. + * User can specify client transport for tcp,rdma volume using + * nfs.transport-type, if it is not set by user default + * one will be tcp. + */ + memset(&cgraph, 0, sizeof(cgraph)); + if (mod_dict) + get_transport_type(voliter, mod_dict, nfs_xprt, _gf_true); + else + get_transport_type(voliter, voliter->dict, nfs_xprt, _gf_true); - ret = dict_set_str (set_dict, "client-transport-type", - nfs_xprt); - if (ret) - goto out; + ret = dict_set_str(set_dict, "performance.stat-prefetch", "off"); + if (ret) + goto out; - ret = dict_set_uint32 (set_dict, "trusted-client", - GF_CLIENT_TRUSTED); - if (ret) - goto out; + ret = dict_set_str(set_dict, "performance.client-io-threads", "off"); + if (ret) + goto out; - ret = dict_set_str (set_dict, "nfs-volume-file", "yes"); - if (ret) - goto out; + ret = dict_set_str(set_dict, "client-transport-type", nfs_xprt); + if (ret) + goto out; - if (mod_dict && (data = dict_get (mod_dict, "volume-name"))) { - volname = data->data; - if (strcmp (volname, voliter->volname) == 0) - dict_copy (mod_dict, set_dict); - } + ret = dict_set_uint32(set_dict, "trusted-client", GF_CLIENT_TRUSTED); + if (ret) + goto out; - ret = build_client_graph (&cgraph, voliter, set_dict); - if (ret) - goto out; - - if (mod_dict) { - dict_copy (mod_dict, set_dict); - ret = volgen_graph_set_options_generic (&cgraph, set_dict, voliter, - basic_option_handler); - } else { - ret = volgen_graph_set_options_generic (&cgraph, voliter->dict, voliter, - basic_option_handler); - } + ret = dict_set_str(set_dict, "nfs-volume-file", "yes"); + if (ret) + goto out; - if (ret) - goto out; + if (mod_dict && (data = dict_get(mod_dict, "volume-name"))) { + volname = data->data; + if (strcmp(volname, voliter->volname) == 0) + dict_copy(mod_dict, set_dict); + } - ret = volgen_graph_set_iam_nfsd (&cgraph); - if (ret) - goto out; + ret = build_client_graph(&cgraph, voliter, set_dict); + if (ret) + goto out; - ret = volgen_graph_merge_sub (graph, &cgraph, 1); - if (ret) - goto out; - ret = dict_reset (set_dict); - if (ret) - goto out; + if (mod_dict) { + dict_copy(mod_dict, set_dict); + ret = volgen_graph_set_options_generic(&cgraph, set_dict, voliter, + basic_option_handler); + } else { + ret = volgen_graph_set_options_generic( + &cgraph, voliter->dict, voliter, basic_option_handler); } - cds_list_for_each_entry (voliter, &priv->volumes, vol_list) { + if (ret) + goto out; - if (mod_dict) { - ret = volgen_graph_set_options_generic (graph, mod_dict, voliter, - nfs_option_handler); - } else { - ret = volgen_graph_set_options_generic (graph, voliter->dict, voliter, - nfs_option_handler); - } + ret = volgen_graph_set_iam_nfsd(&cgraph); + if (ret) + goto out; - if (ret) - gf_msg ("glusterd", GF_LOG_WARNING, 0, - GD_MSG_GRAPH_SET_OPT_FAIL, "Could not set " - "vol-options for the volume %s", voliter->volname); + ret = volgen_graph_merge_sub(graph, &cgraph, 1); + if (ret) + goto out; + ret = dict_reset(set_dict); + if (ret) + goto out; + } + + cds_list_for_each_entry(voliter, &priv->volumes, vol_list) + { + if (mod_dict) { + ret = volgen_graph_set_options_generic(graph, mod_dict, voliter, + nfs_option_handler); + } else { + ret = volgen_graph_set_options_generic(graph, voliter->dict, + voliter, nfs_option_handler); } - out: - gf_msg_debug ("glusterd", 0, "Returning %d", ret); - dict_unref (set_dict); + if (ret) + gf_msg("glusterd", GF_LOG_WARNING, 0, GD_MSG_GRAPH_SET_OPT_FAIL, + "Could not set " + "vol-options for the volume %s", + voliter->volname); + } - return ret; +out: + gf_msg_debug("glusterd", 0, "Returning %d", ret); + dict_unref(set_dict); + + return ret; } /**************************** @@ -5645,1589 +5451,1575 @@ build_nfs_graph (volgen_graph_t *graph, dict_t *mod_dict) * ****************************/ - static void -get_brick_filepath (char *filename, glusterd_volinfo_t *volinfo, - glusterd_brickinfo_t *brickinfo, char *prefix) -{ - char path[PATH_MAX] = {0,}; - char brick[PATH_MAX] = {0,}; - glusterd_conf_t *priv = NULL; - int32_t len = 0; - - priv = THIS->private; - - GLUSTERD_REMOVE_SLASH_FROM_PATH (brickinfo->path, brick); - GLUSTERD_GET_VOLUME_DIR (path, volinfo, priv); - - if (prefix) - len = snprintf (filename, PATH_MAX, "%s/%s.%s.%s.%s.vol", - path, volinfo->volname, prefix, - brickinfo->hostname, brick); - else - len = snprintf (filename, PATH_MAX, "%s/%s.%s.%s.vol", - path, volinfo->volname, - brickinfo->hostname, brick); - if ((len < 0) || (len >= PATH_MAX)) { - filename[0] = 0; - } +get_brick_filepath(char *filename, glusterd_volinfo_t *volinfo, + glusterd_brickinfo_t *brickinfo, char *prefix) +{ + char path[PATH_MAX] = { + 0, + }; + char brick[PATH_MAX] = { + 0, + }; + glusterd_conf_t *priv = NULL; + int32_t len = 0; + + priv = THIS->private; + + GLUSTERD_REMOVE_SLASH_FROM_PATH(brickinfo->path, brick); + GLUSTERD_GET_VOLUME_DIR(path, volinfo, priv); + + if (prefix) + len = snprintf(filename, PATH_MAX, "%s/%s.%s.%s.%s.vol", path, + volinfo->volname, prefix, brickinfo->hostname, brick); + else + len = snprintf(filename, PATH_MAX, "%s/%s.%s.%s.vol", path, + volinfo->volname, brickinfo->hostname, brick); + if ((len < 0) || (len >= PATH_MAX)) { + filename[0] = 0; + } } - gf_boolean_t -glusterd_is_valid_volfpath (char *volname, char *brick) -{ - char volfpath[PATH_MAX] = {0,}; - glusterd_brickinfo_t *brickinfo = NULL; - glusterd_volinfo_t *volinfo = NULL; - int32_t ret = 0; - xlator_t *this = NULL; - - this = THIS; - GF_ASSERT (this); - - ret = glusterd_brickinfo_new_from_brick (brick, &brickinfo, _gf_false, - NULL); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, 0, - GD_MSG_BRICKINFO_CREATE_FAIL, - "Failed to create brickinfo" - " for brick %s", brick ); - ret = 0; - goto out; - } - ret = glusterd_volinfo_new (&volinfo); - if (ret) { - gf_msg (this->name, GF_LOG_WARNING, 0, - GD_MSG_VOLINFO_STORE_FAIL, - "Failed to create volinfo"); - ret = 0; - goto out; - } - strncpy (volinfo->volname, volname, strlen (volname)); - get_brick_filepath (volfpath, volinfo, brickinfo, NULL); +glusterd_is_valid_volfpath(char *volname, char *brick) +{ + char volfpath[PATH_MAX] = { + 0, + }; + glusterd_brickinfo_t *brickinfo = NULL; + glusterd_volinfo_t *volinfo = NULL; + int32_t ret = 0; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT(this); + + ret = glusterd_brickinfo_new_from_brick(brick, &brickinfo, _gf_false, NULL); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, 0, GD_MSG_BRICKINFO_CREATE_FAIL, + "Failed to create brickinfo" + " for brick %s", + brick); + ret = 0; + goto out; + } + ret = glusterd_volinfo_new(&volinfo); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, 0, GD_MSG_VOLINFO_STORE_FAIL, + "Failed to create volinfo"); + ret = 0; + goto out; + } + strncpy(volinfo->volname, volname, strlen(volname)); + get_brick_filepath(volfpath, volinfo, brickinfo, NULL); - ret = ((strlen(volfpath) < PATH_MAX) && - strlen (strrchr(volfpath, '/')) < _POSIX_PATH_MAX); + ret = ((strlen(volfpath) < PATH_MAX) && + strlen(strrchr(volfpath, '/')) < _POSIX_PATH_MAX); out: - if (brickinfo) - glusterd_brickinfo_delete (brickinfo); - if (volinfo) - glusterd_volinfo_unref (volinfo); - return ret; + if (brickinfo) + glusterd_brickinfo_delete(brickinfo); + if (volinfo) + glusterd_volinfo_unref(volinfo); + return ret; } int -glusterd_build_gfproxyd_volfile (glusterd_volinfo_t *volinfo, char *filename) +glusterd_build_gfproxyd_volfile(glusterd_volinfo_t *volinfo, char *filename) { - volgen_graph_t graph = {0, }; - int ret = -1; + volgen_graph_t graph = { + 0, + }; + int ret = -1; - ret = build_graph_generic (&graph, volinfo, - NULL, NULL, - &gfproxy_server_graph_builder); - if (ret == 0) - ret = volgen_write_volfile (&graph, filename); + ret = build_graph_generic(&graph, volinfo, NULL, NULL, + &gfproxy_server_graph_builder); + if (ret == 0) + ret = volgen_write_volfile(&graph, filename); - volgen_graph_free (&graph); + volgen_graph_free(&graph); - return ret; + return ret; } int -glusterd_generate_gfproxyd_volfile (glusterd_volinfo_t *volinfo) +glusterd_generate_gfproxyd_volfile(glusterd_volinfo_t *volinfo) { - char filename[PATH_MAX] = {0, }; - int ret = -1; + char filename[PATH_MAX] = { + 0, + }; + int ret = -1; - GF_ASSERT (volinfo); + GF_ASSERT(volinfo); - glusterd_svc_build_gfproxyd_volfile_path (volinfo, filename, - PATH_MAX - 1); + glusterd_svc_build_gfproxyd_volfile_path(volinfo, filename, PATH_MAX - 1); - ret = glusterd_build_gfproxyd_volfile (volinfo, filename); + ret = glusterd_build_gfproxyd_volfile(volinfo, filename); - return ret; + return ret; } static int -glusterd_generate_brick_volfile (glusterd_volinfo_t *volinfo, - glusterd_brickinfo_t *brickinfo, - dict_t *mod_dict, void *data) +glusterd_generate_brick_volfile(glusterd_volinfo_t *volinfo, + glusterd_brickinfo_t *brickinfo, + dict_t *mod_dict, void *data) { - volgen_graph_t graph = {0,}; - char filename[PATH_MAX] = {0,}; - int ret = -1; + volgen_graph_t graph = { + 0, + }; + char filename[PATH_MAX] = { + 0, + }; + int ret = -1; - GF_ASSERT (volinfo); - GF_ASSERT (brickinfo); + GF_ASSERT(volinfo); + GF_ASSERT(brickinfo); - get_brick_filepath (filename, volinfo, brickinfo, NULL); + get_brick_filepath(filename, volinfo, brickinfo, NULL); - ret = build_server_graph (&graph, volinfo, mod_dict, brickinfo); - if (!ret) - ret = volgen_write_volfile (&graph, filename); + ret = build_server_graph(&graph, volinfo, mod_dict, brickinfo); + if (!ret) + ret = volgen_write_volfile(&graph, filename); - volgen_graph_free (&graph); + volgen_graph_free(&graph); - return ret; + return ret; } int -build_quotad_graph (volgen_graph_t *graph, dict_t *mod_dict) +build_quotad_graph(volgen_graph_t *graph, dict_t *mod_dict) { - volgen_graph_t cgraph = {0}; - glusterd_volinfo_t *voliter = NULL; - xlator_t *this = NULL; - glusterd_conf_t *priv = NULL; - dict_t *set_dict = NULL; - int ret = 0; - xlator_t *quotad_xl = NULL; - char *skey = NULL; + volgen_graph_t cgraph = {0}; + glusterd_volinfo_t *voliter = NULL; + xlator_t *this = NULL; + glusterd_conf_t *priv = NULL; + dict_t *set_dict = NULL; + int ret = 0; + xlator_t *quotad_xl = NULL; + char *skey = NULL; - this = THIS; - GF_ASSERT (this); + this = THIS; + GF_ASSERT(this); - priv = this->private; - GF_ASSERT (priv); + priv = this->private; + GF_ASSERT(priv); - graph->type = GF_QUOTAD; - - set_dict = dict_new (); - if (!set_dict) { - ret = -ENOMEM; - goto out; - } + graph->type = GF_QUOTAD; - quotad_xl = volgen_graph_add_as (graph, "features/quotad", "quotad"); - if (!quotad_xl) { - ret = -1; - goto out; - } + set_dict = dict_new(); + if (!set_dict) { + ret = -ENOMEM; + goto out; + } - cds_list_for_each_entry (voliter, &priv->volumes, vol_list) { - if (voliter->status != GLUSTERD_STATUS_STARTED) - continue; + quotad_xl = volgen_graph_add_as(graph, "features/quotad", "quotad"); + if (!quotad_xl) { + ret = -1; + goto out; + } - if (1 != glusterd_is_volume_quota_enabled (voliter)) - continue; + cds_list_for_each_entry(voliter, &priv->volumes, vol_list) + { + if (voliter->status != GLUSTERD_STATUS_STARTED) + continue; - ret = dict_set_uint32 (set_dict, "trusted-client", - GF_CLIENT_TRUSTED); - if (ret) - goto out; + if (1 != glusterd_is_volume_quota_enabled(voliter)) + continue; - dict_copy (voliter->dict, set_dict); - if (mod_dict) - dict_copy (mod_dict, set_dict); + ret = dict_set_uint32(set_dict, "trusted-client", GF_CLIENT_TRUSTED); + if (ret) + goto out; - ret = gf_asprintf(&skey, "%s.volume-id", voliter->volname); - if (ret == -1) { - gf_msg ("glusterd", GF_LOG_ERROR, ENOMEM, - GD_MSG_NO_MEMORY, "Out of memory"); - goto out; - } - ret = xlator_set_option(quotad_xl, skey, voliter->volname); - GF_FREE(skey); - if (ret) - goto out; + dict_copy(voliter->dict, set_dict); + if (mod_dict) + dict_copy(mod_dict, set_dict); - memset (&cgraph, 0, sizeof (cgraph)); - ret = volgen_graph_build_clients (&cgraph, voliter, set_dict, - NULL); - if (ret) - goto out; - - if (voliter->type == GF_CLUSTER_TYPE_TIER) - ret = volume_volgen_graph_build_clusters_tier - (&cgraph, voliter, _gf_true); - else - ret = volume_volgen_graph_build_clusters - (&cgraph, voliter, _gf_true); - if (ret) { - ret = -1; - goto out; - } + ret = gf_asprintf(&skey, "%s.volume-id", voliter->volname); + if (ret == -1) { + gf_msg("glusterd", GF_LOG_ERROR, ENOMEM, GD_MSG_NO_MEMORY, + "Out of memory"); + goto out; + } + ret = xlator_set_option(quotad_xl, skey, voliter->volname); + GF_FREE(skey); + if (ret) + goto out; - if (mod_dict) { - dict_copy (mod_dict, set_dict); - ret = volgen_graph_set_options_generic (&cgraph, set_dict, - voliter, - basic_option_handler); - } else { - ret = volgen_graph_set_options_generic (&cgraph, - voliter->dict, - voliter, - basic_option_handler); - } - if (ret) - goto out; + memset(&cgraph, 0, sizeof(cgraph)); + ret = volgen_graph_build_clients(&cgraph, voliter, set_dict, NULL); + if (ret) + goto out; - ret = volgen_graph_merge_sub (graph, &cgraph, 1); - if (ret) - goto out; + if (voliter->type == GF_CLUSTER_TYPE_TIER) + ret = volume_volgen_graph_build_clusters_tier(&cgraph, voliter, + _gf_true); + else + ret = volume_volgen_graph_build_clusters(&cgraph, voliter, + _gf_true); + if (ret) { + ret = -1; + goto out; + } - ret = dict_reset (set_dict); - if (ret) - goto out; + if (mod_dict) { + dict_copy(mod_dict, set_dict); + ret = volgen_graph_set_options_generic(&cgraph, set_dict, voliter, + basic_option_handler); + } else { + ret = volgen_graph_set_options_generic( + &cgraph, voliter->dict, voliter, basic_option_handler); } + if (ret) + goto out; + + ret = volgen_graph_merge_sub(graph, &cgraph, 1); + if (ret) + goto out; + + ret = dict_reset(set_dict); + if (ret) + goto out; + } out: - if (set_dict) - dict_unref (set_dict); - return ret; + if (set_dict) + dict_unref(set_dict); + return ret; } static void -get_vol_tstamp_file (char *filename, glusterd_volinfo_t *volinfo) +get_vol_tstamp_file(char *filename, glusterd_volinfo_t *volinfo) { - glusterd_conf_t *priv = NULL; + glusterd_conf_t *priv = NULL; - priv = THIS->private; + priv = THIS->private; - GLUSTERD_GET_VOLUME_DIR (filename, volinfo, priv); - strncat (filename, "/marker.tstamp", - PATH_MAX - strlen(filename) - 1); + GLUSTERD_GET_VOLUME_DIR(filename, volinfo, priv); + strncat(filename, "/marker.tstamp", PATH_MAX - strlen(filename) - 1); } static void -get_parent_vol_tstamp_file (char *filename, glusterd_volinfo_t *volinfo) +get_parent_vol_tstamp_file(char *filename, glusterd_volinfo_t *volinfo) { - glusterd_conf_t *priv = NULL; - xlator_t *this = NULL; - int32_t len = 0; + glusterd_conf_t *priv = NULL; + xlator_t *this = NULL; + int32_t len = 0; - this = THIS; - GF_ASSERT (this); - priv = this->private; - GF_ASSERT (priv); + this = THIS; + GF_ASSERT(this); + priv = this->private; + GF_ASSERT(priv); - len = snprintf (filename, PATH_MAX, "%s/vols/%s/marker.tstamp", - priv->workdir, volinfo->parent_volname); - if ((len < 0) || (len >= PATH_MAX)) { - filename[0] = 0; - } + len = snprintf(filename, PATH_MAX, "%s/vols/%s/marker.tstamp", + priv->workdir, volinfo->parent_volname); + if ((len < 0) || (len >= PATH_MAX)) { + filename[0] = 0; + } } void -assign_jbr_uuids (glusterd_volinfo_t *volinfo) -{ - glusterd_brickinfo_t *brickinfo = NULL; - int in_group = 0; - uuid_t tmp_uuid; - - list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { - if (in_group == 0) - gf_uuid_generate(tmp_uuid); - gf_uuid_copy(brickinfo->jbr_uuid, tmp_uuid); - if (++in_group >= volinfo->replica_count) - in_group = 0; - } -} - -int -generate_brick_volfiles (glusterd_volinfo_t *volinfo) +assign_jbr_uuids(glusterd_volinfo_t *volinfo) { - char tstamp_file[PATH_MAX] = {0,}; - char parent_tstamp_file[PATH_MAX] = {0,}; - int ret = -1; - xlator_t *this = NULL; + glusterd_brickinfo_t *brickinfo = NULL; + int in_group = 0; + uuid_t tmp_uuid; - this = THIS; - GF_ASSERT (this); + list_for_each_entry(brickinfo, &volinfo->bricks, brick_list) + { + if (in_group == 0) + gf_uuid_generate(tmp_uuid); + gf_uuid_copy(brickinfo->jbr_uuid, tmp_uuid); + if (++in_group >= volinfo->replica_count) + in_group = 0; + } +} - ret = glusterd_volinfo_get_boolean (volinfo, VKEY_MARKER_XTIME); - if (ret == -1) - return -1; +int +generate_brick_volfiles(glusterd_volinfo_t *volinfo) +{ + char tstamp_file[PATH_MAX] = { + 0, + }; + char parent_tstamp_file[PATH_MAX] = { + 0, + }; + int ret = -1; + xlator_t *this = NULL; + + this = THIS; + GF_ASSERT(this); + + ret = glusterd_volinfo_get_boolean(volinfo, VKEY_MARKER_XTIME); + if (ret == -1) + return -1; - assign_brick_groups (volinfo); - get_vol_tstamp_file (tstamp_file, volinfo); + assign_brick_groups(volinfo); + get_vol_tstamp_file(tstamp_file, volinfo); - if (ret) { - ret = open (tstamp_file, O_WRONLY|O_CREAT|O_EXCL, 0600); - if (ret == -1 && errno == EEXIST) { - gf_msg_debug (this->name, 0, - "timestamp file exist"); - ret = -2; - } - if (ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, errno, - GD_MSG_FILE_OP_FAILED, - "failed to create " - "%s", tstamp_file); - return -1; - } - if (ret >= 0) { - sys_close (ret); - /* If snap_volume, retain timestamp for marker.tstamp - * from parent. Geo-replication depends on mtime of - * 'marker.tstamp' to decide the volume-mark, i.e., - * geo-rep start time just after session is created. - */ - if (volinfo->is_snap_volume) { - get_parent_vol_tstamp_file (parent_tstamp_file, - volinfo); - ret = gf_set_timestamp (parent_tstamp_file, - tstamp_file); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - GD_MSG_TSTAMP_SET_FAIL, - "Unable to set atime and mtime" - " of %s as of %s", tstamp_file, - parent_tstamp_file); - goto out; - } - } - } - } else { - ret = sys_unlink (tstamp_file); - if (ret == -1 && errno == ENOENT) - ret = 0; - if (ret == -1) { - gf_msg (this->name, GF_LOG_ERROR, errno, - GD_MSG_FILE_OP_FAILED, - "failed to unlink " - "%s", tstamp_file); - return -1; + if (ret) { + ret = open(tstamp_file, O_WRONLY | O_CREAT | O_EXCL, 0600); + if (ret == -1 && errno == EEXIST) { + gf_msg_debug(this->name, 0, "timestamp file exist"); + ret = -2; + } + if (ret == -1) { + gf_msg(this->name, GF_LOG_ERROR, errno, GD_MSG_FILE_OP_FAILED, + "failed to create " + "%s", + tstamp_file); + return -1; + } + if (ret >= 0) { + sys_close(ret); + /* If snap_volume, retain timestamp for marker.tstamp + * from parent. Geo-replication depends on mtime of + * 'marker.tstamp' to decide the volume-mark, i.e., + * geo-rep start time just after session is created. + */ + if (volinfo->is_snap_volume) { + get_parent_vol_tstamp_file(parent_tstamp_file, volinfo); + ret = gf_set_timestamp(parent_tstamp_file, tstamp_file); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_TSTAMP_SET_FAIL, + "Unable to set atime and mtime" + " of %s as of %s", + tstamp_file, parent_tstamp_file); + goto out; } + } } - - if (glusterd_volinfo_get_boolean(volinfo, "cluster.jbr") > 0) { - assign_jbr_uuids(volinfo); + } else { + ret = sys_unlink(tstamp_file); + if (ret == -1 && errno == ENOENT) + ret = 0; + if (ret == -1) { + gf_msg(this->name, GF_LOG_ERROR, errno, GD_MSG_FILE_OP_FAILED, + "failed to unlink " + "%s", + tstamp_file); + return -1; } + } - ret = glusterd_volume_brick_for_each (volinfo, NULL, - glusterd_generate_brick_volfile); - if (ret) - goto out; + if (glusterd_volinfo_get_boolean(volinfo, "cluster.jbr") > 0) { + assign_jbr_uuids(volinfo); + } - ret = 0; + ret = glusterd_volume_brick_for_each(volinfo, NULL, + glusterd_generate_brick_volfile); + if (ret) + goto out; + + ret = 0; out: - gf_msg_debug (this->name, 0, "Returning %d", ret); - return ret; + gf_msg_debug(this->name, 0, "Returning %d", ret); + return ret; } static int -generate_single_transport_client_volfile (glusterd_volinfo_t *volinfo, - char *filepath, dict_t *dict) +generate_single_transport_client_volfile(glusterd_volinfo_t *volinfo, + char *filepath, dict_t *dict) { - volgen_graph_t graph = {0,}; - int ret = -1; + volgen_graph_t graph = { + 0, + }; + int ret = -1; - ret = build_client_graph (&graph, volinfo, dict); - if (!ret) - ret = volgen_write_volfile (&graph, filepath); + ret = build_client_graph(&graph, volinfo, dict); + if (!ret) + ret = volgen_write_volfile(&graph, filepath); - volgen_graph_free (&graph); + volgen_graph_free(&graph); - return ret; + return ret; } int -glusterd_generate_client_per_brick_volfile (glusterd_volinfo_t *volinfo) -{ - char filepath[PATH_MAX] = {0, }; - glusterd_brickinfo_t *brick = NULL; - volgen_graph_t graph = {0, }; - dict_t *dict = NULL; - xlator_t *xl = NULL; - int ret = -1; - char *ssl_str = NULL; - gf_boolean_t ssl_bool = _gf_false; - - dict = dict_new (); - if (!dict) - goto out; - - ret = dict_set_uint32 (dict, "trusted-client", GF_CLIENT_TRUSTED); - if (ret) - goto free_dict; - - if (dict_get_str(volinfo->dict, "client.ssl", &ssl_str) == 0) { - if (gf_string2boolean(ssl_str, &ssl_bool) == 0) { - if (ssl_bool) { - if (dict_set_dynstr_with_alloc(dict, - "client.ssl", "on") != 0) { - ret = -1; - goto free_dict; - } - } - } else { - ret = -1; - goto free_dict; +glusterd_generate_client_per_brick_volfile(glusterd_volinfo_t *volinfo) +{ + char filepath[PATH_MAX] = { + 0, + }; + glusterd_brickinfo_t *brick = NULL; + volgen_graph_t graph = { + 0, + }; + dict_t *dict = NULL; + xlator_t *xl = NULL; + int ret = -1; + char *ssl_str = NULL; + gf_boolean_t ssl_bool = _gf_false; + + dict = dict_new(); + if (!dict) + goto out; + + ret = dict_set_uint32(dict, "trusted-client", GF_CLIENT_TRUSTED); + if (ret) + goto free_dict; + + if (dict_get_str(volinfo->dict, "client.ssl", &ssl_str) == 0) { + if (gf_string2boolean(ssl_str, &ssl_bool) == 0) { + if (ssl_bool) { + if (dict_set_dynstr_with_alloc(dict, "client.ssl", "on") != 0) { + ret = -1; + goto free_dict; } + } + } else { + ret = -1; + goto free_dict; } + } - cds_list_for_each_entry (brick, &volinfo->bricks, brick_list) { - xl = volgen_graph_build_client (&graph, volinfo, - brick->hostname, - NULL, brick->path, - brick->brick_id, - "tcp", dict); - if (!xl) { - ret = -1; - goto out; - } - - get_brick_filepath (filepath, volinfo, brick, "client"); - ret = volgen_write_volfile (&graph, filepath); - if (ret < 0) - goto out; - - volgen_graph_free (&graph); - memset (&graph, 0, sizeof (graph)); + cds_list_for_each_entry(brick, &volinfo->bricks, brick_list) + { + xl = volgen_graph_build_client(&graph, volinfo, brick->hostname, NULL, + brick->path, brick->brick_id, "tcp", + dict); + if (!xl) { + ret = -1; + goto out; } + get_brick_filepath(filepath, volinfo, brick, "client"); + ret = volgen_write_volfile(&graph, filepath); + if (ret < 0) + goto out; - ret = 0; + volgen_graph_free(&graph); + memset(&graph, 0, sizeof(graph)); + } + + ret = 0; out: - if (ret) - volgen_graph_free (&graph); + if (ret) + volgen_graph_free(&graph); free_dict: - if (dict) - dict_unref (dict); + if (dict) + dict_unref(dict); - return ret; + return ret; } static void -enumerate_transport_reqs (gf_transport_type type, char **types) +enumerate_transport_reqs(gf_transport_type type, char **types) { - switch (type) { + switch (type) { case GF_TRANSPORT_TCP: - types[0] = "tcp"; - break; + types[0] = "tcp"; + break; case GF_TRANSPORT_RDMA: - types[0] = "rdma"; - break; + types[0] = "rdma"; + break; case GF_TRANSPORT_BOTH_TCP_RDMA: - types[0] = "tcp"; - types[1] = "rdma"; - break; - } + types[0] = "tcp"; + types[1] = "rdma"; + break; + } } int -generate_dummy_client_volfiles (glusterd_volinfo_t *volinfo) -{ - int i = 0; - int ret = -1; - char filepath[PATH_MAX] = {0,}; - char *types[] = {NULL, NULL, NULL}; - dict_t *dict = NULL; - xlator_t *this = NULL; - gf_transport_type type = GF_TRANSPORT_TCP; - - this = THIS; - - enumerate_transport_reqs (volinfo->transport_type, types); - dict = dict_new (); - if (!dict) - goto out; - for (i = 0; types[i]; i++) { - ret = dict_set_str (dict, "client-transport-type", types[i]); - if (ret) - goto out; - type = transport_str_to_type (types[i]); - - ret = dict_set_uint32 (dict, "trusted-client", GF_CLIENT_OTHER); - if (ret) - goto out; +generate_dummy_client_volfiles(glusterd_volinfo_t *volinfo) +{ + int i = 0; + int ret = -1; + char filepath[PATH_MAX] = { + 0, + }; + char *types[] = {NULL, NULL, NULL}; + dict_t *dict = NULL; + xlator_t *this = NULL; + gf_transport_type type = GF_TRANSPORT_TCP; + + this = THIS; + + enumerate_transport_reqs(volinfo->transport_type, types); + dict = dict_new(); + if (!dict) + goto out; + for (i = 0; types[i]; i++) { + ret = dict_set_str(dict, "client-transport-type", types[i]); + if (ret) + goto out; + type = transport_str_to_type(types[i]); - ret = glusterd_get_dummy_client_filepath (filepath, - volinfo, type); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, EINVAL, - GD_MSG_INVALID_ENTRY, - "Received invalid transport-type."); - goto out; - } + ret = dict_set_uint32(dict, "trusted-client", GF_CLIENT_OTHER); + if (ret) + goto out; - ret = generate_single_transport_client_volfile (volinfo, - filepath, - dict); - if (ret) - goto out; + ret = glusterd_get_dummy_client_filepath(filepath, volinfo, type); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, EINVAL, GD_MSG_INVALID_ENTRY, + "Received invalid transport-type."); + goto out; } + ret = generate_single_transport_client_volfile(volinfo, filepath, dict); + if (ret) + goto out; + } + out: - if (dict) - dict_unref (dict); + if (dict) + dict_unref(dict); - gf_msg_trace ("glusterd", 0, "Returning %d", ret); - return ret; + gf_msg_trace("glusterd", 0, "Returning %d", ret); + return ret; } int -generate_client_volfiles (glusterd_volinfo_t *volinfo, - glusterd_client_type_t client_type) -{ - int i = 0; - int ret = -1; - char filepath[PATH_MAX] = {0,}; - char *volname = NULL; - char *types[] = {NULL, NULL, NULL}; - dict_t *dict = NULL; - xlator_t *this = NULL; - gf_transport_type type = GF_TRANSPORT_TCP; - - this = THIS; - - volname = volinfo->is_snap_volume ? - volinfo->parent_volname : volinfo->volname; - +generate_client_volfiles(glusterd_volinfo_t *volinfo, + glusterd_client_type_t client_type) +{ + int i = 0; + int ret = -1; + char filepath[PATH_MAX] = { + 0, + }; + char *volname = NULL; + char *types[] = {NULL, NULL, NULL}; + dict_t *dict = NULL; + xlator_t *this = NULL; + gf_transport_type type = GF_TRANSPORT_TCP; + + this = THIS; + + volname = volinfo->is_snap_volume ? volinfo->parent_volname + : volinfo->volname; + + if (volname && !strcmp(volname, GLUSTER_SHARED_STORAGE) && + client_type != GF_CLIENT_TRUSTED) { + /* + * shared storage volume cannot be mounted from non trusted + * nodes. So we are not creating volfiles for non-trusted + * clients for shared volumes as well as snapshot of shared + * volumes. + */ - if (volname && !strcmp (volname, GLUSTER_SHARED_STORAGE) && - client_type != GF_CLIENT_TRUSTED) { - /* - * shared storage volume cannot be mounted from non trusted - * nodes. So we are not creating volfiles for non-trusted - * clients for shared volumes as well as snapshot of shared - * volumes. - */ + ret = 0; + gf_msg_debug("glusterd", 0, + "Skipping the non-trusted volfile" + "creation for shared storage volume. Volume %s", + volname); + goto out; + } + + enumerate_transport_reqs(volinfo->transport_type, types); + dict = dict_new(); + if (!dict) + goto out; + for (i = 0; types[i]; i++) { + ret = dict_set_str(dict, "client-transport-type", types[i]); + if (ret) + goto out; + type = transport_str_to_type(types[i]); - ret = 0; - gf_msg_debug ("glusterd", 0, "Skipping the non-trusted volfile" - "creation for shared storage volume. Volume %s", - volname); - goto out; + ret = dict_set_uint32(dict, "trusted-client", client_type); + if (ret) + goto out; + + if (client_type == GF_CLIENT_TRUSTED) { + ret = glusterd_get_trusted_client_filepath(filepath, volinfo, type); + } else if (client_type == GF_CLIENT_TRUSTED_PROXY) { + glusterd_get_gfproxy_client_volfile(volinfo, filepath, PATH_MAX); + ret = dict_set_int32n(dict, "gfproxy-client", + SLEN("gfproxy-client"), 1); + } else { + ret = glusterd_get_client_filepath(filepath, volinfo, type); } - - enumerate_transport_reqs (volinfo->transport_type, types); - dict = dict_new (); - if (!dict) - goto out; - for (i = 0; types[i]; i++) { - ret = dict_set_str (dict, "client-transport-type", types[i]); - if (ret) - goto out; - type = transport_str_to_type (types[i]); - - ret = dict_set_uint32 (dict, "trusted-client", client_type); - if (ret) - goto out; - - if (client_type == GF_CLIENT_TRUSTED) { - ret = glusterd_get_trusted_client_filepath (filepath, - volinfo, - type); - } else if (client_type == GF_CLIENT_TRUSTED_PROXY) { - glusterd_get_gfproxy_client_volfile (volinfo, - filepath, - PATH_MAX); - ret = dict_set_int32n (dict, "gfproxy-client", - SLEN ("gfproxy-client"), 1); - } else { - ret = glusterd_get_client_filepath (filepath, - volinfo, - type); - } - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, EINVAL, - GD_MSG_INVALID_ENTRY, - "Received invalid transport-type"); - goto out; - } - - ret = generate_single_transport_client_volfile (volinfo, - filepath, - dict); - if (ret) - goto out; + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, EINVAL, GD_MSG_INVALID_ENTRY, + "Received invalid transport-type"); + goto out; } - /* Generate volfile for rebalance process */ - glusterd_get_rebalance_volfile (volinfo, filepath, PATH_MAX); - ret = build_rebalance_volfile (volinfo, filepath, dict); + ret = generate_single_transport_client_volfile(volinfo, filepath, dict); + if (ret) + goto out; + } + /* Generate volfile for rebalance process */ + glusterd_get_rebalance_volfile(volinfo, filepath, PATH_MAX); + ret = build_rebalance_volfile(volinfo, filepath, dict); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - GD_MSG_VOLFILE_CREATE_FAIL, - "Failed to create rebalance volfile for %s", - volinfo->volname); - goto out; - } + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_VOLFILE_CREATE_FAIL, + "Failed to create rebalance volfile for %s", volinfo->volname); + goto out; + } out: - if (dict) - dict_unref (dict); + if (dict) + dict_unref(dict); - gf_msg_trace ("glusterd", 0, "Returning %d", ret); - return ret; + gf_msg_trace("glusterd", 0, "Returning %d", ret); + return ret; } int -glusterd_snapdsvc_generate_volfile (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo) -{ - xlator_t *xl = NULL; - char *username = NULL; - char *passwd = NULL; - int ret = 0; - char key [PATH_MAX] = {0, }; - dict_t *set_dict = NULL; - char *loglevel = NULL; - char *xlator = NULL; - char auth_path[] = "auth-path"; - char *ssl_str = NULL; - gf_boolean_t ssl_bool = _gf_false; - - set_dict = dict_copy (volinfo->dict, NULL); - if (!set_dict) - return -1; +glusterd_snapdsvc_generate_volfile(volgen_graph_t *graph, + glusterd_volinfo_t *volinfo) +{ + xlator_t *xl = NULL; + char *username = NULL; + char *passwd = NULL; + int ret = 0; + char key[PATH_MAX] = { + 0, + }; + dict_t *set_dict = NULL; + char *loglevel = NULL; + char *xlator = NULL; + char auth_path[] = "auth-path"; + char *ssl_str = NULL; + gf_boolean_t ssl_bool = _gf_false; + + set_dict = dict_copy(volinfo->dict, NULL); + if (!set_dict) + return -1; - ret = dict_get_str (set_dict, "xlator", &xlator); - if (!ret) { - ret = dict_get_str (set_dict, "loglevel", &loglevel); - if (ret) { - gf_msg ("glusterd", GF_LOG_ERROR, errno, - GD_MSG_DICT_GET_FAILED, "could not get both" - " translator name and loglevel for log level " - "request"); - return -1; - } + ret = dict_get_str(set_dict, "xlator", &xlator); + if (!ret) { + ret = dict_get_str(set_dict, "loglevel", &loglevel); + if (ret) { + gf_msg("glusterd", GF_LOG_ERROR, errno, GD_MSG_DICT_GET_FAILED, + "could not get both" + " translator name and loglevel for log level " + "request"); + return -1; } + } - xl = volgen_graph_add (graph, "features/snapview-server", - volinfo->volname); - if (!xl) - return -1; + xl = volgen_graph_add(graph, "features/snapview-server", volinfo->volname); + if (!xl) + return -1; - ret = xlator_set_option (xl, "volname", volinfo->volname); - if (ret) - return -1; + ret = xlator_set_option(xl, "volname", volinfo->volname); + if (ret) + return -1; - xl = volgen_graph_add (graph, "performance/io-threads", - volinfo->volname); - if (!xl) - return -1; + xl = volgen_graph_add(graph, "performance/io-threads", volinfo->volname); + if (!xl) + return -1; - snprintf (key, sizeof (key), "snapd-%s", volinfo->volname); - xl = volgen_graph_add_as (graph, "debug/io-stats", key); - if (!xl) - return -1; + snprintf(key, sizeof(key), "snapd-%s", volinfo->volname); + xl = volgen_graph_add_as(graph, "debug/io-stats", key); + if (!xl) + return -1; - xl = volgen_graph_add (graph, "protocol/server", volinfo->volname); - if (!xl) - return -1; + xl = volgen_graph_add(graph, "protocol/server", volinfo->volname); + if (!xl) + return -1; - ret = xlator_set_option (xl, "transport-type", "tcp"); - if (ret) - return -1; + ret = xlator_set_option(xl, "transport-type", "tcp"); + if (ret) + return -1; - if (dict_get_str (set_dict, "server.ssl", &ssl_str) == 0) { - if (gf_string2boolean (ssl_str, &ssl_bool) == 0) { - if (ssl_bool) { - ret = xlator_set_option(xl, - "transport.socket.ssl-enabled", + if (dict_get_str(set_dict, "server.ssl", &ssl_str) == 0) { + if (gf_string2boolean(ssl_str, &ssl_bool) == 0) { + if (ssl_bool) { + ret = xlator_set_option(xl, "transport.socket.ssl-enabled", "true"); - if (ret) { - return -1; - } - } + if (ret) { + return -1; } + } } + } - RPC_SET_OPT(xl, SSL_OWN_CERT_OPT, "ssl-own-cert", return -1); - RPC_SET_OPT(xl, SSL_PRIVATE_KEY_OPT,"ssl-private-key", return -1); - RPC_SET_OPT(xl, SSL_CA_LIST_OPT, "ssl-ca-list", return -1); - RPC_SET_OPT(xl, SSL_CRL_PATH_OPT, "ssl-crl-path", return -1); - RPC_SET_OPT(xl, SSL_CERT_DEPTH_OPT, "ssl-cert-depth", return -1); - RPC_SET_OPT(xl, SSL_CIPHER_LIST_OPT,"ssl-cipher-list", return -1); - RPC_SET_OPT(xl, SSL_DH_PARAM_OPT, "ssl-dh-param", return -1); - RPC_SET_OPT(xl, SSL_EC_CURVE_OPT, "ssl-ec-curve", return -1); - - username = glusterd_auth_get_username (volinfo); - passwd = glusterd_auth_get_password (volinfo); - - snprintf (key, sizeof (key), "auth.login.snapd-%s.allow", - volinfo->volname); - ret = xlator_set_option (xl, key, username); - if (ret) - return -1; + RPC_SET_OPT(xl, SSL_OWN_CERT_OPT, "ssl-own-cert", return -1); + RPC_SET_OPT(xl, SSL_PRIVATE_KEY_OPT, "ssl-private-key", return -1); + RPC_SET_OPT(xl, SSL_CA_LIST_OPT, "ssl-ca-list", return -1); + RPC_SET_OPT(xl, SSL_CRL_PATH_OPT, "ssl-crl-path", return -1); + RPC_SET_OPT(xl, SSL_CERT_DEPTH_OPT, "ssl-cert-depth", return -1); + RPC_SET_OPT(xl, SSL_CIPHER_LIST_OPT, "ssl-cipher-list", return -1); + RPC_SET_OPT(xl, SSL_DH_PARAM_OPT, "ssl-dh-param", return -1); + RPC_SET_OPT(xl, SSL_EC_CURVE_OPT, "ssl-ec-curve", return -1); - snprintf (key, sizeof (key), "auth.login.%s.password", username); - ret = xlator_set_option (xl, key, passwd); - if (ret) - return -1; + username = glusterd_auth_get_username(volinfo); + passwd = glusterd_auth_get_password(volinfo); - snprintf (key, sizeof (key), "snapd-%s", volinfo->volname); - ret = xlator_set_option (xl, auth_path, key); - if (ret) - return -1; + snprintf(key, sizeof(key), "auth.login.snapd-%s.allow", volinfo->volname); + ret = xlator_set_option(xl, key, username); + if (ret) + return -1; + + snprintf(key, sizeof(key), "auth.login.%s.password", username); + ret = xlator_set_option(xl, key, passwd); + if (ret) + return -1; + + snprintf(key, sizeof(key), "snapd-%s", volinfo->volname); + ret = xlator_set_option(xl, auth_path, key); + if (ret) + return -1; - ret = volgen_graph_set_options_generic - (graph, set_dict, - (xlator && loglevel)? (void *)set_dict: volinfo, - (xlator && loglevel) ? - &server_spec_extended_option_handler: - &server_spec_option_handler); + ret = volgen_graph_set_options_generic( + graph, set_dict, (xlator && loglevel) ? (void *)set_dict : volinfo, + (xlator && loglevel) ? &server_spec_extended_option_handler + : &server_spec_option_handler); - return ret; + return ret; } static int -prepare_bitrot_scrub_volume_options (glusterd_volinfo_t *volinfo, - dict_t *mod_dict, dict_t *set_dict) +prepare_bitrot_scrub_volume_options(glusterd_volinfo_t *volinfo, + dict_t *mod_dict, dict_t *set_dict) { - int ret = 0; + int ret = 0; + ret = dict_set_uint32(set_dict, "trusted-client", GF_CLIENT_TRUSTED); + if (ret) + goto out; - ret = dict_set_uint32 (set_dict, "trusted-client", GF_CLIENT_TRUSTED); - if (ret) - goto out; - - dict_copy (volinfo->dict, set_dict); - if (mod_dict) - dict_copy (mod_dict, set_dict); + dict_copy(volinfo->dict, set_dict); + if (mod_dict) + dict_copy(mod_dict, set_dict); out: - return ret; + return ret; } static int -build_bitd_clusters (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, int brick_count, unsigned int numbricks) +build_bitd_clusters(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, int brick_count, unsigned int numbricks) { - int ret = -1; - int clusters = 0; - xlator_t *xl = NULL; - char *brick_hint = NULL; - char *bitrot_args[] = {"features/bit-rot", - "%s-bit-rot-%d"}; + int ret = -1; + int clusters = 0; + xlator_t *xl = NULL; + char *brick_hint = NULL; + char *bitrot_args[] = {"features/bit-rot", "%s-bit-rot-%d"}; - ret = volgen_link_bricks_from_list_tail (graph, volinfo, bitrot_args[0], - bitrot_args[1], brick_count, - brick_count); - clusters = ret; + ret = volgen_link_bricks_from_list_tail(graph, volinfo, bitrot_args[0], + bitrot_args[1], brick_count, + brick_count); + clusters = ret; - xl = first_of (graph); + xl = first_of(graph); - ret = gf_asprintf (&brick_hint, "%d", numbricks); - if (ret < 0) - goto out; + ret = gf_asprintf(&brick_hint, "%d", numbricks); + if (ret < 0) + goto out; - ret = xlator_set_option (xl, "brick-count", brick_hint); - if (ret) - goto out; + ret = xlator_set_option(xl, "brick-count", brick_hint); + if (ret) + goto out; - ret = clusters; + ret = clusters; out: - GF_FREE (brick_hint); - brick_hint = NULL; - return ret; + GF_FREE(brick_hint); + brick_hint = NULL; + return ret; } static int -build_bitd_volume_graph (volgen_graph_t *graph, - glusterd_volinfo_t *volinfo, dict_t *mod_dict, - unsigned int numbricks) -{ - volgen_graph_t cgraph = {0}; - xlator_t *this = NULL; - xlator_t *xl = NULL; - dict_t *set_dict = NULL; - glusterd_conf_t *priv = NULL; - int ret = 0; - int clusters = -1; - glusterd_brickinfo_t *brickinfo = NULL; - int brick_count = 0; - char transt[16] = {0,}; - - this = THIS; - GF_ASSERT (this); - - priv = this->private; - GF_ASSERT (priv); - - set_dict = dict_new (); - if (!set_dict) { - ret = -1; - goto out; - } +build_bitd_volume_graph(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *mod_dict, unsigned int numbricks) +{ + volgen_graph_t cgraph = {0}; + xlator_t *this = NULL; + xlator_t *xl = NULL; + dict_t *set_dict = NULL; + glusterd_conf_t *priv = NULL; + int ret = 0; + int clusters = -1; + glusterd_brickinfo_t *brickinfo = NULL; + int brick_count = 0; + char transt[16] = { + 0, + }; + + this = THIS; + GF_ASSERT(this); + + priv = this->private; + GF_ASSERT(priv); + + set_dict = dict_new(); + if (!set_dict) { + ret = -1; + goto out; + } - ret = prepare_bitrot_scrub_volume_options (volinfo, mod_dict, set_dict); - if (ret) - goto out; + ret = prepare_bitrot_scrub_volume_options(volinfo, mod_dict, set_dict); + if (ret) + goto out; - get_transport_type (volinfo, set_dict, transt, _gf_false); - if (!strncmp (transt, "tcp,rdma", SLEN ("tcp,rdma"))) - strncpy (transt, "tcp", sizeof(transt)); - - cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { - if (!glusterd_is_local_brick (this, volinfo, brickinfo)) - continue; - - xl = volgen_graph_build_client (&cgraph, volinfo, - brickinfo->hostname, - NULL, - brickinfo->path, - brickinfo->brick_id, - transt, set_dict); - if (!xl) { - ret = -1; - goto out; - } - brick_count++; - } + get_transport_type(volinfo, set_dict, transt, _gf_false); + if (!strncmp(transt, "tcp,rdma", SLEN("tcp,rdma"))) + strncpy(transt, "tcp", sizeof(transt)); - if (brick_count == 0) { - ret = 0; - goto out; - } + cds_list_for_each_entry(brickinfo, &volinfo->bricks, brick_list) + { + if (!glusterd_is_local_brick(this, volinfo, brickinfo)) + continue; - clusters = build_bitd_clusters (&cgraph, volinfo, set_dict, brick_count, - numbricks); - if (clusters < 0) { - ret = -1; - goto out; + xl = volgen_graph_build_client(&cgraph, volinfo, brickinfo->hostname, + NULL, brickinfo->path, + brickinfo->brick_id, transt, set_dict); + if (!xl) { + ret = -1; + goto out; } + brick_count++; + } - ret = volgen_graph_set_options_generic (&cgraph, set_dict, - volinfo, - bitrot_option_handler); - if (ret) - goto out; + if (brick_count == 0) { + ret = 0; + goto out; + } - ret = volgen_graph_merge_sub (graph, &cgraph, clusters); - if (ret) - goto out; + clusters = build_bitd_clusters(&cgraph, volinfo, set_dict, brick_count, + numbricks); + if (clusters < 0) { + ret = -1; + goto out; + } + + ret = volgen_graph_set_options_generic(&cgraph, set_dict, volinfo, + bitrot_option_handler); + if (ret) + goto out; - ret = graph_set_generic_options (this, graph, set_dict, "Bitrot"); + ret = volgen_graph_merge_sub(graph, &cgraph, clusters); + if (ret) + goto out; + + ret = graph_set_generic_options(this, graph, set_dict, "Bitrot"); out: - if (set_dict) - dict_unref (set_dict); + if (set_dict) + dict_unref(set_dict); - return ret; + return ret; } int -build_bitd_graph (volgen_graph_t *graph, dict_t *mod_dict) -{ - glusterd_volinfo_t *voliter = NULL; - xlator_t *this = NULL; - glusterd_conf_t *priv = NULL; - int ret = 0; - xlator_t *iostxl = NULL; - glusterd_brickinfo_t *brickinfo = NULL; - unsigned int numbricks = 0; - - this = THIS; - GF_ASSERT (this); - priv = this->private; - GF_ASSERT (priv); - - iostxl = volgen_graph_add_as (graph, "debug/io-stats", "bitd"); - if (!iostxl) { - ret = -1; - goto out; - } - - /* TODO: do way with this extra loop _if possible_ */ - cds_list_for_each_entry (voliter, &priv->volumes, vol_list) { - if (voliter->status != GLUSTERD_STATUS_STARTED) - continue; - if (!glusterd_is_bitrot_enabled (voliter)) - continue; - - cds_list_for_each_entry (brickinfo, - &voliter->bricks, brick_list) { - if (!glusterd_is_local_brick (this, voliter, brickinfo)) - continue; - numbricks++; - } +build_bitd_graph(volgen_graph_t *graph, dict_t *mod_dict) +{ + glusterd_volinfo_t *voliter = NULL; + xlator_t *this = NULL; + glusterd_conf_t *priv = NULL; + int ret = 0; + xlator_t *iostxl = NULL; + glusterd_brickinfo_t *brickinfo = NULL; + unsigned int numbricks = 0; + + this = THIS; + GF_ASSERT(this); + priv = this->private; + GF_ASSERT(priv); + + iostxl = volgen_graph_add_as(graph, "debug/io-stats", "bitd"); + if (!iostxl) { + ret = -1; + goto out; + } + + /* TODO: do way with this extra loop _if possible_ */ + cds_list_for_each_entry(voliter, &priv->volumes, vol_list) + { + if (voliter->status != GLUSTERD_STATUS_STARTED) + continue; + if (!glusterd_is_bitrot_enabled(voliter)) + continue; + + cds_list_for_each_entry(brickinfo, &voliter->bricks, brick_list) + { + if (!glusterd_is_local_brick(this, voliter, brickinfo)) + continue; + numbricks++; } + } - cds_list_for_each_entry (voliter, &priv->volumes, vol_list) { - if (voliter->status != GLUSTERD_STATUS_STARTED) - continue; + cds_list_for_each_entry(voliter, &priv->volumes, vol_list) + { + if (voliter->status != GLUSTERD_STATUS_STARTED) + continue; - if (!glusterd_is_bitrot_enabled (voliter)) - continue; + if (!glusterd_is_bitrot_enabled(voliter)) + continue; - ret = build_bitd_volume_graph (graph, voliter, - mod_dict, numbricks); - } + ret = build_bitd_volume_graph(graph, voliter, mod_dict, numbricks); + } out: - return ret; + return ret; } static int -build_scrub_clusters (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *set_dict, int brick_count) +build_scrub_clusters(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, int brick_count) { - int ret = -1; - int clusters = 0; - xlator_t *xl = NULL; - char *scrub_args[] = {"features/bit-rot", - "%s-bit-rot-%d"}; + int ret = -1; + int clusters = 0; + xlator_t *xl = NULL; + char *scrub_args[] = {"features/bit-rot", "%s-bit-rot-%d"}; - ret = volgen_link_bricks_from_list_tail (graph, volinfo, scrub_args[0], - scrub_args[1], brick_count, - brick_count); - clusters = ret; + ret = volgen_link_bricks_from_list_tail( + graph, volinfo, scrub_args[0], scrub_args[1], brick_count, brick_count); + clusters = ret; - xl = first_of (graph); + xl = first_of(graph); + ret = xlator_set_option(xl, "scrubber", "true"); + if (ret) + goto out; - ret = xlator_set_option (xl, "scrubber", "true"); - if (ret) - goto out; - - ret = clusters; + ret = clusters; out: - return ret; + return ret; } static int -build_scrub_volume_graph (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, - dict_t *mod_dict) -{ - volgen_graph_t cgraph = {0}; - dict_t *set_dict = NULL; - xlator_t *this = NULL; - xlator_t *xl = NULL; - glusterd_conf_t *priv = NULL; - int ret = 0; - int clusters = -1; - int brick_count = 0; - char transt[16] = {0,}; - glusterd_brickinfo_t *brickinfo = NULL; - - this = THIS; - GF_ASSERT (this); - - priv = this->private; - GF_ASSERT (priv); - - set_dict = dict_new (); - if (!set_dict) { - ret = -1; - goto out; - } +build_scrub_volume_graph(volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *mod_dict) +{ + volgen_graph_t cgraph = {0}; + dict_t *set_dict = NULL; + xlator_t *this = NULL; + xlator_t *xl = NULL; + glusterd_conf_t *priv = NULL; + int ret = 0; + int clusters = -1; + int brick_count = 0; + char transt[16] = { + 0, + }; + glusterd_brickinfo_t *brickinfo = NULL; + + this = THIS; + GF_ASSERT(this); + + priv = this->private; + GF_ASSERT(priv); + + set_dict = dict_new(); + if (!set_dict) { + ret = -1; + goto out; + } - ret = prepare_bitrot_scrub_volume_options (volinfo, mod_dict, set_dict); - if (ret) - goto out; + ret = prepare_bitrot_scrub_volume_options(volinfo, mod_dict, set_dict); + if (ret) + goto out; - get_transport_type (volinfo, set_dict, transt, _gf_false); - if (!strncmp (transt, "tcp,rdma", SLEN ("tcp,rdma"))) - strncpy (transt, "tcp", sizeof(transt)); - - cds_list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { - if (!glusterd_is_local_brick (this, volinfo, brickinfo)) - continue; - - xl = volgen_graph_build_client (&cgraph, volinfo, - brickinfo->hostname, - NULL, - brickinfo->path, - brickinfo->brick_id, - transt, set_dict); - if (!xl) { - ret = -1; - goto out; - } - brick_count++; - } + get_transport_type(volinfo, set_dict, transt, _gf_false); + if (!strncmp(transt, "tcp,rdma", SLEN("tcp,rdma"))) + strncpy(transt, "tcp", sizeof(transt)); - if (brick_count == 0) { - ret = 0; - goto out; - } + cds_list_for_each_entry(brickinfo, &volinfo->bricks, brick_list) + { + if (!glusterd_is_local_brick(this, volinfo, brickinfo)) + continue; - clusters = build_scrub_clusters (&cgraph, volinfo, set_dict, - brick_count); - if (clusters < 0) { - ret = -1; - goto out; + xl = volgen_graph_build_client(&cgraph, volinfo, brickinfo->hostname, + NULL, brickinfo->path, + brickinfo->brick_id, transt, set_dict); + if (!xl) { + ret = -1; + goto out; } + brick_count++; + } - ret = volgen_graph_set_options_generic (&cgraph, set_dict, - volinfo, - scrubber_option_handler); - if (ret) - goto out; + if (brick_count == 0) { + ret = 0; + goto out; + } - ret = volgen_graph_merge_sub (graph, &cgraph, clusters); - if (ret) - goto out; + clusters = build_scrub_clusters(&cgraph, volinfo, set_dict, brick_count); + if (clusters < 0) { + ret = -1; + goto out; + } + + ret = volgen_graph_set_options_generic(&cgraph, set_dict, volinfo, + scrubber_option_handler); + if (ret) + goto out; - ret = graph_set_generic_options (this, graph, set_dict, "Scrubber"); + ret = volgen_graph_merge_sub(graph, &cgraph, clusters); + if (ret) + goto out; + + ret = graph_set_generic_options(this, graph, set_dict, "Scrubber"); out: - if (set_dict) - dict_unref (set_dict); + if (set_dict) + dict_unref(set_dict); - return ret; + return ret; } int -build_scrub_graph (volgen_graph_t *graph, dict_t *mod_dict) +build_scrub_graph(volgen_graph_t *graph, dict_t *mod_dict) { - glusterd_volinfo_t *voliter = NULL; - xlator_t *this = NULL; - glusterd_conf_t *priv = NULL; - int ret = 0; - xlator_t *iostxl = NULL; + glusterd_volinfo_t *voliter = NULL; + xlator_t *this = NULL; + glusterd_conf_t *priv = NULL; + int ret = 0; + xlator_t *iostxl = NULL; - this = THIS; - GF_ASSERT (this); - priv = this->private; - GF_ASSERT (priv); + this = THIS; + GF_ASSERT(this); + priv = this->private; + GF_ASSERT(priv); - iostxl = volgen_graph_add_as (graph, "debug/io-stats", "scrub"); - if (!iostxl) { - ret = -1; - goto out; - } + iostxl = volgen_graph_add_as(graph, "debug/io-stats", "scrub"); + if (!iostxl) { + ret = -1; + goto out; + } - cds_list_for_each_entry (voliter, &priv->volumes, vol_list) { - if (voliter->status != GLUSTERD_STATUS_STARTED) - continue; + cds_list_for_each_entry(voliter, &priv->volumes, vol_list) + { + if (voliter->status != GLUSTERD_STATUS_STARTED) + continue; - if (!glusterd_is_bitrot_enabled (voliter)) - continue; + if (!glusterd_is_bitrot_enabled(voliter)) + continue; - ret = build_scrub_volume_graph (graph, voliter, mod_dict); - } + ret = build_scrub_volume_graph(graph, voliter, mod_dict); + } out: - return ret; + return ret; } int -glusterd_snapdsvc_create_volfile (glusterd_volinfo_t *volinfo) +glusterd_snapdsvc_create_volfile(glusterd_volinfo_t *volinfo) { - volgen_graph_t graph = {0,}; - int ret = -1; - char filename [PATH_MAX] = {0,}; + volgen_graph_t graph = { + 0, + }; + int ret = -1; + char filename[PATH_MAX] = { + 0, + }; - graph.type = GF_SNAPD; - glusterd_svc_build_snapd_volfile (volinfo, filename, PATH_MAX); + graph.type = GF_SNAPD; + glusterd_svc_build_snapd_volfile(volinfo, filename, PATH_MAX); - ret = glusterd_snapdsvc_generate_volfile (&graph, volinfo); - if (!ret) - ret = volgen_write_volfile (&graph, filename); + ret = glusterd_snapdsvc_generate_volfile(&graph, volinfo); + if (!ret) + ret = volgen_write_volfile(&graph, filename); - volgen_graph_free (&graph); + volgen_graph_free(&graph); - return ret; + return ret; } int -glusterd_create_rb_volfiles (glusterd_volinfo_t *volinfo, - glusterd_brickinfo_t *brickinfo) +glusterd_create_rb_volfiles(glusterd_volinfo_t *volinfo, + glusterd_brickinfo_t *brickinfo) { - int ret = -1; + int ret = -1; - ret = glusterd_generate_brick_volfile (volinfo, brickinfo, NULL, NULL); - if (!ret) - ret = generate_client_volfiles (volinfo, GF_CLIENT_TRUSTED); - if (!ret) - ret = glusterd_fetchspec_notify (THIS); + ret = glusterd_generate_brick_volfile(volinfo, brickinfo, NULL, NULL); + if (!ret) + ret = generate_client_volfiles(volinfo, GF_CLIENT_TRUSTED); + if (!ret) + ret = glusterd_fetchspec_notify(THIS); - return ret; + return ret; } int -glusterd_create_volfiles (glusterd_volinfo_t *volinfo) +glusterd_create_volfiles(glusterd_volinfo_t *volinfo) { - int ret = -1; - xlator_t *this = NULL; + int ret = -1; + xlator_t *this = NULL; - this = THIS; + this = THIS; - ret = generate_brick_volfiles (volinfo); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - GD_MSG_VOLFILE_CREATE_FAIL, - "Could not generate volfiles for bricks"); - goto out; - } + ret = generate_brick_volfiles(volinfo); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_VOLFILE_CREATE_FAIL, + "Could not generate volfiles for bricks"); + goto out; + } - ret = generate_client_volfiles (volinfo, GF_CLIENT_TRUSTED); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, 0, - GD_MSG_VOLFILE_CREATE_FAIL, - "Could not generate trusted client volfiles"); - goto out; - } - - ret = generate_client_volfiles (volinfo, GF_CLIENT_TRUSTED_PROXY); - if (ret) { - gf_log (this->name, GF_LOG_ERROR, - "Could not generate gfproxy client volfiles"); - goto out; - } + ret = generate_client_volfiles(volinfo, GF_CLIENT_TRUSTED); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_VOLFILE_CREATE_FAIL, + "Could not generate trusted client volfiles"); + goto out; + } - ret = generate_client_volfiles (volinfo, GF_CLIENT_OTHER); - if (ret) - gf_msg (this->name, GF_LOG_ERROR, 0, - GD_MSG_VOLFILE_CREATE_FAIL, - "Could not generate client volfiles"); + ret = generate_client_volfiles(volinfo, GF_CLIENT_TRUSTED_PROXY); + if (ret) { + gf_log(this->name, GF_LOG_ERROR, + "Could not generate gfproxy client volfiles"); + goto out; + } + ret = generate_client_volfiles(volinfo, GF_CLIENT_OTHER); + if (ret) + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_VOLFILE_CREATE_FAIL, + "Could not generate client volfiles"); - ret = glusterd_generate_gfproxyd_volfile (volinfo); - if (ret) - gf_log (this->name, GF_LOG_ERROR, - "Could not generate gfproxy volfiles"); + ret = glusterd_generate_gfproxyd_volfile(volinfo); + if (ret) + gf_log(this->name, GF_LOG_ERROR, "Could not generate gfproxy volfiles"); - dict_del (volinfo->dict, "skip-CLIOT"); + dict_del(volinfo->dict, "skip-CLIOT"); out: - return ret; + return ret; } int -glusterd_create_volfiles_and_notify_services (glusterd_volinfo_t *volinfo) +glusterd_create_volfiles_and_notify_services(glusterd_volinfo_t *volinfo) { - int ret = -1; - xlator_t *this = NULL; + int ret = -1; + xlator_t *this = NULL; - this = THIS; + this = THIS; - ret = glusterd_create_volfiles (volinfo); - if (ret) - goto out; + ret = glusterd_create_volfiles(volinfo); + if (ret) + goto out; - ret = glusterd_fetchspec_notify (this); + ret = glusterd_fetchspec_notify(this); out: - return ret; + return ret; } int -glusterd_create_global_volfile (glusterd_graph_builder_t builder, - char *filepath, dict_t *mod_dict) +glusterd_create_global_volfile(glusterd_graph_builder_t builder, char *filepath, + dict_t *mod_dict) { - volgen_graph_t graph = {0,}; - int ret = -1; + volgen_graph_t graph = { + 0, + }; + int ret = -1; - ret = builder (&graph, mod_dict); - if (!ret) - ret = volgen_write_volfile (&graph, filepath); + ret = builder(&graph, mod_dict); + if (!ret) + ret = volgen_write_volfile(&graph, filepath); - volgen_graph_free (&graph); + volgen_graph_free(&graph); - return ret; + return ret; } int -glusterd_delete_volfile (glusterd_volinfo_t *volinfo, - glusterd_brickinfo_t *brickinfo) +glusterd_delete_volfile(glusterd_volinfo_t *volinfo, + glusterd_brickinfo_t *brickinfo) { - int ret = 0; - char filename[PATH_MAX] = {0,}; + int ret = 0; + char filename[PATH_MAX] = { + 0, + }; - GF_ASSERT (volinfo); - GF_ASSERT (brickinfo); + GF_ASSERT(volinfo); + GF_ASSERT(brickinfo); - get_brick_filepath (filename, volinfo, brickinfo, NULL); - ret = sys_unlink (filename); - if (ret) - gf_msg ("glusterd", GF_LOG_ERROR, errno, - GD_MSG_FILE_OP_FAILED, - "failed to delete file: %s", - filename); - return ret; + get_brick_filepath(filename, volinfo, brickinfo, NULL); + ret = sys_unlink(filename); + if (ret) + gf_msg("glusterd", GF_LOG_ERROR, errno, GD_MSG_FILE_OP_FAILED, + "failed to delete file: %s", filename); + return ret; } int -validate_shdopts (glusterd_volinfo_t *volinfo, - dict_t *val_dict, - char **op_errstr) +validate_shdopts(glusterd_volinfo_t *volinfo, dict_t *val_dict, + char **op_errstr) { - volgen_graph_t graph = {0,}; - int ret = -1; + volgen_graph_t graph = { + 0, + }; + int ret = -1; - graph.errstr = op_errstr; + graph.errstr = op_errstr; - if (!glusterd_is_shd_compatible_volume (volinfo)) { - ret = 0; - goto out; - } - ret = dict_set_int32n (val_dict, "graph-check", - SLEN ("graph-check"), 1); - if (ret) - goto out; - ret = build_shd_graph (&graph, val_dict); - if (!ret) - ret = graph_reconf_validateopt (&graph.graph, op_errstr); - - volgen_graph_free (&graph); - - gf_msg_debug ("glusterd", 0, "Returning %d", ret); + if (!glusterd_is_shd_compatible_volume(volinfo)) { + ret = 0; + goto out; + } + ret = dict_set_int32n(val_dict, "graph-check", SLEN("graph-check"), 1); + if (ret) + goto out; + ret = build_shd_graph(&graph, val_dict); + if (!ret) + ret = graph_reconf_validateopt(&graph.graph, op_errstr); + + volgen_graph_free(&graph); + + gf_msg_debug("glusterd", 0, "Returning %d", ret); out: - dict_deln (val_dict, "graph-check", SLEN ("graph-check")); - return ret; + dict_deln(val_dict, "graph-check", SLEN("graph-check")); + return ret; } int -validate_nfsopts (glusterd_volinfo_t *volinfo, - dict_t *val_dict, - char **op_errstr) -{ - volgen_graph_t graph = {0,}; - int ret = -1; - char transport_type[16] = {0,}; - char *tt = NULL; - char err_str[128] = {0,}; - xlator_t *this = THIS; - - GF_ASSERT (this); - - graph.errstr = op_errstr; - - get_vol_transport_type (volinfo, transport_type); - ret = dict_get_str (val_dict, "nfs.transport-type", &tt); - if (!ret) { - if (volinfo->transport_type != GF_TRANSPORT_BOTH_TCP_RDMA) { - snprintf (err_str, sizeof (err_str), "Changing nfs " - "transport type is allowed only for volumes " - "of transport type tcp,rdma"); - gf_msg (this->name, GF_LOG_ERROR, 0, - GD_MSG_OP_UNSUPPORTED, "%s", err_str); - *op_errstr = gf_strdup (err_str); - ret = -1; - goto out; - } - if (strcmp (tt,"tcp") && strcmp (tt,"rdma")) { - snprintf (err_str, sizeof (err_str), "wrong transport " - "type %s", tt); - *op_errstr = gf_strdup (err_str); - ret = -1; - goto out; - } - } - - ret = dict_set_str (val_dict, "volume-name", volinfo->volname); - if (ret) { - gf_msg (this->name, GF_LOG_ERROR, errno, - GD_MSG_DICT_SET_FAILED, "Failed to set volume name"); - goto out; - } - - ret = build_nfs_graph (&graph, val_dict); - if (!ret) - ret = graph_reconf_validateopt (&graph.graph, op_errstr); - - volgen_graph_free (&graph); +validate_nfsopts(glusterd_volinfo_t *volinfo, dict_t *val_dict, + char **op_errstr) +{ + volgen_graph_t graph = { + 0, + }; + int ret = -1; + char transport_type[16] = { + 0, + }; + char *tt = NULL; + char err_str[128] = { + 0, + }; + xlator_t *this = THIS; + + GF_ASSERT(this); + + graph.errstr = op_errstr; + + get_vol_transport_type(volinfo, transport_type); + ret = dict_get_str(val_dict, "nfs.transport-type", &tt); + if (!ret) { + if (volinfo->transport_type != GF_TRANSPORT_BOTH_TCP_RDMA) { + snprintf(err_str, sizeof(err_str), + "Changing nfs " + "transport type is allowed only for volumes " + "of transport type tcp,rdma"); + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_OP_UNSUPPORTED, "%s", + err_str); + *op_errstr = gf_strdup(err_str); + ret = -1; + goto out; + } + if (strcmp(tt, "tcp") && strcmp(tt, "rdma")) { + snprintf(err_str, sizeof(err_str), + "wrong transport " + "type %s", + tt); + *op_errstr = gf_strdup(err_str); + ret = -1; + goto out; + } + } + + ret = dict_set_str(val_dict, "volume-name", volinfo->volname); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_SET_FAILED, + "Failed to set volume name"); + goto out; + } + + ret = build_nfs_graph(&graph, val_dict); + if (!ret) + ret = graph_reconf_validateopt(&graph.graph, op_errstr); + + volgen_graph_free(&graph); out: - if (dict_get (val_dict, "volume-name")) - dict_del (val_dict, "volume-name"); - gf_msg_debug (this->name, 0, "Returning %d", ret); - return ret; + if (dict_get(val_dict, "volume-name")) + dict_del(val_dict, "volume-name"); + gf_msg_debug(this->name, 0, "Returning %d", ret); + return ret; } - int -validate_clientopts (glusterd_volinfo_t *volinfo, - dict_t *val_dict, - char **op_errstr) +validate_clientopts(glusterd_volinfo_t *volinfo, dict_t *val_dict, + char **op_errstr) { - volgen_graph_t graph = {0,}; - int ret = -1; + volgen_graph_t graph = { + 0, + }; + int ret = -1; - GF_ASSERT (volinfo); + GF_ASSERT(volinfo); - graph.errstr = op_errstr; + graph.errstr = op_errstr; - ret = build_client_graph (&graph, volinfo, val_dict); - if (!ret) - ret = graph_reconf_validateopt (&graph.graph, op_errstr); + ret = build_client_graph(&graph, volinfo, val_dict); + if (!ret) + ret = graph_reconf_validateopt(&graph.graph, op_errstr); - volgen_graph_free (&graph); + volgen_graph_free(&graph); - gf_msg_debug ("glusterd", 0, "Returning %d", ret); - return ret; + gf_msg_debug("glusterd", 0, "Returning %d", ret); + return ret; } int -validate_brickopts (glusterd_volinfo_t *volinfo, - glusterd_brickinfo_t *brickinfo, dict_t *mod_dict, - void *reconf) -{ - volgen_graph_t graph = {0,}; - int ret = -1; - struct gd_validate_reconf_opts *brickreconf = reconf; - dict_t *val_dict = brickreconf->options; - char **op_errstr = brickreconf->op_errstr; - dict_t *full_dict = NULL; - - GF_ASSERT (volinfo); - - graph.errstr = op_errstr; - full_dict = dict_new(); - if (!full_dict) { - ret = -1; - goto out; - } - - if (mod_dict) - dict_copy (mod_dict, full_dict); +validate_brickopts(glusterd_volinfo_t *volinfo, glusterd_brickinfo_t *brickinfo, + dict_t *mod_dict, void *reconf) +{ + volgen_graph_t graph = { + 0, + }; + int ret = -1; + struct gd_validate_reconf_opts *brickreconf = reconf; + dict_t *val_dict = brickreconf->options; + char **op_errstr = brickreconf->op_errstr; + dict_t *full_dict = NULL; + + GF_ASSERT(volinfo); + + graph.errstr = op_errstr; + full_dict = dict_new(); + if (!full_dict) { + ret = -1; + goto out; + } - if (val_dict) - dict_copy (val_dict, full_dict); + if (mod_dict) + dict_copy(mod_dict, full_dict); + if (val_dict) + dict_copy(val_dict, full_dict); - ret = build_server_graph (&graph, volinfo, full_dict, brickinfo); - if (!ret) - ret = graph_reconf_validateopt (&graph.graph, op_errstr); + ret = build_server_graph(&graph, volinfo, full_dict, brickinfo); + if (!ret) + ret = graph_reconf_validateopt(&graph.graph, op_errstr); - volgen_graph_free (&graph); + volgen_graph_free(&graph); out: - if (full_dict) - dict_unref (full_dict); + if (full_dict) + dict_unref(full_dict); - gf_msg_debug ("glusterd", 0, "Returning %d", ret); - return ret; + gf_msg_debug("glusterd", 0, "Returning %d", ret); + return ret; } int -glusterd_validate_brickreconf (glusterd_volinfo_t *volinfo, - dict_t *val_dict, - char **op_errstr) +glusterd_validate_brickreconf(glusterd_volinfo_t *volinfo, dict_t *val_dict, + char **op_errstr) { - int ret = -1; - struct gd_validate_reconf_opts brickreconf = {0}; + int ret = -1; + struct gd_validate_reconf_opts brickreconf = {0}; - brickreconf.options = val_dict; - brickreconf.op_errstr = op_errstr; - ret = glusterd_volume_brick_for_each (volinfo, &brickreconf, - validate_brickopts); - return ret; + brickreconf.options = val_dict; + brickreconf.op_errstr = op_errstr; + ret = glusterd_volume_brick_for_each(volinfo, &brickreconf, + validate_brickopts); + return ret; } static int -_check_globalopt (dict_t *this, char *key, data_t *value, void *ret_val) +_check_globalopt(dict_t *this, char *key, data_t *value, void *ret_val) { - int *ret = NULL; - - ret = ret_val; - if (*ret) - return 0; - if (!glusterd_check_globaloption (key)) - *ret = 1; + int *ret = NULL; + ret = ret_val; + if (*ret) return 0; + if (!glusterd_check_globaloption(key)) + *ret = 1; + + return 0; } int -glusterd_validate_globalopts (glusterd_volinfo_t *volinfo, - dict_t *val_dict, char **op_errstr) +glusterd_validate_globalopts(glusterd_volinfo_t *volinfo, dict_t *val_dict, + char **op_errstr) { - int ret = 0; + int ret = 0; - dict_foreach (val_dict, _check_globalopt, &ret); - if (ret) { - *op_errstr = gf_strdup ( "option specified is not a global option"); - return -1; - } - ret = glusterd_validate_brickreconf (volinfo, val_dict, op_errstr); - - if (ret) { - gf_msg_debug ("glusterd", 0, - "Could not Validate bricks"); - goto out; - } - - ret = validate_clientopts (volinfo, val_dict, op_errstr); - if (ret) { - gf_msg_debug ("glusterd", 0, - "Could not Validate client"); - goto out; - } - - ret = validate_nfsopts (volinfo, val_dict, op_errstr); - if (ret) { - gf_msg_debug ("glusterd", 0, "Could not Validate nfs"); - goto out; - } - - ret = validate_shdopts (volinfo, val_dict, op_errstr); - if (ret) { - gf_msg_debug ("glusterd", 0, "Could not Validate self-heald"); - goto out; - } + dict_foreach(val_dict, _check_globalopt, &ret); + if (ret) { + *op_errstr = gf_strdup("option specified is not a global option"); + return -1; + } + ret = glusterd_validate_brickreconf(volinfo, val_dict, op_errstr); + + if (ret) { + gf_msg_debug("glusterd", 0, "Could not Validate bricks"); + goto out; + } + + ret = validate_clientopts(volinfo, val_dict, op_errstr); + if (ret) { + gf_msg_debug("glusterd", 0, "Could not Validate client"); + goto out; + } + + ret = validate_nfsopts(volinfo, val_dict, op_errstr); + if (ret) { + gf_msg_debug("glusterd", 0, "Could not Validate nfs"); + goto out; + } + + ret = validate_shdopts(volinfo, val_dict, op_errstr); + if (ret) { + gf_msg_debug("glusterd", 0, "Could not Validate self-heald"); + goto out; + } out: - gf_msg_debug ("glusterd", 0, "Returning %d", ret); - return ret; + gf_msg_debug("glusterd", 0, "Returning %d", ret); + return ret; } static int -_check_localopt (dict_t *this, char *key, data_t *value, void *ret_val) +_check_localopt(dict_t *this, char *key, data_t *value, void *ret_val) { - int *ret = NULL; - - ret = ret_val; - if (*ret) - return 0; - if (!glusterd_check_localoption (key)) - *ret = 1; + int *ret = NULL; + ret = ret_val; + if (*ret) return 0; + if (!glusterd_check_localoption(key)) + *ret = 1; + + return 0; } int -glusterd_validate_reconfopts (glusterd_volinfo_t *volinfo, dict_t *val_dict, - char **op_errstr) +glusterd_validate_reconfopts(glusterd_volinfo_t *volinfo, dict_t *val_dict, + char **op_errstr) { - int ret = 0; - - dict_foreach (val_dict, _check_localopt, &ret); - if (ret) { - *op_errstr = gf_strdup ( "option specified is not a local option"); - return -1; - } - ret = glusterd_validate_brickreconf (volinfo, val_dict, op_errstr); - - if (ret) { - gf_msg_debug ("glusterd", 0, - "Could not Validate bricks"); - goto out; - } - - ret = validate_clientopts (volinfo, val_dict, op_errstr); - if (ret) { - gf_msg_debug ("glusterd", 0, - "Could not Validate client"); - goto out; - } - - ret = validate_nfsopts (volinfo, val_dict, op_errstr); - if (ret) { - gf_msg_debug ("glusterd", 0, "Could not Validate nfs"); - goto out; - } - - - ret = validate_shdopts (volinfo, val_dict, op_errstr); - if (ret) { - gf_msg_debug ("glusterd", 0, "Could not Validate self-heald"); - goto out; - } + int ret = 0; + dict_foreach(val_dict, _check_localopt, &ret); + if (ret) { + *op_errstr = gf_strdup("option specified is not a local option"); + return -1; + } + ret = glusterd_validate_brickreconf(volinfo, val_dict, op_errstr); + + if (ret) { + gf_msg_debug("glusterd", 0, "Could not Validate bricks"); + goto out; + } + + ret = validate_clientopts(volinfo, val_dict, op_errstr); + if (ret) { + gf_msg_debug("glusterd", 0, "Could not Validate client"); + goto out; + } + + ret = validate_nfsopts(volinfo, val_dict, op_errstr); + if (ret) { + gf_msg_debug("glusterd", 0, "Could not Validate nfs"); + goto out; + } + + ret = validate_shdopts(volinfo, val_dict, op_errstr); + if (ret) { + gf_msg_debug("glusterd", 0, "Could not Validate self-heald"); + goto out; + } out: - gf_msg_debug ("glusterd", 0, "Returning %d", ret); - return ret; + gf_msg_debug("glusterd", 0, "Returning %d", ret); + return ret; } static struct volopt_map_entry * -_gd_get_vmep (char *key) { - char *completion = NULL; - struct volopt_map_entry *vmep = NULL; - int ret = 0; - - COMPLETE_OPTION ((char *)key, completion, ret); - for (vmep = glusterd_volopt_map; vmep->key; vmep++) { - if (strcmp (vmep->key, key) == 0) - return vmep; - } +_gd_get_vmep(char *key) +{ + char *completion = NULL; + struct volopt_map_entry *vmep = NULL; + int ret = 0; - return NULL; + COMPLETE_OPTION((char *)key, completion, ret); + for (vmep = glusterd_volopt_map; vmep->key; vmep++) { + if (strcmp(vmep->key, key) == 0) + return vmep; + } + + return NULL; } uint32_t -glusterd_get_op_version_for_key (char *key) +glusterd_get_op_version_for_key(char *key) { - struct volopt_map_entry *vmep = NULL; + struct volopt_map_entry *vmep = NULL; - GF_ASSERT (key); + GF_ASSERT(key); - vmep = _gd_get_vmep (key); - if (vmep) - return vmep->op_version; + vmep = _gd_get_vmep(key); + if (vmep) + return vmep->op_version; - return 0; + return 0; } gf_boolean_t -gd_is_client_option (char *key) +gd_is_client_option(char *key) { - struct volopt_map_entry *vmep = NULL; + struct volopt_map_entry *vmep = NULL; - GF_ASSERT (key); + GF_ASSERT(key); - vmep = _gd_get_vmep (key); - if (vmep && (vmep->flags & VOLOPT_FLAG_CLIENT_OPT)) - return _gf_true; + vmep = _gd_get_vmep(key); + if (vmep && (vmep->flags & VOLOPT_FLAG_CLIENT_OPT)) + return _gf_true; - return _gf_false; + return _gf_false; } gf_boolean_t -gd_is_xlator_option (char *key) +gd_is_xlator_option(char *key) { - struct volopt_map_entry *vmep = NULL; + struct volopt_map_entry *vmep = NULL; - GF_ASSERT (key); + GF_ASSERT(key); - vmep = _gd_get_vmep (key); - if (vmep && (vmep->flags & VOLOPT_FLAG_XLATOR_OPT)) - return _gf_true; + vmep = _gd_get_vmep(key); + if (vmep && (vmep->flags & VOLOPT_FLAG_XLATOR_OPT)) + return _gf_true; - return _gf_false; + return _gf_false; } volume_option_type_t -_gd_get_option_type (char *key) +_gd_get_option_type(char *key) { - struct volopt_map_entry *vmep = NULL; - void *dl_handle = NULL; - volume_opt_list_t vol_opt_list = {{0},}; - int ret = -1; - volume_option_t *opt = NULL; - char *xlopt_key = NULL; - volume_option_type_t opt_type = GF_OPTION_TYPE_MAX; + struct volopt_map_entry *vmep = NULL; + void *dl_handle = NULL; + volume_opt_list_t vol_opt_list = { + {0}, + }; + int ret = -1; + volume_option_t *opt = NULL; + char *xlopt_key = NULL; + volume_option_type_t opt_type = GF_OPTION_TYPE_MAX; - GF_ASSERT (key); + GF_ASSERT(key); - vmep = _gd_get_vmep (key); + vmep = _gd_get_vmep(key); - if (vmep) { - CDS_INIT_LIST_HEAD (&vol_opt_list.list); - ret = xlator_volopt_dynload (vmep->voltype, &dl_handle, - &vol_opt_list); - if (ret) - goto out; + if (vmep) { + CDS_INIT_LIST_HEAD(&vol_opt_list.list); + ret = xlator_volopt_dynload(vmep->voltype, &dl_handle, &vol_opt_list); + if (ret) + goto out; - if (_get_xlator_opt_key_from_vme (vmep, &xlopt_key)) - goto out; + if (_get_xlator_opt_key_from_vme(vmep, &xlopt_key)) + goto out; - opt = xlator_volume_option_get_list (&vol_opt_list, xlopt_key); - _free_xlator_opt_key (xlopt_key); + opt = xlator_volume_option_get_list(&vol_opt_list, xlopt_key); + _free_xlator_opt_key(xlopt_key); - if (opt) - opt_type = opt->type; - } + if (opt) + opt_type = opt->type; + } out: - if (dl_handle) { - dlclose (dl_handle); - dl_handle = NULL; - } + if (dl_handle) { + dlclose(dl_handle); + dl_handle = NULL; + } - return opt_type; + return opt_type; } gf_boolean_t -gd_is_boolean_option (char *key) +gd_is_boolean_option(char *key) { - GF_ASSERT (key); + GF_ASSERT(key); - if (GF_OPTION_TYPE_BOOL == _gd_get_option_type (key)) - return _gf_true; + if (GF_OPTION_TYPE_BOOL == _gd_get_option_type(key)) + return _gf_true; - return _gf_false; + return _gf_false; } |