diff options
Diffstat (limited to 'xlators/mgmt/glusterd/src/glusterd-volgen.c')
| -rw-r--r-- | xlators/mgmt/glusterd/src/glusterd-volgen.c | 4687 |
1 files changed, 3531 insertions, 1156 deletions
diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.c b/xlators/mgmt/glusterd/src/glusterd-volgen.c index ee7d68391..6f3c69e7d 100644 --- a/xlators/mgmt/glusterd/src/glusterd-volgen.c +++ b/xlators/mgmt/glusterd/src/glusterd-volgen.c @@ -1,454 +1,677 @@ /* - Copyright (c) 2006-2009 Gluster, Inc. <http://www.gluster.com> - This file is part of GlusterFS. - - GlusterFS is GF_FREE software; you can redistribute it and/or modify - it under the terms of the GNU Affero General Public License as published - by the Free Software Foundation; either version 3 of the License, - or (at your option) any later version. - - GlusterFS is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Affero General Public License for more details. - - You should have received a copy of the GNU Affero General Public License - along with this program. If not, see - <http://www.gnu.org/licenses/>. -*/ + Copyright (c) 2010-2012 Red Hat, Inc. <http://www.redhat.com> + This file is part of GlusterFS. + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ #ifndef _CONFIG_H #define _CONFIG_H #include "config.h" #endif +#include <fnmatch.h> +#include <sys/wait.h> +#include <dlfcn.h> + +#if (HAVE_LIB_XML) +#include <libxml/encoding.h> +#include <libxml/xmlwriter.h> +#endif + #include "xlator.h" -#include "protocol-common.h" #include "glusterd.h" #include "defaults.h" -#include "list.h" +#include "logging.h" #include "dict.h" -#include "compat.h" -#include "compat-errno.h" -#include "glusterd-sm.h" -#include "glusterd-op-sm.h" -#include "cli1.h" +#include "graph-utils.h" +#include "glusterd-store.h" +#include "glusterd-hooks.h" +#include "trie.h" #include "glusterd-mem-types.h" +#include "cli1-xdr.h" #include "glusterd-volgen.h" +#include "glusterd-op-sm.h" +#include "glusterd-utils.h" +#include "run.h" +#include "options.h" -static int -set_xlator_option (dict_t *dict, char *key, - char *value) -{ - int ret = 0; - char *str = NULL; +extern struct volopt_map_entry glusterd_volopt_map[]; - str = GF_CALLOC (1, strlen (value) + 1, - gf_gld_mt_char); +/********************************************* + * + * xlator generation / graph manipulation API + * + *********************************************/ - if (!str) - return -1; - strncpy (str, value, strlen (value)); +struct volgen_graph { + char **errstr; + glusterfs_graph_t graph; +}; +typedef struct volgen_graph volgen_graph_t; - ret = dict_set_dynstr (dict, key, str); +static void +set_graph_errstr (volgen_graph_t *graph, const char *str) +{ + if (!graph->errstr) + return; - return ret; + *graph->errstr = gf_strdup (str); } -static int32_t -set_default_options (dict_t *dict, char *volname) +static xlator_t * +xlator_instantiate_va (const char *type, const char *format, va_list arg) { - int ret = -1; + xlator_t *xl = NULL; + char *volname = NULL; + int ret = 0; - ret = dict_set_str (dict, "volname", - volname); - if (ret) - goto out; + ret = gf_vasprintf (&volname, format, arg); + if (ret < 0) { + volname = NULL; - ret = set_xlator_option (dict, VOLGEN_POSIX_OPTION_ODIRECT, - "on"); - if (ret) - goto out; + goto error; + } - ret = set_xlator_option (dict, VOLGEN_POSIX_OPTION_STATFSSIZE, - "on"); + 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 out; + goto error; + xl->options = get_new_dict(); + if (!xl->options) + goto error; + xl->name = volname; + INIT_LIST_HEAD (&xl->volume_options); - ret = set_xlator_option (dict, VOLGEN_POSIX_OPTION_MANDATTR, - "on"); - if (ret) - goto out; + xl->ctx = THIS->ctx; - ret = set_xlator_option (dict, VOLGEN_POSIX_OPTION_SPANDEVICES, - "1"); - if (ret) - goto out; + return xl; - ret = set_xlator_option (dict, VOLGEN_POSIX_OPTION_BCKUNLINK, - "on"); - if (ret) - goto out; + error: + gf_log ("", GF_LOG_ERROR, "creating xlator of type %s failed", + type); + GF_FREE (volname); + if (xl) + xlator_destroy (xl); - ret = set_xlator_option (dict, VOLGEN_LOCKS_OPTION_TRACE, - "on"); - if (ret) - goto out; + return NULL; +} - ret = set_xlator_option (dict, VOLGEN_LOCKS_OPTION_MAND, - "on"); - if (ret) - goto out; +#ifdef __not_used_as_of_now_ +static xlator_t * +xlator_instantiate (const char *type, const char *format, ...) +{ + va_list arg; + xlator_t *xl; - ret = set_xlator_option (dict, VOLGEN_CLIENT_OPTION_TRANSTYPE, - "tcp"); - if (ret) - goto out; + va_start (arg, format); + xl = xlator_instantiate_va (type, format, arg); + va_end (arg); - ret = set_xlator_option (dict, VOLGEN_CLIENT_OPTION_NODELAY, - "on"); - if (ret) - goto out; + return xl; +} +#endif - ret = set_xlator_option (dict, VOLGEN_IOT_OPTION_THREADCOUNT, - "16"); - if (ret) - goto out; +static int +volgen_xlator_link (xlator_t *pxl, xlator_t *cxl) +{ + int ret = 0; - ret = set_xlator_option (dict, VOLGEN_IOT_OPTION_AUTOSCALING, - "on"); - if (ret) - goto out; + ret = glusterfs_xlator_link (pxl, cxl); + if (ret == -1) { + gf_log ("", GF_LOG_ERROR, + "Out of memory, cannot link xlators %s <- %s", + pxl->name, cxl->name); + } - ret = set_xlator_option (dict, VOLGEN_IOT_OPTION_MINTHREADS, - "on"); - if (ret) - goto out; + return ret; +} - ret = set_xlator_option (dict, VOLGEN_IOT_OPTION_MAXTHREADS, - "on"); - if (ret) - goto out; +static int +volgen_graph_link (volgen_graph_t *graph, xlator_t *xl) +{ + int ret = 0; - ret = set_xlator_option (dict, VOLGEN_SERVER_OPTION_TRANSTYPE, - "tcp"); - if (ret) - goto out; + /* no need to care about graph->top here */ + if (graph->graph.first) + ret = volgen_xlator_link (xl, graph->graph.first); + if (ret == -1) { + gf_log ("", GF_LOG_ERROR, "failed to add graph entry %s", + xl->name); - ret = set_xlator_option (dict, VOLGEN_SERVER_OPTION_NODELAY, - "on"); - if (ret) - goto out; + return -1; + } - ret = set_xlator_option (dict, VOLGEN_REPLICATE_OPTION_READSUBVOL, - "on"); - if (ret) - goto out; + return 0; +} - ret = set_xlator_option (dict, VOLGEN_REPLICATE_OPTION_FAVCHILD, - "on"); - if (ret) - goto out; +static xlator_t * +volgen_graph_add_as (volgen_graph_t *graph, const char *type, + const char *format, ...) +{ + va_list arg; + xlator_t *xl = NULL; - ret = set_xlator_option (dict, VOLGEN_REPLICATE_OPTION_BCKSHCOUNT, - "on"); - if (ret) - goto out; + va_start (arg, format); + xl = xlator_instantiate_va (type, format, arg); + va_end (arg); - ret = set_xlator_option (dict, VOLGEN_REPLICATE_OPTION_DATASH, - "on"); - if (ret) - goto out; + if (!xl) + return NULL; - ret = set_xlator_option (dict, VOLGEN_REPLICATE_OPTION_DATASHALGO, - "on"); - if (ret) - goto out; + if (volgen_graph_link (graph, xl)) { + xlator_destroy (xl); - ret = set_xlator_option (dict, VOLGEN_REPLICATE_OPTION_SHWINDOWSIZE, - "on"); - if (ret) - goto out; + return NULL; + } else + glusterfs_graph_set_first (&graph->graph, xl); - ret = set_xlator_option (dict, VOLGEN_REPLICATE_OPTION_METASH, - "on"); - if (ret) - goto out; + return xl; +} - ret = set_xlator_option (dict, VOLGEN_REPLICATE_OPTION_ENTRYSH, - "on"); - if (ret) - goto out; +static xlator_t * +volgen_graph_add_nolink (volgen_graph_t *graph, const char *type, + const char *format, ...) +{ + va_list arg; + xlator_t *xl = NULL; - ret = set_xlator_option (dict, VOLGEN_REPLICATE_OPTION_DATACHANGELOG, - "on"); - if (ret) - goto out; + va_start (arg, format); + xl = xlator_instantiate_va (type, format, arg); + va_end (arg); - ret = set_xlator_option (dict, VOLGEN_REPLICATE_OPTION_METADATACHANGELOG, - "on"); - if (ret) - goto out; + if (!xl) + return NULL; - ret = set_xlator_option (dict, VOLGEN_REPLICATE_OPTION_ENTRYCHANGELOG, - "on"); - if (ret) - goto out; + glusterfs_graph_set_first (&graph->graph, xl); - ret = set_xlator_option (dict, VOLGEN_REPLICATE_OPTION_STRICTREADDIR, - "on"); - if (ret) - goto out; + return xl; +} - ret = set_xlator_option (dict, VOLGEN_STRIPE_OPTION_BLOCKSIZE, - "on"); - if (ret) - goto out; +static xlator_t * +volgen_graph_add (volgen_graph_t *graph, char *type, char *volname) +{ + char *shorttype = NULL; - ret = set_xlator_option (dict, VOLGEN_STRIPE_OPTION_USEXATTR, - "on"); - if (ret) - goto out; + shorttype = strrchr (type, '/'); + GF_ASSERT (shorttype); + shorttype++; + GF_ASSERT (*shorttype); - ret = set_xlator_option (dict, VOLGEN_DHT_OPTION_LOOKUPUNHASH, - "on"); - if (ret) - goto out; + return volgen_graph_add_as (graph, type, "%s-%s", volname, shorttype); +} - ret = set_xlator_option (dict, VOLGEN_DHT_OPTION_MINFREEDISK, - "on"); - if (ret) - goto out; +/* 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) +{ + char *dval = NULL; - ret = set_xlator_option (dict, VOLGEN_DHT_OPTION_UNHASHSTICKY, - "on"); - if (ret) - goto out; + dval = gf_strdup (value); + if (!dval) { + gf_log ("", GF_LOG_ERROR, + "failed to set xlator opt: %s[%s] = %s", + xl->name, key, value); - ret = set_xlator_option (dict, VOLGEN_WB_OPTION_FLUSHBEHIND, - "on"); - if (ret) - goto out; + return -1; + } - ret = set_xlator_option (dict, VOLGEN_WB_OPTION_CACHESIZE, - "on"); - if (ret) - goto out; + return dict_set_dynstr (xl->options, key, dval); +} - ret = set_xlator_option (dict, VOLGEN_WB_OPTION_DISABLENBYTES, - "on"); - if (ret) - goto out; +static int +xlator_get_option (xlator_t *xl, char *key, char **value) +{ + GF_ASSERT (xl); + return dict_get_str (xl->options, key, value); +} - ret = set_xlator_option (dict, VOLGEN_WB_OPTION_OSYNC, - "on"); - if (ret) - goto out; +static inline xlator_t * +first_of (volgen_graph_t *graph) +{ + return (xlator_t *)graph->graph.first; +} - ret = set_xlator_option (dict, VOLGEN_WB_OPTION_TRICKLINGWRITES, - "on"); - if (ret) - goto out; - ret = set_xlator_option (dict, VOLGEN_RA_OPTION_ATIME, - "on"); - if (ret) - goto out; - ret = set_xlator_option (dict, VOLGEN_RA_OPTION_PAGECOUNT, - "on"); - if (ret) - goto out; - ret = set_xlator_option (dict, VOLGEN_IOCACHE_OPTION_PRIORITY, - "on"); - if (ret) - goto out; +/************************** + * + * Trie glue + * + *************************/ - ret = set_xlator_option (dict, VOLGEN_IOCACHE_OPTION_TIMEOUT, - "on"); - if (ret) - goto out; - ret = set_xlator_option (dict, VOLGEN_IOCACHE_OPTION_CACHESIZE, - "on"); - if (ret) - goto out; +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++; + } - ret = set_xlator_option (dict, VOLGEN_IOCACHE_OPTION_MINFILESIZE, - "on"); - if (ret) - goto out; + 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; + } - ret = set_xlator_option (dict, VOLGEN_IOCACHE_OPTION_MAXFILESIZE, - "on"); - if (ret) - goto out; + return 0; +} - ret = set_xlator_option (dict, VOLGEN_QR_OPTION_PRIORITY, - "on"); - if (ret) - goto out; +static int +volopt_trie_cbk (char *word, void *param) +{ + return trie_add ((trie_t *)param, word); +} - ret = set_xlator_option (dict, VOLGEN_QR_OPTION_TIMEOUT, - "on"); - if (ret) - goto out; +static int +process_nodevec (struct trienodevec *nodevec, char **hint) +{ + int ret = 0; + char *hint1 = NULL; + char *hint2 = NULL; + char *hintinfx = ""; + trienode_t **nodes = nodevec->nodes; - ret = set_xlator_option (dict, VOLGEN_QR_OPTION_CACHESIZE, - "on"); - if (ret) - goto out; + if (!nodes[0]) { + *hint = NULL; + return 0; + } - ret = set_xlator_option (dict, VOLGEN_QR_OPTION_MAXFILESIZE, - "on"); - if (ret) - goto out; +#if 0 + /* Limit as in git */ + if (trienode_get_dist (nodes[0]) >= 6) { + *hint = NULL; + return 0; + } +#endif - ret = 0; + if (trienode_get_word (nodes[0], &hint1)) + return -1; -out: + if (nodevec->cnt < 2 || !nodes[1]) { + *hint = hint1; + return 0; + } + + 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; } -int32_t -glusterd_default_xlator_options (glusterd_volinfo_t *volinfo) +static int +volopt_trie_section (int lvl, char **patt, char *word, char **hint, int hints) { - int ret = -1; + trienode_t *nodes[] = { NULL, NULL }; + struct trienodevec nodevec = { nodes, 2}; + trie_t *trie = NULL; + int ret = 0; - volinfo->dict = dict_new (); - if (!volinfo->dict) { - ret = -1; - goto out; - } + trie = trie_new (); + if (!trie) + return -1; - ret = set_default_options (volinfo->dict, - volinfo->volname); - if (ret) { - goto out; + if (volopt_selector (lvl, patt, trie, &volopt_trie_cbk)) { + trie_destroy (trie); + + return -1; } - ret = 0; + GF_ASSERT (hints <= 2); + nodevec.cnt = hints; + ret = trie_measure_vec (trie, word, &nodevec); + if (ret || !nodevec.nodes[0]) + trie_destroy (trie); -out: - return ret; + ret = process_nodevec (&nodevec, hint); + trie_destroy (trie); + return ret; } static int -__write_posix_xlator (FILE *file, dict_t *dict, - char *posix_directory) -{ - char *volname = NULL; - char *opt_odirect = NULL; - char *opt_statfssize = NULL; - char *opt_mandattr = NULL; - char *opt_spandevices = NULL; - char *opt_bckunlink = NULL; - int ret = -1; - - const char *posix_str = "volume %s-%s\n" - "type storage/posix\n" - "option directory %s\n" - "option o-direct %s\n" - "option export-statfs-size %s\n" - "option mandate-attribute %s\n" - "#option span-devices %s\n" - "option background-unlink %s\n" - "end-volume\n\n"; - - ret = dict_get_str (dict, "volname", &volname); - if (ret) { - goto out; - } +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; + + dot = strchr (key, '.'); + if (!dot) + return volopt_trie_section (1, patt, key, hint, 2); + + len = dot - key; + dom = gf_strdup (key); + if (!dom) + return -1; + dom[len] = '\0'; - ret = dict_get_str (dict, VOLGEN_POSIX_OPTION_ODIRECT, - &opt_odirect); + ret = volopt_trie_section (0, NULL, dom, patt, 1); + GF_FREE (dom); if (ret) { + patt[0] = NULL; goto out; } - - ret = dict_get_str (dict, VOLGEN_POSIX_OPTION_STATFSSIZE, - &opt_statfssize); - if (ret) { + if (!patt[0]) goto out; - } - ret = dict_get_str (dict, VOLGEN_POSIX_OPTION_MANDATTR, - &opt_mandattr); - if (ret) { + *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; + } } - ret = dict_get_str (dict, VOLGEN_POSIX_OPTION_SPANDEVICES, - &opt_spandevices); - if (ret) { - goto out; + out: + GF_FREE (patt[0]); + if (ret) + *hint = NULL; + + return ret; +} + + + + +/************************** + * + * Volume generation engine + * + **************************/ + + +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; +}; + +static int +process_option (char *key, data_t *value, void *param) +{ + 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; + else + vme.value = value->data; + + 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 (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; + } } - ret = dict_get_str (dict, VOLGEN_POSIX_OPTION_BCKUNLINK, - &opt_bckunlink); - if (ret) { - goto out; + return 0; +} + +static int +no_filter_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) +{ + xlator_t *trav; + int ret = 0; + + 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; +} - fprintf (file, posix_str, - volname, - "posix", - posix_directory, - opt_odirect, - opt_statfssize, - opt_mandattr, - opt_spandevices, - opt_bckunlink); +static int +basic_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) +{ + int ret = 0; - ret = 0; + if (vme->option[0] == '!') + goto out; + ret = no_filter_option_handler (graph, vme, param); out: return ret; } static int -__write_locks_xlator (FILE *file, dict_t *dict, - char *subvolume) -{ - char *volname = NULL; - char *opt_trace = NULL; - char *opt_mand = NULL; - int ret = -1; - - const char *locks_str = "volume %s-%s\n" - "type features/locks\n" - "option trace %s\n" - "option mandatory %s\n" - "subvolumes %s\n" - "end-volume\n\n"; - - ret = dict_get_str (dict, "volname", &volname); - if (ret) { - goto out; - } +volgen_graph_set_options (volgen_graph_t *graph, dict_t *dict) +{ + return volgen_graph_set_options_generic (graph, dict, NULL, + &basic_option_handler); +} - ret = dict_get_str (dict, VOLGEN_LOCKS_OPTION_TRACE, - &opt_trace); - if (ret) { - goto out; +static int +optget_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) +{ + struct volopt_map_entry *vme2 = param; + + if (strcmp (vme->key, vme2->key) == 0) + vme2->value = vme->value; + + return 0; +} + +static glusterd_server_xlator_t +get_server_xlator (char *xlator) +{ + glusterd_server_xlator_t subvol = GF_XLATOR_NONE; + + if (strcmp (xlator, "posix") == 0) + subvol = GF_XLATOR_POSIX; + if (strcmp (xlator, "acl") == 0) + subvol = GF_XLATOR_ACL; + if (strcmp (xlator, "locks") == 0) + subvol = GF_XLATOR_LOCKS; + if (strcmp (xlator, "io-threads") == 0) + subvol = GF_XLATOR_IOT; + if (strcmp (xlator, "index") == 0) + subvol = GF_XLATOR_INDEX; + if (strcmp (xlator, "marker") == 0) + subvol = GF_XLATOR_MARKER; + if (strcmp (xlator, "io-stats") == 0) + subvol = GF_XLATOR_IO_STATS; + if (strcmp (xlator, "bd") == 0) + subvol = GF_XLATOR_BD; + + return subvol; +} + +static glusterd_client_xlator_t +get_client_xlator (char *xlator) +{ + glusterd_client_xlator_t subvol = GF_CLNT_XLATOR_NONE; + + if (strcmp (xlator, "client") == 0) + subvol = GF_CLNT_XLATOR_FUSE; + + return subvol; +} + +static int +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; + + if (strcmp (vme->option, "!debug") != 0) + return 0; + + if (!strcmp (vme->key , "debug.trace") || + !strcmp (vme->key, "debug.error-gen")) { + if (get_server_xlator (vme->value) == GF_XLATOR_NONE && + get_client_xlator (vme->value) == GF_CLNT_XLATOR_NONE) + return 0; + else + goto add_graph; } - ret = dict_get_str (dict, VOLGEN_LOCKS_OPTION_MAND, - &opt_mand); - if (ret) { - goto out; + if (gf_string2boolean (vme->value, &enabled) == -1) + return -1; + if (!enabled) + return 0; + +add_graph: + 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) +{ + int ret = 0; + char *value_str = NULL; + + ret = dict_get_str (set_dict, "debug.trace", &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; + } } - fprintf (file, locks_str, - volname, - "locks", - opt_trace, - opt_mand, - subvolume); + ret = dict_get_str (set_dict, "debug.error-gen", &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; + } + } ret = 0; @@ -456,1235 +679,3387 @@ out: return ret; } +/* This getter considers defaults also. */ static int -__write_client_xlator (FILE *file, dict_t *dict, - char *remote_subvol, - char *remote_host, - int count) -{ - char *volname = NULL; - char *opt_transtype = NULL; - char *opt_nodelay = NULL; - int ret = 0; - - - const char *client_str = "volume %s-%s-%d\n" - "type protocol/client\n" - "option transport-type %s\n" - "option remote-host %s\n" - "option transport.socket.nodelay %s\n" - "option remote-subvolume %s\n" - "end-volume\n\n"; - - ret = dict_get_str (dict, "volname", &volname); +volgen_dict_get (dict_t *dict, char *key, char **value) +{ + struct volopt_map_entry vme = {0,}; + int ret = 0; + + vme.key = key; + + ret = volgen_graph_set_options_generic (NULL, dict, &vme, + &optget_option_handler); if (ret) { - goto out; + gf_log ("", GF_LOG_ERROR, "Out of memory"); + + return -1; } - ret = dict_get_str (dict, VOLGEN_CLIENT_OPTION_TRANSTYPE, - &opt_transtype); - if (ret) { - goto out; + *value = vme.value; + + return 0; +} + +static int +option_complete (char *key, char **completion) +{ + 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; + + if (*completion && strcmp (*completion, vme->key) != 0) { + /* cancel on non-unique match */ + *completion = NULL; + + 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; } - ret = dict_get_str (dict, VOLGEN_CLIENT_OPTION_NODELAY, - &opt_nodelay); + return 0; +} + +int +glusterd_volinfo_get (glusterd_volinfo_t *volinfo, char *key, char **value) +{ + return volgen_dict_get (volinfo->dict, key, value); +} + +int +glusterd_volinfo_get_boolean (glusterd_volinfo_t *volinfo, char *key) +{ + char *val = NULL; + gf_boolean_t boo = _gf_false; + int ret = 0; + + ret = glusterd_volinfo_get (volinfo, key, &val); + if (ret) + return -1; + + if (val) + ret = gf_string2boolean (val, &boo); if (ret) { - goto out; + gf_log ("", GF_LOG_ERROR, "value for %s option is not valid", key); + + return -1; } - fprintf (file, client_str, - volname, - "client", - count, - opt_transtype, - remote_host, - opt_nodelay, - remote_subvol); + return boo; +} - ret = 0; +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; + } + } -out: - return ret; + return _gf_false; } -static int -__write_replace_brick_xlator (FILE *file, dict_t *dict) +gf_boolean_t +glusterd_check_globaloption (char *key) { - char *volname = NULL; - char *opt_transtype = NULL; - char *opt_nodelay = NULL; - int ret = 0; + 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; +} - const char *client_str = "volume %s-%s\n" - "type protocol/client\n" - "option transport-type %s\n" - "option remote-port 34034\n" - "option transport.socket.nodelay %s\n" - "end-volume\n\n"; +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; + } + } - ret = dict_get_str (dict, "volname", &volname); - if (ret) { - goto out; + return _gf_false; +} + +int +glusterd_check_voloption (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 == DOC)) + return _gf_true; + else + return _gf_false; + } } - ret = dict_get_str (dict, VOLGEN_CLIENT_OPTION_TRANSTYPE, - &opt_transtype); - if (ret) { - goto out; + 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_log (this->name, GF_LOG_ERROR, + "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; + } } - ret = dict_get_str (dict, VOLGEN_CLIENT_OPTION_NODELAY, - &opt_nodelay); + if (ret || !completion) + return ret; + + trie: + ret = volopt_trie (key, completion); if (ret) { - goto out; + gf_log (this->name, GF_LOG_ERROR, + "Some error occurred during keyword hinting"); } - fprintf (file, client_str, - volname, - "replace-brick", - opt_transtype, - opt_nodelay); + return ret; +} - ret = 0; +char* +glusterd_get_trans_type_rb (gf_transport_type ttype) +{ + char *trans_type = NULL; + + switch (ttype) { + case GF_TRANSPORT_RDMA: + gf_asprintf (&trans_type, "rdma"); + break; + case GF_TRANSPORT_TCP: + case GF_TRANSPORT_BOTH_TCP_RDMA: + gf_asprintf (&trans_type, "tcp"); + break; + default: + gf_log (THIS->name, GF_LOG_ERROR, "Unknown " + "transport 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); + if (ret) + goto out; + } + ret = 0; out: return ret; } static int -__write_pump_xlator (FILE *file, dict_t *dict, - char *subvolume) +volgen_graph_merge_sub (volgen_graph_t *dgraph, volgen_graph_t *sgraph, + size_t child_count) { - char *volname = NULL; - int ret = -1; + xlator_t *trav = NULL; + int ret = 0; - const char *pump_str = "volume %s-%s\n" - "type cluster/pump\n" - "subvolumes %s %s-replace-brick\n" - "end-volume\n\n"; + GF_ASSERT (dgraph->graph.first); - ret = dict_get_str (dict, "volname", &volname); - if (ret) { + ret = _xl_link_children (first_of (dgraph), first_of (sgraph), + child_count); + if (ret) goto out; - } - fprintf (file, pump_str, - volname, "pump", - subvolume, - volname); + for (trav = first_of (dgraph); trav->next; trav = trav->next); - ret = 0; + trav->next = first_of (sgraph); + trav->next->prev = trav; + dgraph->graph.xl_count += sgraph->graph.xl_count; out: return ret; } +static void +volgen_apply_filters (char *orig_volfile) +{ + DIR *filterdir = NULL; + struct dirent entry = {0,}; + struct dirent *next = NULL; + char *filterpath = NULL; + struct stat statbuf = {0,}; + + filterdir = opendir(FILTERDIR); + if (!filterdir) { + return; + } + + while ((readdir_r(filterdir,&entry,&next) == 0) && next) { + if (!strncmp(entry.d_name,".",sizeof(entry.d_name))) { + continue; + } + if (!strncmp(entry.d_name,"..",sizeof(entry.d_name))) { + continue; + } + /* + * d_type isn't guaranteed to be present/valid on all systems, + * so do an explicit stat instead. + */ + if (gf_asprintf(&filterpath,"%s/%.*s",FILTERDIR, + sizeof(entry.d_name), entry.d_name) == (-1)) { + continue; + } + /* Deliberately use stat instead of lstat to allow symlinks. */ + if (stat(filterpath,&statbuf) == (-1)) { + goto free_fp; + } + if (!S_ISREG(statbuf.st_mode)) { + goto free_fp; + } + /* + * 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 (access(filterpath,X_OK) != 0) { + goto free_fp; + } + if (runcmd(filterpath,orig_volfile,NULL)) { + gf_log("",GF_LOG_ERROR,"failed to run filter %.*s", + (int)sizeof(entry.d_name), entry.d_name); + } +free_fp: + GF_FREE(filterpath); + } +} + static int -__write_iothreads_xlator (FILE *file, dict_t *dict, - char *subvolume) -{ - char *volname = NULL; - char *opt_threadcount = NULL; - char *opt_autoscaling = NULL; - char *opt_minthreads = NULL; - char *opt_maxthreads = NULL; - int ret = -1; - - const char *iot_str = "volume %s\n" - "type performance/io-threads\n" - "option thread-count %s\n" - "#option autoscaling %s\n" - "#option min-threads %s\n" - "#option max-threads %s\n" - "subvolumes %s\n" - "end-volume\n\n"; - - ret = dict_get_str (dict, "export-path", &volname); - if (ret) { - goto out; +volgen_write_volfile (volgen_graph_t *graph, char *filename) +{ + char *ftmp = NULL; + FILE *f = NULL; + int fd = 0; + xlator_t *this = NULL; + + this = THIS; + + if (gf_asprintf (&ftmp, "%s.tmp", filename) == -1) { + ftmp = NULL; + + goto error; } - ret = dict_get_str (dict, VOLGEN_IOT_OPTION_THREADCOUNT, - &opt_threadcount); - if (ret) { - goto out; + fd = creat (ftmp, S_IRUSR | S_IWUSR); + if (fd < 0) { + gf_log (this->name, GF_LOG_ERROR, "%s", + strerror (errno)); + goto error; } - ret = dict_get_str (dict, VOLGEN_IOT_OPTION_AUTOSCALING, - &opt_autoscaling); - if (ret) { - goto out; + 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_log (THIS->name, GF_LOG_ERROR, "fclose on the file %s " + "failed (%s)", ftmp, strerror (errno)); + /* + * 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; } - ret = dict_get_str (dict, VOLGEN_IOT_OPTION_MINTHREADS, - &opt_minthreads); - if (ret) { - goto out; + f = NULL; + + if (rename (ftmp, filename) == -1) + goto error; + + GF_FREE (ftmp); + + volgen_apply_filters(filename); + + return 0; + + error: + + GF_FREE (ftmp); + if (f) + fclose (f); + + gf_log (this->name, GF_LOG_ERROR, + "failed to create volfile %s", filename); + + return -1; +} + +static void +volgen_graph_free (volgen_graph_t *graph) +{ + xlator_t *trav = NULL; + xlator_t *trav_old = NULL; + + for (trav = first_of (graph) ;; trav = trav->next) { + if (trav_old) + xlator_destroy (trav_old); + + trav_old = trav; + + if (!trav) + break; } +} - ret = dict_get_str (dict, VOLGEN_IOT_OPTION_MAXTHREADS, - &opt_maxthreads); - if (ret) { - goto out; +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)) +{ + dict_t *set_dict = NULL; + int ret = 0; + + if (mod_dict) { + set_dict = dict_copy (volinfo->dict, NULL); + if (!set_dict) + return -1; + dict_copy (mod_dict, set_dict); + /* XXX dict_copy swallows errors */ + } else { + set_dict = volinfo->dict; } - fprintf (file, iot_str, - volname, - opt_threadcount, - opt_autoscaling, - opt_minthreads, - opt_maxthreads, - subvolume); + ret = builder (graph, volinfo, set_dict, param); + if (!ret) + ret = volgen_graph_set_options (graph, set_dict); - ret = 0; + if (mod_dict) + dict_destroy (set_dict); -out: return ret; } -static int -__write_server_xlator (FILE *file, dict_t *dict, - char *subvolume) -{ - char *volname = NULL; - char *opt_transtype = NULL; - char *opt_nodelay = NULL; - int ret = -1; - - const char *server_str = "volume %s-%s\n" - "type protocol/server\n" - "option transport-type %s\n" - "option auth.addr.%s.allow *\n" - "option transport.socket.nodelay %s\n" - "subvolumes %s\n" - "end-volume\n\n"; - - ret = dict_get_str (dict, "volname", &volname); - if (ret) { - goto out; +static gf_transport_type +transport_str_to_type (char *tt) +{ + 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; +} + +static void +transport_type_to_str (gf_transport_type type, char *tt) +{ + switch (type) { + case GF_TRANSPORT_RDMA: + strcpy (tt, "rdma"); + break; + case GF_TRANSPORT_TCP: + strcpy (tt, "tcp"); + break; + case GF_TRANSPORT_BOTH_TCP_RDMA: + strcpy (tt, "tcp,rdma"); + break; } +} - ret = dict_get_str (dict, VOLGEN_SERVER_OPTION_TRANSTYPE, - &opt_transtype); - if (ret) { - goto out; +static void +get_vol_transport_type (glusterd_volinfo_t *volinfo, char *tt) +{ + transport_type_to_str (volinfo->transport_type, tt); +} + +static void +get_vol_nfs_transport_type (glusterd_volinfo_t *volinfo, char *tt) +{ + if (volinfo->nfs_transport_type == GF_TRANSPORT_BOTH_TCP_RDMA) { + gf_log ("", GF_LOG_ERROR, "%s:nfs transport cannot be both" + " tcp and rdma", volinfo->volname); + GF_ASSERT (0); } + transport_type_to_str (volinfo->nfs_transport_type, tt); +} - ret = dict_get_str (dict, VOLGEN_SERVER_OPTION_NODELAY, - &opt_nodelay); - if (ret) { - goto out; +/* gets the volinfo, dict, a character array for filling in + * the transport type and a boolean option which says whether + * the transport type is required for nfs or not. If its not + * for nfs, then it is considered as the client transport + * 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; } - fprintf (file, server_str, - volname, "server", - opt_transtype, - subvolume, - opt_nodelay, - subvolume); + ret = dict_get_str (set_dict, key, &tt); + if (ret) + get_transport (volinfo, transt); + if (!ret) + strcpy (transt, tt); +} - ret = 0; +static int +server_auth_option_handler (volgen_graph_t *graph, + struct volopt_map_entry *vme, void *param) +{ + xlator_t *xl = NULL; + xlator_list_t *trav = NULL; + char *aa = NULL; + int ret = 0; + char *key = NULL; + + if (strcmp (vme->option, "!server-auth") != 0) + return 0; + + xl = first_of (graph); + + /* from 'auth.allow' -> 'allow', and 'auth.reject' -> 'reject' */ + key = strchr (vme->key, '.') + 1; + + for (trav = xl->children; trav; trav = trav->next) { + ret = gf_asprintf (&aa, "auth.addr.%s.%s", trav->xlator->name, + key); + if (ret != -1) { + ret = xlator_set_option (xl, aa, vme->value); + GF_FREE (aa); + } + if (ret) + return -1; + } -out: - return ret; + return 0; } static int -__write_replicate_xlator (FILE *file, dict_t *dict, - char *subvolume, - int replicate_count, - int count) -{ - char *volname = NULL; - char *opt_readsubvol = NULL; - char *opt_favchild = NULL; - char *opt_bckshcount = NULL; - char *opt_datash = NULL; - char *opt_datashalgo = NULL; - char *opt_shwindowsize = NULL; - char *opt_metash = NULL; - char *opt_entrysh = NULL; - char *opt_datachangelog = NULL; - char *opt_metadatachangelog = NULL; - char *opt_entrychangelog = NULL; - char *opt_strictreaddir = NULL; - char subvol_str[8192] = {0,}; - char tmp[4096] = {0,}; - int ret = -1; - int i = 0; - - const char *replicate_str = "volume %s-%s-%d\n" - "type cluster/replicate\n" - "#option read-subvolume %s\n" - "#option favorite-child %s\n" - "#option background-self-heal-count %s\n" - "#option data-self-heal %s\n" - "#option data-self-heal-algorithm %s\n" - "#option data-self-heal-window-size %s\n" - "#option metadata-self-heal %s\n" - "#option entry-self-heal %s\n" - "#option data-change-log %s\n" - "#option metadata-change-log %s\n" - "#option entry-change-log %s\n" - "#option strict-readdir %s\n" - "subvolumes %s\n" - "end-volume\n\n"; - - ret = dict_get_str (dict, "volname", &volname); - if (ret) { +loglevel_option_handler (volgen_graph_t *graph, + struct volopt_map_entry *vme, void *param) +{ + 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; + + memcpy (&vme2, vme, sizeof (vme2)); + vme2.option = "log-level"; + + return basic_option_handler (graph, &vme2, NULL); +} + +static int +server_check_marker_off (volgen_graph_t *graph, struct volopt_map_entry *vme, + glusterd_volinfo_t *volinfo) +{ + gf_boolean_t bool = _gf_false; + int ret = 0; + + GF_ASSERT (volinfo); + GF_ASSERT (vme); + + if (strcmp (vme->option, "!xtime") != 0) + return 0; + + ret = gf_string2boolean (vme->value, &bool); + if (ret || bool) goto out; - } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_READSUBVOL, - &opt_readsubvol); - if (ret) { + ret = glusterd_volinfo_get_boolean (volinfo, VKEY_MARKER_XTIME); + if (ret < 0) { + gf_log ("", GF_LOG_WARNING, "failed to get the marker status"); + ret = -1; goto out; } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_FAVCHILD, - &opt_favchild); if (ret) { - goto out; + bool = _gf_false; + ret = glusterd_check_gsync_running (volinfo, &bool); + + if (bool) { + gf_log ("", GF_LOG_WARNING, 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 (ret) { + gf_log ("", GF_LOG_WARNING, "Unable to get the status" + " of active gsync session"); + goto out; + } } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_BCKSHCOUNT, - &opt_bckshcount); - if (ret) { + ret = 0; + out: + gf_log ("", GF_LOG_DEBUG, "Returning %d", ret); + return ret; + +} + +static int +sys_loglevel_option_handler (volgen_graph_t *graph, + struct volopt_map_entry *vme, + void *param) +{ + char *role = NULL; + struct volopt_map_entry vme2 = {0,}; + + role = (char *) param; + + if (strcmp (vme->option, "!sys-log-level") != 0 || + !strstr (vme->key, role)) + return 0; + + memcpy (&vme2, vme, sizeof (vme2)); + vme2.option = "sys-log-level"; + + 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, VOLGEN_REPLICATE_OPTION_DATASH, - &opt_datash); - if (ret) { + 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_log ("glusterd", GF_LOG_DEBUG, "Setting log level for xlator: %s", + trav->type); + ret = xlator_set_option (trav, "log-level", loglevel); + if (ret) + break; + } } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_DATASHALGO, - &opt_datashalgo); - if (ret) { - goto out; + out: + return ret; +} + +static int +server_spec_option_handler (volgen_graph_t *graph, + struct volopt_map_entry *vme, void *param) +{ + int ret = 0; + glusterd_volinfo_t *volinfo = NULL; + + volinfo = param; + + ret = server_auth_option_handler (graph, vme, NULL); + if (!ret) + ret = server_check_marker_off (graph, vme, volinfo); + + if (!ret) + ret = loglevel_option_handler (graph, vme, "brick"); + + if (!ret) + ret = sys_loglevel_option_handler (graph, vme, "brick"); + + return ret; +} + +static int +server_spec_extended_option_handler (volgen_graph_t *graph, + struct volopt_map_entry *vme, void *param) +{ + int ret = 0; + dict_t *dict = NULL; + + 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); + + return ret; +} + +static void get_vol_tstamp_file (char *filename, glusterd_volinfo_t *volinfo); + +static int +server_graph_builder (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *set_dict, void *param) +{ + char *volname = NULL; + char *path = NULL; + int pump = 0; + xlator_t *xl = NULL; + xlator_t *txl = NULL; + xlator_t *rbxl = NULL; + char transt[16] = {0,}; + char *ptranst = NULL; + char volume_id[64] = {0,}; + char tstamp_file[PATH_MAX] = {0,}; + int ret = 0; + char *xlator = NULL; + char *loglevel = NULL; + char *username = NULL; + char *password = NULL; + char index_basepath[PATH_MAX] = {0}; + char key[1024] = {0}; + glusterd_brickinfo_t *brickinfo = NULL; + char changelog_basepath[PATH_MAX] = {0,}; + + brickinfo = param; + path = brickinfo->path; + volname = volinfo->volname; + get_vol_transport_type (volinfo, transt); + + 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_log ("glusterd", GF_LOG_ERROR, "could not get both" + " translator name and loglevel for log level request"); + goto out; + } } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_SHWINDOWSIZE, - &opt_shwindowsize); - if (ret) { - goto out; + xl = volgen_graph_add (graph, "storage/posix", volname); + if (!xl) + return -1; + + ret = xlator_set_option (xl, "directory", path); + if (ret) + return -1; + + ret = xlator_set_option (xl, "volume-id", + uuid_utoa (volinfo->volume_id)); + if (ret) + return -1; + + ret = check_and_add_debug_xl (graph, set_dict, volname, + "posix"); + if (ret) + return -1; +#ifdef HAVE_BD_XLATOR + if (*brickinfo->vg != '\0') { + /* Now add BD v2 xlator if volume is BD type */ + xl = volgen_graph_add (graph, "storage/bd", volname); + if (!xl) + return -1; + + ret = xlator_set_option (xl, "device", "vg"); + if (ret) + return -1; + ret = xlator_set_option (xl, "export", brickinfo->vg); + if (ret) + return -1; + + ret = check_and_add_debug_xl (graph, set_dict, volname, "bd"); + if (ret) + return -1; + } +#endif - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_METASH, - &opt_metash); - if (ret) { - goto out; + xl = volgen_graph_add (graph, "features/changelog", volname); + if (!xl) + return -1; + + ret = xlator_set_option (xl, "changelog-brick", path); + if (ret) + return -1; + + snprintf (changelog_basepath, sizeof (changelog_basepath), + "%s/%s", path, ".glusterfs/changelogs"); + ret = xlator_set_option (xl, "changelog-dir", changelog_basepath); + if (ret) + return -1; + + ret = check_and_add_debug_xl (graph, set_dict, volname, "changelog"); + if (ret) + return -1; + + xl = volgen_graph_add (graph, "features/access-control", volname); + if (!xl) + return -1; + + ret = check_and_add_debug_xl (graph, set_dict, volname, "acl"); + if (ret) + return -1; + + xl = volgen_graph_add (graph, "features/locks", volname); + if (!xl) + return -1; + + ret = check_and_add_debug_xl (graph, set_dict, volname, "locks"); + if (ret) + return -1; + + xl = volgen_graph_add (graph, "performance/io-threads", volname); + if (!xl) + return -1; + + ret = check_and_add_debug_xl (graph, set_dict, volname, "io-threads"); + if (ret) + return -1; + + 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 (pump) { + txl = first_of (graph); + + rbxl = volgen_graph_add_nolink (graph, "protocol/client", + "%s-replace-brick", volname); + if (!rbxl) + return -1; + + ptranst = glusterd_get_trans_type_rb (volinfo->transport_type); + if (NULL == ptranst) + return -1; + + if (username) { + ret = xlator_set_option (rbxl, "username", username); + 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; + + xl = volgen_graph_add_nolink (graph, "cluster/pump", "%s-pump", + 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; } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_ENTRYSH, - &opt_entrysh); - if (ret) { + xl = volgen_graph_add (graph, "features/index", volname); + if (!xl) + return -1; + + snprintf (index_basepath, sizeof (index_basepath), "%s/%s", + path, ".glusterfs/indices"); + ret = xlator_set_option (xl, "index-base", index_basepath); + if (ret) + return -1; + + ret = check_and_add_debug_xl (graph, set_dict, volname, + "index"); + if (ret) + return -1; + + xl = volgen_graph_add (graph, "features/marker", volname); + if (!xl) + return -1; + + uuid_unparse (volinfo->volume_id, volume_id); + ret = xlator_set_option (xl, "volume-uuid", volume_id); + if (ret) + return -1; + get_vol_tstamp_file (tstamp_file, volinfo); + ret = xlator_set_option (xl, "timestamp-file", tstamp_file); + if (ret) + return -1; + + ret = check_and_add_debug_xl (graph, set_dict, volname, "marker"); + if (ret) + return -1; + + if (dict_get_str_boolean (set_dict, "features.read-only", 0) && + dict_get_str_boolean (set_dict, "features.worm",0)) { + gf_log (THIS->name, GF_LOG_ERROR, + "read-only and worm cannot be set together"); + ret = -1; goto out; } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_DATACHANGELOG, - &opt_datachangelog); - if (ret) { - goto out; + /* Check for read-only volume option, and add it to the graph */ + if (dict_get_str_boolean (set_dict, "features.read-only", 0) + || volinfo -> is_snap_volume) { + xl = volgen_graph_add (graph, "features/read-only", volname); + if (!xl) { + ret = -1; + goto out; + } } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_METADATACHANGELOG, - &opt_metadatachangelog); - if (ret) { - goto out; + /* Check for worm volume option, and add it to the graph */ + if (dict_get_str_boolean (set_dict, "features.worm", 0)) { + xl = volgen_graph_add (graph, "features/worm", volname); + if (!xl) { + ret = -1; + goto out; + } } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_ENTRYCHANGELOG, - &opt_entrychangelog); - if (ret) { - goto out; + /* Check for compress volume option, and add it to the graph on server side */ + if (dict_get_str_boolean (set_dict, "features.compress", 0)) { + xl = volgen_graph_add (graph, "features/cdc", volname); + if (!xl) { + ret = -1; + goto out; + } + ret = dict_set_str (set_dict, "compress.mode", "server"); + if (ret) + goto out; } - ret = dict_get_str (dict, VOLGEN_REPLICATE_OPTION_STRICTREADDIR, - &opt_strictreaddir); - if (ret) { - goto out; + xl = volgen_graph_add_as (graph, "debug/io-stats", path); + if (!xl) + return -1; + + xl = volgen_graph_add (graph, "protocol/server", volname); + if (!xl) + return -1; + ret = xlator_set_option (xl, "transport-type", transt); + if (ret) + return -1; + + /*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; } - for (i = 0; i < replicate_count; i++) { - snprintf (tmp, 4096, "%s-%d ", subvolume, i); - strncat (subvol_str, tmp, strlen (tmp)); + if (username) { + memset (key, 0, sizeof (key)); + snprintf (key, sizeof (key), "auth.login.%s.allow", path); + + ret = xlator_set_option (xl, key, username); + if (ret) + return -1; } - fprintf (file, replicate_str, - volname, - "replicate", - count, - opt_readsubvol, - opt_favchild, - opt_bckshcount, - opt_datash, - opt_datashalgo, - opt_shwindowsize, - opt_metash, - opt_entrysh, - opt_datachangelog, - opt_metadatachangelog, - opt_entrychangelog, - opt_strictreaddir, - subvol_str); + if (password) { + memset (key, 0, sizeof (key)); + snprintf (key, sizeof (key), "auth.login.%s.password", + username); + ret = xlator_set_option (xl, key, password); + if (ret) + return -1; + } - ret = 0; + 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: + 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) +{ + 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) +{ + gf_boolean_t enabled = _gf_false; + glusterd_volinfo_t *volinfo = NULL; + + GF_ASSERT (param); + volinfo = param; + + if (strcmp (vme->option, "!perf") != 0) + return 0; + + if (gf_string2boolean (vme->value, &enabled) == -1) + return -1; + if (!enabled) + 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 (volgen_graph_add (graph, vme->voltype, volinfo->volname)) + return 0; + else + return -1; +} + static int -__write_stripe_xlator (FILE *file, dict_t *dict, - char *subvolume, - int stripe_count, - int count) +nfsperfxl_option_handler (volgen_graph_t *graph, struct volopt_map_entry *vme, + void *param) { char *volname = NULL; - char *opt_blocksize = NULL; - char *opt_usexattr = NULL; - char subvol_str[8192] = {0,}; - char tmp[4096] = {0,}; - int ret = -1; - int i = 0; - - const char *stripe_str = "volume %s-%s-%d\n" - "type cluster/stripe\n" - "#option block-size %s\n" - "#option use-xattr %s\n" - "subvolumes %s\n" - "end-volume\n\n"; - - ret = dict_get_str (dict, "volname", &volname); - if (ret) { + gf_boolean_t enabled = _gf_false; + + volname = param; + + if (strcmp (vme->option, "!nfsperf") != 0) + 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 (HAVE_LIB_XML) +static int +end_sethelp_xml_doc (xmlTextWriterPtr writer) +{ + int ret = -1; + + ret = xmlTextWriterEndElement(writer); + if (ret < 0) { + gf_log ("glusterd", GF_LOG_ERROR, "Could not end an " + "xmlElemetnt"); + ret = -1; goto out; } - - ret = dict_get_str (dict, VOLGEN_STRIPE_OPTION_BLOCKSIZE, - &opt_blocksize); - if (ret) { + ret = xmlTextWriterEndDocument (writer); + if (ret < 0) { + gf_log ("glusterd", GF_LOG_ERROR, "Could not end an " + "xmlDocument"); + ret = -1; goto out; } + ret = 0; + out: + gf_log ("glusterd", GF_LOG_DEBUG, "Returning %d", ret); + return ret; - ret = dict_get_str (dict, VOLGEN_STRIPE_OPTION_USEXATTR, - &opt_usexattr); - if (ret) { +} + +static int +init_sethelp_xml_doc (xmlTextWriterPtr *writer, xmlBufferPtr *buf) +{ + int ret; + + *buf = xmlBufferCreateSize (8192); + if (buf == NULL) { + gf_log ("glusterd", GF_LOG_ERROR, "Error creating the xml " + "buffer"); + ret = -1; goto out; } + xmlBufferSetAllocationScheme (*buf,XML_BUFFER_ALLOC_DOUBLEIT); - for (i = 0; i < stripe_count; i++) { - snprintf (tmp, 4096, "%s-%d ", subvolume, i); - strncat (subvol_str, tmp, strlen (tmp)); + *writer = xmlNewTextWriterMemory(*buf, 0); + if (writer == NULL) { + gf_log ("glusterd", GF_LOG_ERROR, " Error creating the xml " + "writer"); + ret = -1; + goto out; } - fprintf (file, stripe_str, - volname, - count, - "stripe", - opt_blocksize, - opt_usexattr, - subvol_str); + ret = xmlTextWriterStartDocument(*writer, "1.0", "UTF-8", "yes"); + if (ret < 0) { + gf_log ("glusterd", GF_LOG_ERROR, "Error While starting the " + "xmlDoc"); + goto out; + } + + ret = xmlTextWriterStartElement(*writer, (xmlChar *)"options"); + if (ret < 0) { + gf_log ("glusterd", GF_LOG_ERROR, "Could not create an " + "xmlElemetnt"); + ret = -1; + goto out; + } ret = 0; -out: + out: + gf_log ("glusterd", GF_LOG_DEBUG, "Returning %d", ret); return ret; + } static int -__write_distribute_xlator (FILE *file, dict_t *dict, - char *subvolume, - int dist_count) -{ - char *volname = NULL; - char subvol_str[8192] = {0,}; - char tmp[4096] = {0,}; - char *opt_lookupunhash = NULL; - char *opt_minfreedisk = NULL; - char *opt_unhashsticky = NULL; - int ret = -1; - int i = 0; - - const char *dht_str = "volume %s-%s\n" - "type cluster/distribute\n" - "#option lookup-unhashed %s\n" - "#option min-free-disk %s\n" - "#option unhashed-sticky-bit %s\n" - "subvolumes %s\n" - "end-volume\n\n"; - - ret = dict_get_str (dict, "volname", &volname); - if (ret) { +xml_add_volset_element (xmlTextWriterPtr writer, const char *name, + const char *def_val, const char *dscrpt) +{ + + int ret = -1; + + GF_ASSERT (name); + + ret = xmlTextWriterStartElement(writer, (xmlChar *) "option"); + if (ret < 0) { + gf_log ("glusterd", GF_LOG_ERROR, "Could not create an " + "xmlElemetnt"); + ret = -1; goto out; } - ret = dict_get_str (dict, VOLGEN_DHT_OPTION_LOOKUPUNHASH, - &opt_lookupunhash); - if (ret) { + ret = xmlTextWriterWriteFormatElement(writer, (xmlChar*)"defaultValue", + "%s", def_val); + if (ret < 0) { + gf_log ("glusterd", GF_LOG_ERROR, "Could not create an " + "xmlElemetnt"); + ret = -1; goto out; } - ret = dict_get_str (dict, VOLGEN_DHT_OPTION_MINFREEDISK, - &opt_minfreedisk); - if (ret) { + ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *)"description", + "%s", dscrpt ); + if (ret < 0) { + gf_log ("glusterd", GF_LOG_ERROR, "Could not create an " + "xmlElemetnt"); + ret = -1; goto out; } - ret = dict_get_str (dict, VOLGEN_DHT_OPTION_UNHASHSTICKY, - &opt_unhashsticky); - if (ret) { + ret = xmlTextWriterWriteFormatElement(writer, (xmlChar *) "name", "%s", + name); + if (ret < 0) { + gf_log ("glusterd", GF_LOG_ERROR, "Could not create an " + "xmlElemetnt"); + ret = -1; goto out; } - for (i = 0; i < dist_count; i++) { - snprintf (tmp, 4096, "%s-%d ", subvolume, i); - strncat (subvol_str, tmp, strlen (tmp)); + ret = xmlTextWriterEndElement(writer); + if (ret < 0) { + gf_log ("glusterd", GF_LOG_ERROR, "Could not end an " + "xmlElemetnt"); + ret = -1; + goto out; } - fprintf (file, dht_str, - volname, - "dht", - opt_lookupunhash, - opt_minfreedisk, - opt_unhashsticky, - subvol_str); + ret = 0; + out: + gf_log ("glusterd", GF_LOG_DEBUG, "Returning %d", ret); + return ret; +} - ret = 0; +#endif + +static 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; + } + } + } + if (ret) + gf_log ("glusterd", GF_LOG_ERROR, "Wrong entry found in " + "glusterd_volopt_map entry %s", vme->key); + else + gf_log ("glusterd", GF_LOG_DEBUG, "Returning %d", ret); -out: return ret; } -static int -__write_wb_xlator (FILE *file, dict_t *dict, - char *subvolume) -{ - char *volname = NULL; - char *opt_flushbehind = NULL; - char *opt_cachesize = NULL; - char *opt_disablenbytes = NULL; - char *opt_osync = NULL; - char *opt_tricklingwrites = NULL; - int ret = -1; - - const char *dht_str = "volume %s-%s\n" - "type performance/write-behind\n" - "#option flush-behind %s\n" - "#option cache-size %s\n" - "#option disable-for-first-nbytes %s\n" - "#option enable-O_SYNC %s\n" - "#option enable-trickling-writes %s\n" - "subvolumes %s\n" - "end-volume\n\n"; - - ret = dict_get_str (dict, "volname", &volname); - if (ret) { - goto out; +static void +_free_xlator_opt_key (char *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); + + return; +} + +int +glusterd_get_volopt_content (dict_t * ctx, gf_boolean_t xml_out) +{ + void *dl_handle = NULL; + volume_opt_list_t vol_opt_handle = {{0},}; + char *key = NULL; + struct volopt_map_entry *vme = NULL; + int ret = -1; + char *def_val = NULL; + char *descr = NULL; + char output_string[25600] = {0, }; + char *output = NULL; + char tmp_str[2048] = {0, }; +#if (HAVE_LIB_XML) + xmlTextWriterPtr writer = NULL; + xmlBufferPtr buf = NULL; + + if (xml_out) { + ret = init_sethelp_xml_doc (&writer, &buf); + if (ret) /*logging done in init_xml_lib*/ + goto out; } +#endif - ret = dict_get_str (dict, VOLGEN_WB_OPTION_FLUSHBEHIND, - &opt_flushbehind); - if (ret) { - goto out; + INIT_LIST_HEAD (&vol_opt_handle.list); + + for (vme = &glusterd_volopt_map[0]; vme->key; vme++) { + + if ((vme->type == NO_DOC) || (vme->type == GLOBAL_NO_DOC)) + continue; + + if (vme->description) { + descr = vme->description; + def_val = vme->value; + } else { + if (_get_xlator_opt_key_from_vme (vme, &key)) { + gf_log ("glusterd", GF_LOG_DEBUG, "Failed to " + "get %s key from volume option entry", + vme->key); + goto out; /*Some error while geting key*/ + } + + ret = xlator_volopt_dynload (vme->voltype, + &dl_handle, + &vol_opt_handle); + + if (ret) { + gf_log ("glusterd", GF_LOG_DEBUG, + "xlator_volopt_dynload error(%d)", ret); + ret = 0; + goto cont; + } + + ret = xlator_option_info_list (&vol_opt_handle, key, + &def_val, &descr); + if (ret) { /*Swallow Error i.e if option not found*/ + gf_log ("glusterd", GF_LOG_DEBUG, + "Failed to get option for %s key", key); + ret = 0; + goto cont; + } + } + + if (xml_out) { +#if (HAVE_LIB_XML) + if (xml_add_volset_element (writer,vme->key, + def_val, descr)) { + ret = -1; + goto cont; + } +#else + gf_log ("glusterd", GF_LOG_ERROR, "Libxml not present"); +#endif + } else { + snprintf (tmp_str, sizeof (tmp_str), "Option: %s\nDefault " + "Value: %s\nDescription: %s\n\n", + vme->key, def_val, descr); + strcat (output_string, tmp_str); + } +cont: + if (dl_handle) { + dlclose (dl_handle); + dl_handle = NULL; + vol_opt_handle.given_opt = NULL; + } + if (key) { + _free_xlator_opt_key (key); + key = NULL; + } + if (ret) + goto out; } - ret = dict_get_str (dict, VOLGEN_WB_OPTION_CACHESIZE, - &opt_cachesize); - if (ret) { +#if (HAVE_LIB_XML) + if ((xml_out) && + (ret = end_sethelp_xml_doc (writer))) goto out; - } +#else + if (xml_out) + gf_log ("glusterd", GF_LOG_ERROR, "Libxml not present"); +#endif - ret = dict_get_str (dict, VOLGEN_WB_OPTION_DISABLENBYTES, - &opt_disablenbytes); - if (ret) { + if (!xml_out) + output = gf_strdup (output_string); + else +#if (HAVE_LIB_XML) + output = gf_strdup ((char *)buf->content); +#else + gf_log ("glusterd", GF_LOG_ERROR, "Libxml not present"); +#endif + + if (NULL == output) { + ret = -1; goto out; } - ret = dict_get_str (dict, VOLGEN_WB_OPTION_OSYNC, - &opt_osync); - if (ret) { + ret = dict_set_dynstr (ctx, "help-str", output); +out: + gf_log ("glusterd", GF_LOG_DEBUG, "Returning %d", ret); + return ret; + +} + +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; + uint32_t client_type = GF_CLIENT_OTHER; + char transt[16] = {0,}; + char *volname = NULL; + char *str = NULL; + glusterd_brickinfo_t *brick = NULL; + xlator_t *xl = NULL; + char *ssl_str = NULL; + gf_boolean_t ssl_bool; + + volname = volinfo->volname; + + if (volinfo->brick_count == 0) { + gf_log ("", GF_LOG_ERROR, + "volume inconsistency: brick count is 0"); goto out; } - ret = dict_get_str (dict, VOLGEN_WB_OPTION_TRICKLINGWRITES, - &opt_tricklingwrites); - if (ret) { + if ((volinfo->dist_leaf_count < volinfo->brick_count) && + ((volinfo->brick_count % volinfo->dist_leaf_count) != 0)) { + gf_log ("", GF_LOG_ERROR, + "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; } - fprintf (file, dht_str, - volname, - "write-behind", - opt_flushbehind, - opt_cachesize, - opt_disablenbytes, - opt_osync, - opt_tricklingwrites, - subvolume); + get_transport_type (volinfo, set_dict, transt, _gf_false); + if (!strcmp (transt, "tcp,rdma")) + strcpy (transt, "tcp"); - ret = 0; + i = 0; + ret = -1; + list_for_each_entry (brick, &volinfo->bricks, brick_list) { + ret = -1; + xl = volgen_graph_add_nolink (graph, "protocol/client", + "%s-client-%d", volname, i); + if (!xl) + goto out; + ret = xlator_set_option (xl, "remote-host", brick->hostname); + if (ret) + goto out; + ret = xlator_set_option (xl, "remote-subvolume", brick->path); + if (ret) + goto out; + ret = xlator_set_option (xl, "transport-type", transt); + if (ret) + goto out; + ret = dict_get_uint32 (set_dict, "trusted-client", + &client_type); + + if (!ret && client_type == GF_CLIENT_TRUSTED) { + str = NULL; + str = glusterd_auth_get_username (volinfo); + if (str) { + ret = xlator_set_option (xl, "username", + str); + if (ret) + goto out; + } + + str = glusterd_auth_get_password (volinfo); + if (str) { + ret = xlator_set_option (xl, "password", + str); + if (ret) + goto out; + } + } + + 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 out; + } + } + } + } + + i++; + } + + if (i != volinfo->brick_count) { + gf_log ("", GF_LOG_ERROR, + "volume inconsistency: actual number of bricks (%d) " + "differs from brick count (%d)", i, + volinfo->brick_count); + + ret = -1; + goto out; + } + ret = 0; out: return ret; } static int -__write_ra_xlator (FILE *file, dict_t *dict, - char *subvolume) -{ - char *volname = NULL; - char *opt_atime = NULL; - char *opt_pagecount = NULL; - int ret = -1; - - const char *ra_str = "volume %s-%s\n" - "type performance/read-ahead\n" - "#option force-atime-update %s\n" - "#option page-count %s\n" - "subvolumes %s\n" - "end-volume\n\n"; - - ret = dict_get_str (dict, "volname", &volname); - if (ret) { +volgen_graph_build_clusters (volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, char *xl_type, + char *xl_namefmt, size_t child_count, + size_t sub_count) +{ + int i = 0; + int j = 0; + xlator_t *txl = NULL; + xlator_t *xl = NULL; + xlator_t *trav = NULL; + char *volname = NULL; + int ret = -1; + + if (child_count == 0) goto out; + volname = volinfo->volname; + txl = first_of (graph); + for (trav = txl; --child_count; trav = trav->next); + 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++; + } + + ret = volgen_xlator_link (xl, trav); + if (ret) + goto out; + + if (trav == txl) + break; + + i++; } - ret = dict_get_str (dict, VOLGEN_RA_OPTION_ATIME, - &opt_atime); + ret = j; +out: + 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_log ("glusterd", GF_LOG_ERROR, "Failed to get remote-host " + "from client %s", xl->name); goto out; } - - ret = dict_get_str (dict, VOLGEN_RA_OPTION_PAGECOUNT, - &opt_pagecount); + ret = xlator_get_option (xl, "remote-subvolume", &path); if (ret) { + GF_ASSERT (0); + gf_log ("glusterd", GF_LOG_ERROR, "Failed to get remote-host " + "from client %s", xl->name); goto out; } - fprintf (file, ra_str, - volname, - "read-ahead", - opt_atime, - opt_pagecount, - subvolume); + decommissioned = glusterd_is_brick_decommissioned (volinfo, hostname, + path); +out: + 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; - ret = 0; + 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 ret; + return decommissioned; } static int -__write_iocache_xlator (FILE *file, dict_t *dict, - char *subvolume) -{ - char *volname = NULL; - char *opt_priority = NULL; - char *opt_timeout = NULL; - char *opt_cachesize = NULL; - char *opt_minfilesize = NULL; - char *opt_maxfilesize = NULL; - int ret = -1; - - const char *iocache_str = "volume %s-%s\n" - "type performance/io-cache\n" - "#option priority %s\n" - "#option cache-timeout %s\n" - "#option cache-size %s\n" - "#option min-file-size %s\n" - "#option max-file-size %s\n" - "subvolumes %s\n" - "end-volume\n\n"; - - ret = dict_get_str (dict, "volname", &volname); - if (ret) { - goto out; +_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; +} - ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_PRIORITY, - &opt_priority); - if (ret) { +static int +volgen_graph_build_dht_cluster (volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, size_t child_count) +{ + int32_t clusters = 0; + int ret = -1; + char *decommissioned_children = NULL; + xlator_t *dht = NULL; + char *voltype = "cluster/distribute"; + + /* NUFA and Switch section */ + if (dict_get_str_boolean (volinfo->dict, "cluster.nufa", 0) && + dict_get_str_boolean (volinfo->dict, "cluster.switch", 0)) { + gf_log (THIS->name, GF_LOG_ERROR, + "nufa and switch cannot be set together"); + ret = -1; goto out; } - ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_TIMEOUT, - &opt_timeout); - if (ret) { + /* 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"; + + clusters = volgen_graph_build_clusters (graph, volinfo, + voltype, + "%s-dht", + child_count, + child_count); + if (clusters < 0) goto out; - } - ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_CACHESIZE, - &opt_cachesize); - if (ret) { + 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; +} - ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_MINFILESIZE, - &opt_minfilesize); - if (ret) { +static int +volume_volgen_graph_build_clusters (volgen_graph_t *graph, + glusterd_volinfo_t *volinfo) +{ + char *replicate_args[] = {"cluster/replicate", + "%s-replicate-%d"}; + char *stripe_args[] = {"cluster/stripe", + "%s-stripe-%d"}; + int rclusters = 0; + int clusters = 0; + int dist_count = 0; + int ret = -1; + + 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_clusters (graph, volinfo, + replicate_args[0], + replicate_args[1], + volinfo->brick_count, + volinfo->replica_count); + if (clusters < 0) + goto out; + break; + case GF_CLUSTER_TYPE_STRIPE: + clusters = volgen_graph_build_clusters (graph, volinfo, + stripe_args[0], + stripe_args[1], + volinfo->brick_count, + volinfo->stripe_count); + if (clusters < 0) + goto out; + break; + case GF_CLUSTER_TYPE_STRIPE_REPLICATE: + /* Replicate after the clients, then stripe */ + if (volinfo->replica_count == 0) + goto out; + clusters = volgen_graph_build_clusters (graph, volinfo, + replicate_args[0], + replicate_args[1], + volinfo->brick_count, + volinfo->replica_count); + if (clusters < 0) + goto out; + + rclusters = volinfo->brick_count / volinfo->replica_count; + GF_ASSERT (rclusters == clusters); + clusters = volgen_graph_build_clusters (graph, volinfo, + stripe_args[0], + stripe_args[1], + rclusters, + volinfo->stripe_count); + if (clusters < 0) + goto out; + break; + default: + gf_log ("", GF_LOG_ERROR, "volume inconsistency: " + "unrecognized clustering type"); goto out; } - ret = dict_get_str (dict, VOLGEN_IOCACHE_OPTION_MAXFILESIZE, - &opt_maxfilesize); - if (ret) { +build_distribute: + dist_count = volinfo->brick_count / volinfo->dist_leaf_count; + if (!dist_count) { + ret = -1; goto out; } - fprintf (file, iocache_str, - volname, - "io-cache", - opt_priority, - opt_timeout, - opt_cachesize, - opt_minfilesize, - opt_maxfilesize, - subvolume); - + ret = volgen_graph_build_dht_cluster (graph, volinfo, + dist_count); + if (ret == -1) + goto out; ret = 0; - out: return ret; } +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; + + /* + * Logic to make sure NFS doesn't have performance translators by + * default for a volume + */ + volname = volinfo->volname; + tmp_data = dict_get (set_dict, "nfs-volume-file"); + if (!tmp_data) + return volgen_graph_set_options_generic(graph, set_dict, + volname, + &perfxl_option_handler); + else + return volgen_graph_set_options_generic(graph, set_dict, + volname, + &nfsperfxl_option_handler); +} + static int -__write_qr_xlator (FILE *file, dict_t *dict, - char *subvolume) -{ - char *volname = NULL; - char *opt_priority = NULL; - char *opt_timeout = NULL; - char *opt_cachesize = NULL; - char *opt_maxfilesize = NULL; - int ret = -1; - - const char *qr_str = "volume %s-%s\n" - "type performance/quick-read\n" - "#option priority %s\n" - "#option cache-timeout %s\n" - "#option cache-size %s\n" - "#option max-file-size %s\n" - "subvolumes %s\n" - "end-volume\n\n"; - - ret = dict_get_str (dict, "volname", &volname); - if (ret) { +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; + + volname = volinfo->volname; + ret = volgen_graph_build_clients (graph, volinfo, set_dict, param); + if (ret) goto out; - } - ret = dict_get_str (dict, VOLGEN_QR_OPTION_PRIORITY, - &opt_priority); - if (ret) { + ret = volume_volgen_graph_build_clusters (graph, volinfo); + if (ret == -1) goto out; + + /* Check for compress volume option, and add it to the graph on client side */ + if (dict_get_str_boolean (set_dict, "features.compress", 0)) { + xl = volgen_graph_add (graph, "features/cdc", volname); + if (!xl) { + ret = -1; + goto out; + } + ret = dict_set_str (set_dict, "compress.mode", "client"); + if (ret) + goto out; + } - ret = dict_get_str (dict, VOLGEN_QR_OPTION_TIMEOUT, - &opt_timeout); - if (ret) { + ret = glusterd_volinfo_get_boolean (volinfo, "features.encryption"); + if (ret == -1) goto out; + if (ret) { + xl = volgen_graph_add (graph, "encryption/crypt", volname); + + if (!xl) { + ret = -1; + goto out; + } } - ret = dict_get_str (dict, VOLGEN_QR_OPTION_CACHESIZE, - &opt_cachesize); - if (ret) { + 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; + } } - ret = dict_get_str (dict, VOLGEN_QR_OPTION_MAXFILESIZE, - &opt_maxfilesize); - if (ret) { + + ret = glusterd_volinfo_get_boolean (volinfo, "features.file-snapshot"); + if (ret == -1) goto out; + if (ret) { + xl = volgen_graph_add (graph, "features/qemu-block", volname); + + if (!xl) { + ret = -1; + goto out; + } } - fprintf (file, qr_str, - volname, - "quick-read", - opt_priority, - opt_timeout, - opt_cachesize, - opt_maxfilesize, - subvolume); + ret = client_graph_set_perf_options(graph, volinfo, set_dict); + if (ret) + goto out; - ret = 0; + /* add debug translators depending on the options */ + ret = check_and_add_debug_xl (graph, set_dict, volname, + "client"); + if (ret) + return -1; + ret = -1; + xl = volgen_graph_add_as (graph, "debug/io-stats", volname); + if (!xl) + goto out; + + ret = volgen_graph_set_options_generic (graph, set_dict, "client", + &loglevel_option_handler); + + if (ret) + gf_log (THIS->name, GF_LOG_WARNING, "changing client log level" + " failed"); + + ret = volgen_graph_set_options_generic (graph, set_dict, "client", + &sys_loglevel_option_handler); + if (ret) + gf_log (THIS->name, GF_LOG_WARNING, "changing client syslog " + "level failed"); out: return ret; } + +/* builds a graph for client role , with option overrides in mod_dict */ static int -__write_statprefetch_xlator (FILE *file, dict_t *dict, - char *subvolume) +build_client_graph (volgen_graph_t *graph, glusterd_volinfo_t *volinfo, + dict_t *mod_dict) { - char *volname = NULL; - int ret = -1; + return build_graph_generic (graph, volinfo, mod_dict, NULL, + &client_graph_builder); +} - const char *statprefetch_str = "volume %s-%s\n" - "type performance/stat-prefetch\n" - "subvolumes %s\n" - "end-volume\n\n"; +char *gd_shd_options[] = { + "!self-heal-daemon", + "!heal-timeout", + NULL +}; - ret = dict_get_str (dict, "volname", &volname); - if (ret) { - goto out; - } +char* +gd_get_matching_option (char **options, char *option) +{ + while (*options && strcmp (*options, option)) + options++; + return *options; +} - fprintf (file, statprefetch_str, - volname, - "stat-prefetch", - subvolume); +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; - ret = 0; + 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; } static int -generate_server_volfile (glusterd_brickinfo_t *brickinfo, - dict_t *dict, - const char *filename) +nfs_option_handler (volgen_graph_t *graph, + struct volopt_map_entry *vme, void *param) { - FILE *file = NULL; - char subvol[2048] = {0,}; - char *volname = NULL; - int ret = -1; + xlator_t *xl = NULL; + char *aa = NULL; + int ret = 0; + glusterd_volinfo_t *volinfo = NULL; - GF_ASSERT (filename); + volinfo = param; - file = fopen (filename, "w+"); - if (!file) { - gf_log ("", GF_LOG_DEBUG, - "Could not open file %s", filename); - ret = -1; - goto out; + xl = first_of (graph); + +/* if (vme->type == GLOBAL_DOC || vme->type == GLOBAL_NO_DOC) { + + ret = xlator_set_option (xl, vme->key, vme->value); + }*/ + 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 (ret != -1) { + ret = xlator_set_option (xl, aa, vme->value); + GF_FREE (aa); + } + + if (ret) + return -1; } - ret = dict_get_str (dict, "volname", &volname); - if (ret) { - goto out; + if (! strcmp (vme->option, "!rpc-auth.addr.*.reject")) { + ret = gf_asprintf (&aa, "rpc-auth.addr.%s.reject", + volinfo->volname); + + if (ret != -1) { + ret = xlator_set_option (xl, aa, vme->value); + GF_FREE (aa); + } + + if (ret) + return -1; } - /* Call functions in the same order - as you'd call if you were manually - writing a volfile top-down - */ + if (! strcmp (vme->option, "!rpc-auth.auth-unix.*")) { + ret = gf_asprintf (&aa, "rpc-auth.auth-unix.%s", + volinfo->volname); - ret = __write_posix_xlator (file, dict, brickinfo->path); - if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Could not write xlator"); - goto out; + 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); - VOLGEN_GENERATE_VOLNAME (subvol, volname, "posix"); + if (ret != -1) { + ret = xlator_set_option (xl, aa, vme->value); + GF_FREE (aa); + } - ret = __write_locks_xlator (file, dict, subvol); - if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Could not write xlator"); - goto out; + if (ret) + return -1; } - VOLGEN_GENERATE_VOLNAME (subvol, volname, "locks"); + if (! strcmp (vme->option, "!nfs3.*.trusted-sync")) { + ret = gf_asprintf (&aa, "nfs3.%s.trusted-sync", + volinfo->volname); - ret = __write_replace_brick_xlator (file, dict); - if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Could not write xlator"); - goto out; + if (ret != -1) { + ret = xlator_set_option (xl, aa, vme->value); + GF_FREE (aa); + } + + if (ret) + return -1; } - ret = __write_pump_xlator (file, dict, subvol); - if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Could not write xlator"); - goto out; + if (! strcmp (vme->option, "!nfs3.*.trusted-write")) { + ret = gf_asprintf (&aa, "nfs3.%s.trusted-write", + volinfo->volname); + + if (ret != -1) { + ret = xlator_set_option (xl, aa, vme->value); + GF_FREE (aa); + } + + if (ret) + return -1; } - VOLGEN_GENERATE_VOLNAME (subvol, volname, "pump"); + if (! strcmp (vme->option, "!nfs3.*.volume-access")) { + ret = gf_asprintf (&aa, "nfs3.%s.volume-access", + volinfo->volname); - ret = dict_set_str (dict, "export-path", brickinfo->path); - if (ret) { - goto out; + if (ret != -1) { + ret = xlator_set_option (xl, aa, vme->value); + GF_FREE (aa); + } + + if (ret) + return -1; } - ret = __write_iothreads_xlator (file, dict, subvol); - if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Could not write xlator"); - goto out; + if (! strcmp (vme->option, "!nfs3.*.export-dir")) { + ret = gf_asprintf (&aa, "nfs3.%s.export-dir", + volinfo->volname); + + if (ret != -1) { + ret = gf_canonicalize_path (vme->value); + if (ret) + return -1; + + ret = xlator_set_option (xl, aa, vme->value); + GF_FREE (aa); + } + + if (ret) + return -1; } - ret = __write_server_xlator (file, dict, brickinfo->path); - if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Could not write xlator"); - goto out; + + + 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; } - fclose (file); - file = NULL; -out: + 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 (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; + } + + + /*key = strchr (vme->key, '.') + 1; + + for (trav = xl->children; trav; trav = trav->next) { + ret = gf_asprintf (&aa, "auth.addr.%s.%s", trav->xlator->name, + key); + if (ret != -1) { + ret = xlator_set_option (xl, aa, vme->value); + GF_FREE (aa); + } + if (ret) + return -1; + }*/ + + return 0; +} + +static int +volgen_graph_set_iam_shd (volgen_graph_t *graph) +{ + xlator_t *trav; + int ret = 0; + + for (trav = first_of (graph); trav; trav = trav->next) { + if (strcmp (trav->type, "cluster/replicate") != 0) + continue; + + ret = xlator_set_option (trav, "iam-self-heal-daemon", "yes"); + if (ret) + break; + } return ret; } static int -generate_client_volfile (glusterd_volinfo_t *volinfo, char *filename) -{ - FILE *file = NULL; - dict_t *dict = NULL; - char *volname = NULL; - glusterd_brickinfo_t *brick = NULL; - char subvol[2048] = {0,}; - int32_t replicate_count = 0; - int32_t stripe_count = 0; - int32_t dist_count = 0; - int32_t num_bricks = 0; - int count = 0; - int i = 0; - int ret = -1; - - GF_ASSERT (filename); +build_shd_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; + gf_boolean_t valid_config = _gf_false; + xlator_t *iostxl = NULL; + int rclusters = 0; + int replica_count = 0; + gf_boolean_t graph_check = _gf_false; + + this = THIS; + priv = this->private; + + set_dict = dict_new (); + if (!set_dict) { + ret = -ENOMEM; + goto out; + } + + 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; + } - volname = volinfo->volname; - dict = volinfo->dict; + list_for_each_entry (voliter, &priv->volumes, vol_list) { + if (!graph_check && + (voliter->status != GLUSTERD_STATUS_STARTED)) + continue; + + if (!glusterd_is_volume_replicate (voliter)) + continue; - list_for_each_entry (brick, &volinfo->bricks, brick_list) - num_bricks++; + replica_count = voliter->replica_count; - if (GF_CLUSTER_TYPE_REPLICATE == volinfo->type) { - ret = dict_get_int32 (dict, "replica-count", - &replicate_count); + valid_config = _gf_true; + + ret = dict_set_str (set_dict, "cluster.self-heal-daemon", "on"); if (ret) goto out; - gf_log ("", GF_LOG_DEBUG, - "Volfile is distributed-replicated"); - dist_count = num_bricks / replicate_count; + ret = dict_set_uint32 (set_dict, "trusted-client", + GF_CLIENT_TRUSTED); + if (ret) + goto out; + + dict_copy (voliter->dict, set_dict); + if (mod_dict) + dict_copy (mod_dict, set_dict); - } else if (GF_CLUSTER_TYPE_STRIPE == volinfo->type) { - ret = dict_get_int32 (dict, "stripe-count", - &stripe_count); + memset (&cgraph, 0, sizeof (cgraph)); + ret = volgen_graph_build_clients (&cgraph, voliter, set_dict, + NULL); if (ret) goto out; - gf_log ("", GF_LOG_DEBUG, - "Volfile is distributed-striped"); - dist_count = num_bricks / stripe_count; - } else { - gf_log ("", GF_LOG_DEBUG, - "Volfile is plain distributed"); - dist_count = num_bricks; - } + rclusters = volgen_graph_build_clusters (&cgraph, voliter, + "cluster/replicate", + "%s-replicate-%d", + voliter->brick_count, + replica_count); + if (rclusters < 0) { + ret = -1; + goto out; + } + ret = volgen_graph_set_options_generic (&cgraph, set_dict, voliter, + shd_option_handler); + if (ret) + goto out; - file = fopen (filename, "w+"); - if (!file) { - gf_log ("", GF_LOG_DEBUG, - "Could not open file %s", filename); - ret = -1; - goto out; - } + ret = volgen_graph_set_iam_shd (&cgraph); + if (ret) + goto out; - /* Call functions in the same order - as you'd call if you were manually - writing a volfile top-down - */ + ret = volgen_graph_merge_sub (graph, &cgraph, rclusters); + if (ret) + goto out; - count = 0; + ret = volgen_graph_set_options_generic (graph, set_dict, + "client", + &loglevel_option_handler); - list_for_each_entry (brick, &volinfo->bricks, brick_list) { + if (ret) + gf_log (THIS->name, GF_LOG_WARNING, "changing loglevel " + "of self-heal daemon failed"); - ret = __write_client_xlator (file, dict, brick->path, - brick->hostname, count); - if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Could not write xlator"); + ret = volgen_graph_set_options_generic (graph, set_dict, + "client", + &sys_loglevel_option_handler); + if (ret) + gf_log (THIS->name, GF_LOG_WARNING, "changing syslog " + "level of self-heal daemon failed"); + + ret = dict_reset (set_dict); + if (ret) goto out; - } + } +out: + if (set_dict) + dict_unref (set_dict); + if (!valid_config) + ret = -EINVAL; + return ret; +} - count++; +/* builds a graph for nfs server role, with option overrides in mod_dict */ +static 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_log ("", GF_LOG_ERROR, "Out of memory"); + return -1; } - if (stripe_count && replicate_count) { - gf_log ("", GF_LOG_DEBUG, - "Striped Replicate config not allowed"); + 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; - if (replicate_count > 1) { - for (i = 0; i < dist_count; i++) { + ret = xlator_set_option (nfsxl, "nfs.drc", "on"); + if (ret) + goto out; - VOLGEN_GENERATE_VOLNAME (subvol, volname, "client"); + list_for_each_entry (voliter, &priv->volumes, vol_list) { + if (voliter->status != GLUSTERD_STATUS_STARTED) + continue; - ret = __write_replicate_xlator (file, dict, subvol, - replicate_count, i); - if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Count not write xlator"); - goto out; - } + if (dict_get_str_boolean (voliter->dict, "nfs.disable", 0)) + continue; + + ret = gf_asprintf (&skey, "rpc-auth.addr.%s.allow", + voliter->volname); + if (ret == -1) { + gf_log ("", GF_LOG_ERROR, "Out of memory"); + goto out; } - } + ret = xlator_set_option (nfsxl, skey, "*"); + GF_FREE (skey); + if (ret) + goto out; - if (stripe_count > 1) { - for (i = 0; i < dist_count; i++) { + ret = gf_asprintf (&skey, "nfs3.%s.volume-id", + voliter->volname); + if (ret == -1) { + gf_log ("", GF_LOG_ERROR, "Out of memory"); + goto out; + } + ret = xlator_set_option (nfsxl, skey, uuid_utoa (voliter->volume_id)); + GF_FREE (skey); + if (ret) + goto out; - VOLGEN_GENERATE_VOLNAME (subvol, volname, "client"); + /* If both RDMA and TCP are the transport_type, use RDMA + for NFS client protocols */ + 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 = __write_stripe_xlator (file, dict, subvol, - stripe_count, i); - if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Count not write xlator"); - goto out; - } + ret = dict_set_str (set_dict, "performance.stat-prefetch", "off"); + 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, "client-transport-type", + nfs_xprt); + 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, "nfs-volume-file", "yes"); + 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 = build_client_graph (&cgraph, voliter, set_dict); + if (ret) + goto out; - if (dist_count > 1) { - if (replicate_count) { - VOLGEN_GENERATE_VOLNAME (subvol, volname, - "replicate"); - } else if (stripe_count) { - VOLGEN_GENERATE_VOLNAME (subvol, volname, - "stripe"); + if (mod_dict) { + dict_copy (mod_dict, set_dict); + ret = volgen_graph_set_options_generic (&cgraph, set_dict, voliter, + basic_option_handler); } else { - VOLGEN_GENERATE_VOLNAME (subvol, volname, - "client"); + ret = volgen_graph_set_options_generic (&cgraph, voliter->dict, voliter, + basic_option_handler); } + if (ret) + goto out; - ret = __write_distribute_xlator (file, - dict, - subvol, - dist_count); - if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Count not write xlator"); + ret = volgen_graph_merge_sub (graph, &cgraph, 1); + if (ret) + goto out; + ret = dict_reset (set_dict); + if (ret) goto out; - } } + list_for_each_entry (voliter, &priv->volumes, vol_list) { - if (dist_count > 1) { - VOLGEN_GENERATE_VOLNAME (subvol, volname, "dht"); - ret = __write_wb_xlator (file, dict, subvol); - } - else if (replicate_count > 1) { - VOLGEN_GENERATE_VOLNAME (subvol, volname, "replicate-0"); - ret = __write_wb_xlator (file, dict, subvol); - } - else if (stripe_count > 1) { - VOLGEN_GENERATE_VOLNAME (subvol, volname, "stripe-0"); - ret = __write_wb_xlator (file, dict, subvol); + 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); + } + + if (ret) + gf_log ("glusterd", GF_LOG_WARNING, "Could not set " + "vol-options for the volume %s", voliter->volname); } - else { - VOLGEN_GENERATE_VOLNAME (subvol, volname, "client-0"); - ret = __write_wb_xlator (file, dict, subvol); + + out: + gf_log ("glusterd", GF_LOG_DEBUG, "Returning %d", ret); + dict_destroy (set_dict); + + return ret; +} + + + + +/**************************** + * + * Volume generation interface + * + ****************************/ + + +static void +get_brick_filepath (char *filename, glusterd_volinfo_t *volinfo, + glusterd_brickinfo_t *brickinfo) +{ + char path[PATH_MAX] = {0,}; + char brick[PATH_MAX] = {0,}; + glusterd_conf_t *priv = NULL; + + priv = THIS->private; + + GLUSTERD_REMOVE_SLASH_FROM_PATH (brickinfo->path, brick); + GLUSTERD_GET_VOLUME_DIR (path, volinfo, priv); + + snprintf (filename, PATH_MAX, "%s/%s.%s.%s.vol", + path, volinfo->volname, + brickinfo->hostname, + brick); +} + +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); + if (ret) { + gf_log (this->name, GF_LOG_WARNING, "Failed to create brickinfo" + " for brick %s", brick ); + ret = 0; + goto out; } + ret = glusterd_volinfo_new (&volinfo); if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Could not write xlator"); + gf_log (this->name, GF_LOG_WARNING, "Failed to create volinfo"); + ret = 0; goto out; } + strncpy (volinfo->volname, volname, sizeof (volinfo->volname)); + get_brick_filepath (volfpath, volinfo, brickinfo); + + ret = (strlen (volfpath) < _POSIX_PATH_MAX); +out: + if (brickinfo) + glusterd_brickinfo_delete (brickinfo); + if (volinfo) + glusterd_volinfo_delete (volinfo); + return ret; +} + +static int +glusterd_generate_brick_volfile (glusterd_volinfo_t *volinfo, + glusterd_brickinfo_t *brickinfo) +{ + volgen_graph_t graph = {0,}; + char filename[PATH_MAX] = {0,}; + int ret = -1; + + GF_ASSERT (volinfo); + GF_ASSERT (brickinfo); + + get_brick_filepath (filename, volinfo, brickinfo); + + ret = build_server_graph (&graph, volinfo, NULL, brickinfo); + if (!ret) + ret = volgen_write_volfile (&graph, filename); + + volgen_graph_free (&graph); + + return ret; +} + +static void +get_vol_tstamp_file (char *filename, glusterd_volinfo_t *volinfo) +{ + glusterd_conf_t *priv = NULL; + + priv = THIS->private; + + GLUSTERD_GET_VOLUME_DIR (filename, volinfo, priv); + strncat (filename, "/marker.tstamp", + PATH_MAX - strlen(filename) - 1); +} + +int +generate_brick_volfiles (glusterd_volinfo_t *volinfo) +{ + glusterd_brickinfo_t *brickinfo = NULL; + char tstamp_file[PATH_MAX] = {0,}; + int ret = -1; + + ret = glusterd_volinfo_get_boolean (volinfo, VKEY_MARKER_XTIME); + if (ret == -1) + return -1; + + get_vol_tstamp_file (tstamp_file, volinfo); - VOLGEN_GENERATE_VOLNAME (subvol, volname, "write-behind"); - ret = __write_ra_xlator (file, dict, subvol); if (ret) { + ret = open (tstamp_file, O_WRONLY|O_CREAT|O_EXCL, 0600); + if (ret == -1 && errno == EEXIST) { + gf_log ("", GF_LOG_DEBUG, "timestamp file exist"); + ret = -2; + } + if (ret == -1) { + gf_log ("", GF_LOG_ERROR, "failed to create %s (%s)", + tstamp_file, strerror (errno)); + return -1; + } + if (ret >= 0) + close (ret); + } else { + ret = unlink (tstamp_file); + if (ret == -1 && errno == ENOENT) + ret = 0; + if (ret == -1) { + gf_log ("", GF_LOG_ERROR, "failed to unlink %s (%s)", + tstamp_file, strerror (errno)); + return -1; + } + } + + list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { gf_log ("", GF_LOG_DEBUG, - "Could not write xlator"); - goto out; + "Found a brick - %s:%s", brickinfo->hostname, + brickinfo->path); + + ret = glusterd_generate_brick_volfile (volinfo, brickinfo); + if (ret) + goto out; + + } + + ret = 0; + +out: + gf_log ("", GF_LOG_DEBUG, "Returning %d", ret); + return ret; +} + +static int +generate_single_transport_client_volfile (glusterd_volinfo_t *volinfo, + char *filepath, dict_t *dict) +{ + volgen_graph_t graph = {0,}; + int ret = -1; + + ret = build_client_graph (&graph, volinfo, dict); + if (!ret) + ret = volgen_write_volfile (&graph, filepath); + + volgen_graph_free (&graph); + + return ret; +} + +static void +enumerate_transport_reqs (gf_transport_type type, char **types) +{ + switch (type) { + case GF_TRANSPORT_TCP: + types[0] = "tcp"; + break; + case GF_TRANSPORT_RDMA: + types[0] = "rdma"; + break; + case GF_TRANSPORT_BOTH_TCP_RDMA: + types[0] = "tcp"; + types[1] = "rdma"; + break; + } +} + +int +generate_client_volfiles (glusterd_volinfo_t *volinfo, + glusterd_client_type_t client_type) +{ + char filepath[PATH_MAX] = {0,}; + int ret = -1; + char *types[] = {NULL, NULL, NULL}; + int i = 0; + dict_t *dict = NULL; + gf_transport_type type = GF_TRANSPORT_TCP; + + enumerate_transport_reqs (volinfo->transport_type, types); + dict = dict_new (); + if (!dict) + goto out; + for (i = 0; types[i]; i++) { + memset (filepath, 0, sizeof (filepath)); + 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) { + glusterd_get_trusted_client_filepath (filepath, + volinfo, + type); + } else { + glusterd_get_client_filepath (filepath, + volinfo, + type); + } + + ret = generate_single_transport_client_volfile (volinfo, + filepath, + dict); + if (ret) + goto out; } +out: + if (dict) + dict_unref (dict); + return ret; +} - VOLGEN_GENERATE_VOLNAME (subvol, volname, "read-ahead"); - ret = __write_iocache_xlator (file, dict, subvol); +int +glusterd_create_rb_volfiles (glusterd_volinfo_t *volinfo, + glusterd_brickinfo_t *brickinfo) +{ + int ret = -1; + + ret = glusterd_generate_brick_volfile (volinfo, brickinfo); + if (!ret) + ret = generate_client_volfiles (volinfo, GF_CLIENT_TRUSTED); + if (!ret) + ret = glusterd_fetchspec_notify (THIS); + + return ret; +} + +int +glusterd_create_volfiles_and_notify_services (glusterd_volinfo_t *volinfo) +{ + int ret = -1; + xlator_t *this = NULL; + + this = THIS; + + ret = generate_brick_volfiles (volinfo); if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Could not write xlator"); + gf_log (this->name, GF_LOG_ERROR, + "Could not generate volfiles for bricks"); goto out; } - VOLGEN_GENERATE_VOLNAME (subvol, volname, "io-cache"); - ret = __write_qr_xlator (file, dict, subvol); + ret = generate_client_volfiles (volinfo, GF_CLIENT_TRUSTED); if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Could not write xlator"); + gf_log (this->name, GF_LOG_ERROR, + "Could not generate trusted client volfiles"); goto out; } - VOLGEN_GENERATE_VOLNAME (subvol, volname, "quick-read"); - ret = __write_statprefetch_xlator (file, dict, subvol); + ret = generate_client_volfiles (volinfo, GF_CLIENT_OTHER); if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Could not write xlator"); + gf_log (this->name, GF_LOG_ERROR, + "Could not generate client volfiles"); goto out; } - fclose (file); - file = NULL; + ret = glusterd_fetchspec_notify (this); out: return ret; } -static char * -get_brick_filename (glusterd_volinfo_t *volinfo, - glusterd_brickinfo_t *brickinfo) +int +glusterd_create_global_volfile (int (*builder) (volgen_graph_t *graph, + dict_t *set_dict), + char *filepath, dict_t *mod_dict) { - char path[PATH_MAX] = {0,}; - char *ret = NULL; - char brick[PATH_MAX] = {0,}; - char *filename = NULL; - int i = 0; + volgen_graph_t graph = {0,}; + int ret = -1; + + ret = builder (&graph, mod_dict); + if (!ret) + ret = volgen_write_volfile (&graph, filepath); + + volgen_graph_free (&graph); + + return ret; +} + +int +glusterd_create_nfs_volfile () +{ + char filepath[PATH_MAX] = {0,}; + glusterd_conf_t *conf = THIS->private; + + glusterd_get_nodesvc_volfile ("nfs", conf->workdir, + filepath, sizeof (filepath)); + return glusterd_create_global_volfile (build_nfs_graph, + filepath, NULL); +} + +int +glusterd_create_shd_volfile () +{ + char filepath[PATH_MAX] = {0,}; + int ret = -1; + glusterd_conf_t *conf = THIS->private; + dict_t *mod_dict = NULL; + + mod_dict = dict_new (); + if (!mod_dict) + goto out; + + ret = dict_set_uint32 (mod_dict, "cluster.background-self-heal-count", 0); + if (ret) + goto out; + + ret = dict_set_str (mod_dict, "cluster.data-self-heal", "on"); + if (ret) + goto out; + + ret = dict_set_str (mod_dict, "cluster.metadata-self-heal", "on"); + if (ret) + goto out; + + ret = dict_set_str (mod_dict, "cluster.entry-self-heal", "on"); + if (ret) + goto out; + + glusterd_get_nodesvc_volfile ("glustershd", conf->workdir, + filepath, sizeof (filepath)); + ret = glusterd_create_global_volfile (build_shd_graph, filepath, + mod_dict); +out: + if (mod_dict) + dict_unref (mod_dict); + return ret; +} - filename = GF_CALLOC (1, PATH_MAX, gf_gld_mt_char); - if (!filename) +int +glusterd_check_nfs_topology_identical (gf_boolean_t *identical) +{ + char nfsvol[PATH_MAX] = {0,}; + char tmpnfsvol[PATH_MAX] = {0,}; + glusterd_conf_t *conf = NULL; + xlator_t *this = THIS; + int ret = -1; + int tmpclean = 0; + int tmpfd = -1; + + if ((!identical) || (!this) || (!this->private)) goto out; - /* TODO: make this part a macro, so everyone uses same thing */ - for (i = 1; i < strlen (brickinfo->path); i++) { - brick[i-1] = brickinfo->path[i]; - if (brick[i-1] == '/') - brick[i-1] = '-'; + conf = (glusterd_conf_t *) this->private; + + /* Fetch the original NFS volfile */ + glusterd_get_nodesvc_volfile ("nfs", conf->workdir, + nfsvol, sizeof (nfsvol)); + + /* Create the temporary NFS volfile */ + snprintf (tmpnfsvol, sizeof (tmpnfsvol), "/tmp/gnfs-XXXXXX"); + tmpfd = mkstemp (tmpnfsvol); + if (tmpfd < 0) { + gf_log (this->name, GF_LOG_WARNING, + "Unable to create temp file %s: (%s)", + tmpnfsvol, strerror (errno)); + goto out; } - VOLGEN_GET_VOLUME_DIR (path, volinfo); + tmpclean = 1; /* SET the flag to unlink() tmpfile */ - snprintf (filename, PATH_MAX, "%s/%s.%s.%s.vol", - path, volinfo->volname, - brickinfo->hostname, - brick); + ret = glusterd_create_global_volfile (build_nfs_graph, + tmpnfsvol, NULL); + if (ret) + goto out; - ret = filename; + /* Compare the topology of volfiles */ + ret = glusterd_check_topology_identical (nfsvol, tmpnfsvol, + identical); out: + if (tmpfd >= 0) + close (tmpfd); + if (tmpclean) + unlink (tmpnfsvol); return ret; } -static char * -get_client_filename (glusterd_volinfo_t *volinfo) +int +glusterd_check_nfs_volfile_identical (gf_boolean_t *identical) { - char path[PATH_MAX] = {0,}; - char *ret = NULL; - char *filename = NULL; + char nfsvol[PATH_MAX] = {0,}; + char tmpnfsvol[PATH_MAX] = {0,}; + glusterd_conf_t *conf = NULL; + xlator_t *this = NULL; + int ret = -1; + int need_unlink = 0; + int tmp_fd = -1; + + this = THIS; + + GF_ASSERT (this); + GF_ASSERT (identical); + + conf = this->private; + + glusterd_get_nodesvc_volfile ("nfs", conf->workdir, + nfsvol, sizeof (nfsvol)); + + snprintf (tmpnfsvol, sizeof (tmpnfsvol), "/tmp/gnfs-XXXXXX"); - filename = GF_CALLOC (1, PATH_MAX, gf_gld_mt_char); - if (!filename) + tmp_fd = mkstemp (tmpnfsvol); + if (tmp_fd < 0) { + gf_log ("", GF_LOG_WARNING, "Unable to create temp file %s: " + "(%s)", tmpnfsvol, strerror (errno)); goto out; + } - VOLGEN_GET_VOLUME_DIR (path, volinfo); + need_unlink = 1; - snprintf (filename, PATH_MAX, "%s/%s-fuse.vol", - path, volinfo->volname); + ret = glusterd_create_global_volfile (build_nfs_graph, + tmpnfsvol, NULL); + if (ret) + goto out; + + ret = glusterd_check_files_identical (nfsvol, tmpnfsvol, + identical); + if (ret) + goto out; - ret = filename; out: + if (need_unlink) + unlink (tmpnfsvol); + + if (tmp_fd >= 0) + close (tmp_fd); + return ret; } -static int -generate_brick_volfiles (glusterd_volinfo_t *volinfo) +int +glusterd_delete_volfile (glusterd_volinfo_t *volinfo, + glusterd_brickinfo_t *brickinfo) { - glusterd_brickinfo_t *brickinfo = NULL; - char *filename = NULL; - int ret = -1; + int ret = 0; + char filename[PATH_MAX] = {0,}; - list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { - gf_log ("", GF_LOG_DEBUG, - "Found a brick - %s:%s", brickinfo->hostname, - brickinfo->path); + GF_ASSERT (volinfo); + GF_ASSERT (brickinfo); + + get_brick_filepath (filename, volinfo, brickinfo); + ret = unlink (filename); + if (ret) + gf_log ("glusterd", GF_LOG_ERROR, "failed to delete file: %s, " + "reason: %s", filename, strerror (errno)); + return ret; +} + +int +validate_shdopts (glusterd_volinfo_t *volinfo, + dict_t *val_dict, + char **op_errstr) +{ + volgen_graph_t graph = {0,}; + int ret = -1; + + graph.errstr = op_errstr; + + if (!glusterd_is_volume_replicate (volinfo)) { + ret = 0; + goto out; + } + ret = dict_set_str (val_dict, "graph-check", "on"); + 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_log ("glusterd", GF_LOG_DEBUG, "Returning %d", ret); +out: + dict_del (val_dict, "graph-check"); + return ret; +} - filename = get_brick_filename (volinfo, brickinfo); - if (!filename) { - gf_log ("", GF_LOG_ERROR, - "Out of memory"); +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[4096] = {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_log (this->name, GF_LOG_ERROR, "%s", err_str); + *op_errstr = gf_strdup (err_str); ret = -1; goto out; } - - ret = generate_server_volfile (brickinfo, volinfo->dict, - filename); - if (ret) { - gf_log ("", GF_LOG_DEBUG, - "Could not generate volfile for brick %s:%s", - brickinfo->hostname, brickinfo->path); + 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; } + } - if (filename) - GF_FREE (filename); + ret = dict_set_str (val_dict, "volume-name", volinfo->volname); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "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_log (this->name, GF_LOG_DEBUG, "Returning %d", ret); + return ret; +} + + +int +validate_clientopts (glusterd_volinfo_t *volinfo, + dict_t *val_dict, + char **op_errstr) +{ + volgen_graph_t graph = {0,}; + int ret = -1; + + GF_ASSERT (volinfo); + + graph.errstr = op_errstr; + + ret = build_client_graph (&graph, volinfo, val_dict); + if (!ret) + ret = graph_reconf_validateopt (&graph.graph, op_errstr); + + volgen_graph_free (&graph); + + gf_log ("", GF_LOG_DEBUG, "Returning %d", ret); + return ret; +} + +int +validate_brickopts (glusterd_volinfo_t *volinfo, + glusterd_brickinfo_t *brickinfo, + dict_t *val_dict, + char **op_errstr) +{ + volgen_graph_t graph = {0,}; + int ret = -1; + + GF_ASSERT (volinfo); + + graph.errstr = op_errstr; + + ret = build_server_graph (&graph, volinfo, val_dict, brickinfo); + if (!ret) + ret = graph_reconf_validateopt (&graph.graph, op_errstr); + + volgen_graph_free (&graph); + + gf_log ("", GF_LOG_DEBUG, "Returning %d", ret); + return ret; +} + +int +glusterd_validate_brickreconf (glusterd_volinfo_t *volinfo, + dict_t *val_dict, + char **op_errstr) +{ + glusterd_brickinfo_t *brickinfo = NULL; + int ret = -1; + + list_for_each_entry (brickinfo, &volinfo->bricks, brick_list) { + gf_log ("", GF_LOG_DEBUG, + "Validating %s", brickinfo->hostname); + + ret = validate_brickopts (volinfo, brickinfo, val_dict, + op_errstr); + if (ret) + goto out; } ret = 0; + out: return ret; } static int -generate_client_volfiles (glusterd_volinfo_t *volinfo) +_check_globalopt (dict_t *this, char *key, data_t *value, void *ret_val) { - char *filename = NULL; - int ret = -1; + int *ret = NULL; - filename = get_client_filename (volinfo); - if (!filename) { - gf_log ("", GF_LOG_ERROR, - "Out of memory"); - ret = -1; + 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) +{ + 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_log ("", GF_LOG_DEBUG, + "Could not Validate bricks"); goto out; } - ret = generate_client_volfile (volinfo, filename); + ret = validate_clientopts (volinfo, val_dict, op_errstr); if (ret) { gf_log ("", GF_LOG_DEBUG, - "Could not generate volfile for client"); + "Could not Validate client"); goto out; } -out: - if (filename) - GF_FREE (filename); + ret = validate_nfsopts (volinfo, val_dict, op_errstr); + if (ret) { + gf_log ("", GF_LOG_DEBUG, "Could not Validate nfs"); + goto out; + } + + ret = validate_shdopts (volinfo, val_dict, op_errstr); + if (ret) { + gf_log ("", GF_LOG_DEBUG, "Could not Validate self-heald"); + goto out; + } +out: + gf_log ("", GF_LOG_DEBUG, "Returning %d", ret); return ret; } +static int +_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; + + return 0; +} + int -glusterd_create_volfiles (glusterd_volinfo_t *volinfo) +glusterd_validate_reconfopts (glusterd_volinfo_t *volinfo, dict_t *val_dict, + char **op_errstr) { - int ret = -1; + 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); - ret = generate_brick_volfiles (volinfo); if (ret) { gf_log ("", GF_LOG_DEBUG, - "Could not generate volfiles for bricks"); + "Could not Validate bricks"); goto out; } - ret = generate_client_volfiles (volinfo); + ret = validate_clientopts (volinfo, val_dict, op_errstr); if (ret) { gf_log ("", GF_LOG_DEBUG, - "Could not generate volfile for client"); + "Could not Validate client"); + goto out; + } + + ret = validate_nfsopts (volinfo, val_dict, op_errstr); + if (ret) { + gf_log ("", GF_LOG_DEBUG, "Could not Validate nfs"); goto out; } - ret = glusterd_fetchspec_notify (THIS); + ret = validate_shdopts (volinfo, val_dict, op_errstr); + if (ret) { + gf_log ("", GF_LOG_DEBUG, "Could not Validate self-heald"); + goto out; + } + + +out: + gf_log ("", GF_LOG_DEBUG, "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; + } + + return NULL; +} + +uint32_t +glusterd_get_op_version_for_key (char *key) +{ + struct volopt_map_entry *vmep = NULL; + + GF_ASSERT (key); + + vmep = _gd_get_vmep (key); + if (vmep) + return vmep->op_version; + + return 0; +} + +gf_boolean_t +gd_is_client_option (char *key) +{ + struct volopt_map_entry *vmep = NULL; + + GF_ASSERT (key); + + vmep = _gd_get_vmep (key); + if (vmep && (vmep->flags & OPT_FLAG_CLIENT_OPT)) + return _gf_true; + + return _gf_false; +} + +gf_boolean_t +gd_is_xlator_option (char *key) +{ + struct volopt_map_entry *vmep = NULL; + + GF_ASSERT (key); + + vmep = _gd_get_vmep (key); + if (vmep && (vmep->flags & OPT_FLAG_XLATOR_OPT)) + return _gf_true; + + return _gf_false; +} + +volume_option_type_t +_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; + + GF_ASSERT (key); + + vmep = _gd_get_vmep (key); + + if (vmep) { + 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; + + opt = xlator_volume_option_get_list (&vol_opt_list, xlopt_key); + _free_xlator_opt_key (xlopt_key); + + if (opt) + opt_type = opt->type; + } + +out: + if (dl_handle) { + dlclose (dl_handle); + dl_handle = NULL; + } + + return opt_type; +} + +gf_boolean_t +gd_is_boolean_option (char *key) +{ + GF_ASSERT (key); + + if (GF_OPTION_TYPE_BOOL == _gd_get_option_type (key)) + return _gf_true; + + return _gf_false; +} + +/* This function will restore origin volume to it's snap. + * The restore operation will simply replace the Gluster origin + * volume with the snap volume. + * TODO: Multi-volume delete to be done. + * Cleanup in case of restore failure is pending. + * + * @param orig_vol volinfo of origin volume + * @param snap_vol volinfo of snapshot volume + * + * @return 0 on success and negative value on error + */ +int +gd_restore_snap_volume (dict_t *rsp_dict, + glusterd_volinfo_t *orig_vol, + glusterd_volinfo_t *snap_vol) +{ + int ret = -1; + glusterd_volinfo_t *new_volinfo = NULL; + glusterd_snap_t *snap = NULL; + xlator_t *this = NULL; + glusterd_conf_t *conf = NULL; + glusterd_volinfo_t *temp_volinfo = NULL; + glusterd_volinfo_t *voliter = NULL; + + this = THIS; + GF_ASSERT (this); + GF_ASSERT (rsp_dict); + conf = this->private; + GF_ASSERT (conf); + + GF_VALIDATE_OR_GOTO (this->name, orig_vol, out); + GF_VALIDATE_OR_GOTO (this->name, snap_vol, out); + snap = snap_vol->snapshot; + GF_VALIDATE_OR_GOTO (this->name, snap, out); + + /* Snap volume must be stoped before performing the + * restore operation. + */ + ret = glusterd_stop_volume (snap_vol); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to stop " + "snap volume"); + goto out; + } + + /* Create a new volinfo for the restored volume */ + ret = glusterd_volinfo_dup (snap_vol, &new_volinfo, _gf_true); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to create volinfo"); + goto out; + } + + /* Following entries need to be derived from origin volume. */ + strcpy (new_volinfo->volname, orig_vol->volname); + uuid_copy (new_volinfo->volume_id, orig_vol->volume_id); + new_volinfo->snap_count = orig_vol->snap_count; + new_volinfo->snap_max_hard_limit = orig_vol->snap_max_hard_limit; + new_volinfo->is_volume_restored = _gf_true; + + /* Bump the version of the restored volume, so that nodes * + * which are done can sync during handshake */ + new_volinfo->version = orig_vol->version; + + list_for_each_entry_safe (voliter, temp_volinfo, + &orig_vol->snap_volumes, snapvol_list) { + list_add_tail (&voliter->snapvol_list, + &new_volinfo->snap_volumes); + } + /* Copy the snap vol info to the new_volinfo.*/ + ret = glusterd_snap_volinfo_restore (rsp_dict, new_volinfo, snap_vol); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to restore snap"); + (void)glusterd_volinfo_delete (new_volinfo); + goto out; + } + + /* If the orig_vol is already restored then we should delete + * the backend LVMs */ + if (orig_vol->is_volume_restored) { + ret = glusterd_lvm_snapshot_remove (rsp_dict, orig_vol); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to remove " + "LVM backend"); + (void)glusterd_volinfo_delete (new_volinfo); + goto out; + } + } + + /* Once the new_volinfo is completely constructed then delete + * the orinal volinfo + */ + ret = glusterd_volinfo_delete (orig_vol); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to delete volinfo"); + (void)glusterd_volinfo_delete (new_volinfo); + goto out; + } + + /* New volinfo always shows the status as created. Therefore + * set the status to stop. */ + glusterd_set_volume_status (new_volinfo, GLUSTERD_STATUS_STOPPED); + + list_add_tail (&new_volinfo->vol_list, &conf->volumes); + + /* Now delete the snap entry. As a first step delete the snap + * volume information stored in store. */ + ret = glusterd_snap_remove (rsp_dict, snap, _gf_false, _gf_true); + if (ret) { + gf_log (this->name, GF_LOG_WARNING, "Failed to delete " + "snap %s", snap->snapname); + goto out; + } + + ret = glusterd_store_volinfo (new_volinfo, + GLUSTERD_VOLINFO_VER_AC_INCREMENT); + if (ret) { + gf_log (this->name, GF_LOG_ERROR, "Failed to store volinfo"); + goto out; + } + + ret = 0; out: + return ret; } |