diff options
Diffstat (limited to 'libglusterfs/src/graph.c')
| -rw-r--r-- | libglusterfs/src/graph.c | 1748 |
1 files changed, 867 insertions, 881 deletions
diff --git a/libglusterfs/src/graph.c b/libglusterfs/src/graph.c index 03ef55c5892..2a213d2c48e 100644 --- a/libglusterfs/src/graph.c +++ b/libglusterfs/src/graph.c @@ -69,623 +69,611 @@ _gf_dump_details (int argc, char **argv) #endif int -glusterfs_read_secure_access_file (void) +glusterfs_read_secure_access_file(void) { - FILE *fp = NULL; - char line[100] = {0,}; - int cert_depth = 1; /* Default SSL CERT DEPTH */ - regex_t regcmpl; - char *key = {"^option transport.socket.ssl-cert-depth"}; - char keyval[50] = {0,}; - int start = 0, end = 0, copy_len = 0; - regmatch_t result[1] = {{0} }; - - fp = fopen (SECURE_ACCESS_FILE, "r"); - if (!fp) - goto out; - - /* Check if any line matches with key */ - while (fgets(line, sizeof(line), fp) != NULL) { - if (regcomp (®cmpl, key, REG_EXTENDED)) { - goto out; - } - if (!regexec (®cmpl, line, 1, result, 0)) { - start = result[0].rm_so; - end = result[0].rm_eo; - copy_len = end - start; - gf_strncpy (keyval, line+copy_len, sizeof (keyval)); - if (keyval[0]) { - cert_depth = atoi(keyval); - if (cert_depth == 0) - cert_depth = 1; /* Default SSL CERT DEPTH */ - break; - } - } - regfree(®cmpl); + FILE *fp = NULL; + char line[100] = { + 0, + }; + int cert_depth = 1; /* Default SSL CERT DEPTH */ + regex_t regcmpl; + char *key = {"^option transport.socket.ssl-cert-depth"}; + char keyval[50] = { + 0, + }; + int start = 0, end = 0, copy_len = 0; + regmatch_t result[1] = {{0}}; + + fp = fopen(SECURE_ACCESS_FILE, "r"); + if (!fp) + goto out; + + /* Check if any line matches with key */ + while (fgets(line, sizeof(line), fp) != NULL) { + if (regcomp(®cmpl, key, REG_EXTENDED)) { + goto out; } + if (!regexec(®cmpl, line, 1, result, 0)) { + start = result[0].rm_so; + end = result[0].rm_eo; + copy_len = end - start; + gf_strncpy(keyval, line + copy_len, sizeof(keyval)); + if (keyval[0]) { + cert_depth = atoi(keyval); + if (cert_depth == 0) + cert_depth = 1; /* Default SSL CERT DEPTH */ + break; + } + } + regfree(®cmpl); + } out: - if (fp) - fclose (fp); - return cert_depth; + if (fp) + fclose(fp); + return cert_depth; } int -glusterfs_xlator_link (xlator_t *pxl, xlator_t *cxl) +glusterfs_xlator_link(xlator_t *pxl, xlator_t *cxl) { - xlator_list_t *xlchild = NULL; - xlator_list_t *xlparent = NULL; - xlator_list_t **tmp = NULL; + xlator_list_t *xlchild = NULL; + xlator_list_t *xlparent = NULL; + xlator_list_t **tmp = NULL; - xlparent = (void *) GF_CALLOC (1, sizeof (*xlparent), - gf_common_mt_xlator_list_t); - if (!xlparent) - return -1; + xlparent = (void *)GF_CALLOC(1, sizeof(*xlparent), + gf_common_mt_xlator_list_t); + if (!xlparent) + return -1; - xlchild = (void *) GF_CALLOC (1, sizeof (*xlchild), - gf_common_mt_xlator_list_t); - if (!xlchild) { - GF_FREE (xlparent); + xlchild = (void *)GF_CALLOC(1, sizeof(*xlchild), + gf_common_mt_xlator_list_t); + if (!xlchild) { + GF_FREE(xlparent); - return -1; - } + return -1; + } - xlparent->xlator = pxl; - for (tmp = &cxl->parents; *tmp; tmp = &(*tmp)->next); - *tmp = xlparent; + xlparent->xlator = pxl; + for (tmp = &cxl->parents; *tmp; tmp = &(*tmp)->next) + ; + *tmp = xlparent; - xlchild->xlator = cxl; - for (tmp = &pxl->children; *tmp; tmp = &(*tmp)->next); - *tmp = xlchild; + xlchild->xlator = cxl; + for (tmp = &pxl->children; *tmp; tmp = &(*tmp)->next) + ; + *tmp = xlchild; - return 0; + return 0; } - void -glusterfs_graph_set_first (glusterfs_graph_t *graph, xlator_t *xl) +glusterfs_graph_set_first(glusterfs_graph_t *graph, xlator_t *xl) { - xl->next = graph->first; - if (graph->first) - ((xlator_t *)graph->first)->prev = xl; - graph->first = xl; + xl->next = graph->first; + if (graph->first) + ((xlator_t *)graph->first)->prev = xl; + graph->first = xl; - graph->xl_count++; - xl->xl_id = graph->xl_count; + graph->xl_count++; + xl->xl_id = graph->xl_count; } - int -glusterfs_graph_insert (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx, - const char *type, const char *name, - gf_boolean_t autoload) +glusterfs_graph_insert(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx, + const char *type, const char *name, + gf_boolean_t autoload) { - xlator_t *ixl = NULL; + xlator_t *ixl = NULL; - if (!ctx->master) { - gf_msg ("glusterfs", GF_LOG_ERROR, 0, LG_MSG_VOLUME_ERROR, - "volume \"%s\" can be added from command line only " - "on client side", type); + if (!ctx->master) { + gf_msg("glusterfs", GF_LOG_ERROR, 0, LG_MSG_VOLUME_ERROR, + "volume \"%s\" can be added from command line only " + "on client side", + type); - return -1; - } + return -1; + } - ixl = GF_CALLOC (1, sizeof (*ixl), gf_common_mt_xlator_t); - if (!ixl) - return -1; + ixl = GF_CALLOC(1, sizeof(*ixl), gf_common_mt_xlator_t); + if (!ixl) + return -1; - ixl->ctx = ctx; - ixl->graph = graph; - ixl->options = get_new_dict (); - if (!ixl->options) - goto err; + ixl->ctx = ctx; + ixl->graph = graph; + ixl->options = get_new_dict(); + if (!ixl->options) + goto err; - ixl->name = gf_strdup (name); - if (!ixl->name) - goto err; + ixl->name = gf_strdup(name); + if (!ixl->name) + goto err; - ixl->is_autoloaded = autoload; + ixl->is_autoloaded = autoload; - if (xlator_set_type (ixl, type) == -1) { - gf_msg ("glusterfs", GF_LOG_ERROR, 0, LG_MSG_INIT_FAILED, - "%s (%s) initialization failed", - name, type); - return -1; - } + if (xlator_set_type(ixl, type) == -1) { + gf_msg("glusterfs", GF_LOG_ERROR, 0, LG_MSG_INIT_FAILED, + "%s (%s) initialization failed", name, type); + return -1; + } - if (glusterfs_xlator_link (ixl, graph->top) == -1) - goto err; - glusterfs_graph_set_first (graph, ixl); - graph->top = ixl; + if (glusterfs_xlator_link(ixl, graph->top) == -1) + goto err; + glusterfs_graph_set_first(graph, ixl); + graph->top = ixl; - return 0; + return 0; err: - xlator_destroy (ixl); - return -1; + xlator_destroy(ixl); + return -1; } int -glusterfs_graph_acl (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx) +glusterfs_graph_acl(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx) { - int ret = 0; - cmd_args_t *cmd_args = NULL; + int ret = 0; + cmd_args_t *cmd_args = NULL; - cmd_args = &ctx->cmd_args; + cmd_args = &ctx->cmd_args; - if (!cmd_args->acl) - return 0; + if (!cmd_args->acl) + return 0; - ret = glusterfs_graph_insert (graph, ctx, "system/posix-acl", - "posix-acl-autoload", 1); - return ret; + ret = glusterfs_graph_insert(graph, ctx, "system/posix-acl", + "posix-acl-autoload", 1); + return ret; } int -glusterfs_graph_worm (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx) +glusterfs_graph_worm(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx) { - int ret = 0; - cmd_args_t *cmd_args = NULL; + int ret = 0; + cmd_args_t *cmd_args = NULL; - cmd_args = &ctx->cmd_args; + cmd_args = &ctx->cmd_args; - if (!cmd_args->worm) - return 0; + if (!cmd_args->worm) + return 0; - ret = glusterfs_graph_insert (graph, ctx, "features/worm", - "worm-autoload", 1); - return ret; + ret = glusterfs_graph_insert(graph, ctx, "features/worm", "worm-autoload", + 1); + return ret; } - int -glusterfs_graph_meta (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx) +glusterfs_graph_meta(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx) { - int ret = 0; + int ret = 0; - if (!ctx->master) - return 0; + if (!ctx->master) + return 0; - ret = glusterfs_graph_insert (graph, ctx, "meta", - "meta-autoload", 1); - return ret; + ret = glusterfs_graph_insert(graph, ctx, "meta", "meta-autoload", 1); + return ret; } - int -glusterfs_graph_mac_compat (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx) +glusterfs_graph_mac_compat(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx) { - int ret = 0; - cmd_args_t *cmd_args = NULL; + int ret = 0; + cmd_args_t *cmd_args = NULL; - cmd_args = &ctx->cmd_args; + cmd_args = &ctx->cmd_args; - if (cmd_args->mac_compat == GF_OPTION_DISABLE) - return 0; + if (cmd_args->mac_compat == GF_OPTION_DISABLE) + return 0; - ret = glusterfs_graph_insert (graph, ctx, "features/mac-compat", - "mac-compat-autoload", 1); + ret = glusterfs_graph_insert(graph, ctx, "features/mac-compat", + "mac-compat-autoload", 1); - return ret; + return ret; } int -glusterfs_graph_gfid_access (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx) +glusterfs_graph_gfid_access(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx) { - int ret = 0; - cmd_args_t *cmd_args = NULL; + int ret = 0; + cmd_args_t *cmd_args = NULL; - cmd_args = &ctx->cmd_args; + cmd_args = &ctx->cmd_args; - if (!cmd_args->aux_gfid_mount) - return 0; + if (!cmd_args->aux_gfid_mount) + return 0; - ret = glusterfs_graph_insert (graph, ctx, "features/gfid-access", - "gfid-access-autoload", 1); - return ret; + ret = glusterfs_graph_insert(graph, ctx, "features/gfid-access", + "gfid-access-autoload", 1); + return ret; } static void -gf_add_cmdline_options (glusterfs_graph_t *graph, cmd_args_t *cmd_args) +gf_add_cmdline_options(glusterfs_graph_t *graph, cmd_args_t *cmd_args) { - int ret = 0; - xlator_t *trav = NULL; - xlator_cmdline_option_t *cmd_option = NULL; - - trav = graph->first; - - while (trav) { - list_for_each_entry (cmd_option, - &cmd_args->xlator_options, cmd_args) { - if (!fnmatch (cmd_option->volume, - trav->name, FNM_NOESCAPE)) { - ret = dict_set_str (trav->options, - cmd_option->key, - cmd_option->value); - if (ret == 0) { - gf_msg (trav->name, GF_LOG_TRACE, 0, - LG_MSG_VOL_OPTION_ADD, - "adding option '%s' for " - "volume '%s' with value '%s'", - cmd_option->key, trav->name, - cmd_option->value); - } else { - gf_msg (trav->name, GF_LOG_WARNING, - -ret, LG_MSG_VOL_OPTION_ADD, - "adding option '%s' for " - "volume '%s' failed", - cmd_option->key, trav->name); - } - } + int ret = 0; + xlator_t *trav = NULL; + xlator_cmdline_option_t *cmd_option = NULL; + + trav = graph->first; + + while (trav) { + list_for_each_entry(cmd_option, &cmd_args->xlator_options, cmd_args) + { + if (!fnmatch(cmd_option->volume, trav->name, FNM_NOESCAPE)) { + ret = dict_set_str(trav->options, cmd_option->key, + cmd_option->value); + if (ret == 0) { + gf_msg(trav->name, GF_LOG_TRACE, 0, LG_MSG_VOL_OPTION_ADD, + "adding option '%s' for " + "volume '%s' with value '%s'", + cmd_option->key, trav->name, cmd_option->value); + } else { + gf_msg(trav->name, GF_LOG_WARNING, -ret, + LG_MSG_VOL_OPTION_ADD, + "adding option '%s' for " + "volume '%s' failed", + cmd_option->key, trav->name); } - trav = trav->next; + } } + trav = trav->next; + } } - int -glusterfs_graph_validate_options (glusterfs_graph_t *graph) +glusterfs_graph_validate_options(glusterfs_graph_t *graph) { - xlator_t *trav = NULL; - int ret = -1; - char *errstr = NULL; + xlator_t *trav = NULL; + int ret = -1; + char *errstr = NULL; - trav = graph->first; + trav = graph->first; - while (trav) { - if (list_empty (&trav->volume_options)) { - trav = trav->next; - continue; - } + while (trav) { + if (list_empty(&trav->volume_options)) { + trav = trav->next; + continue; + } - ret = xlator_options_validate (trav, trav->options, &errstr); - if (ret) { - gf_msg (trav->name, GF_LOG_ERROR, 0, - LG_MSG_VALIDATION_FAILED, "validation failed: " - "%s", errstr); - return ret; - } - trav = trav->next; + ret = xlator_options_validate(trav, trav->options, &errstr); + if (ret) { + gf_msg(trav->name, GF_LOG_ERROR, 0, LG_MSG_VALIDATION_FAILED, + "validation failed: " + "%s", + errstr); + return ret; } + trav = trav->next; + } - return 0; + return 0; } - int -glusterfs_graph_init (glusterfs_graph_t *graph) +glusterfs_graph_init(glusterfs_graph_t *graph) { - xlator_t *trav = NULL; - int ret = -1; - - trav = graph->first; - - while (trav) { - ret = xlator_init (trav); - if (ret) { - gf_msg (trav->name, GF_LOG_ERROR, 0, - LG_MSG_TRANSLATOR_INIT_FAILED, - "initializing translator failed"); - return ret; - } - trav = trav->next; + xlator_t *trav = NULL; + int ret = -1; + + trav = graph->first; + + while (trav) { + ret = xlator_init(trav); + if (ret) { + gf_msg(trav->name, GF_LOG_ERROR, 0, LG_MSG_TRANSLATOR_INIT_FAILED, + "initializing translator failed"); + return ret; } + trav = trav->next; + } - return 0; + return 0; } int -glusterfs_graph_deactivate (glusterfs_graph_t *graph) +glusterfs_graph_deactivate(glusterfs_graph_t *graph) { - xlator_t *top = NULL; + xlator_t *top = NULL; - if (graph == NULL) - goto out; + if (graph == NULL) + goto out; - top = graph->top; - xlator_tree_fini (top); - out: - return 0; + top = graph->top; + xlator_tree_fini(top); +out: + return 0; } static int -_log_if_unknown_option (dict_t *dict, char *key, data_t *value, void *data) +_log_if_unknown_option(dict_t *dict, char *key, data_t *value, void *data) { - volume_option_t *found = NULL; - xlator_t *xl = NULL; + volume_option_t *found = NULL; + xlator_t *xl = NULL; - xl = data; + xl = data; - found = xlator_volume_option_get (xl, key); + found = xlator_volume_option_get(xl, key); - if (!found) { - gf_msg (xl->name, GF_LOG_WARNING, 0, - LG_MSG_XLATOR_OPTION_INVALID, - "option '%s' is not recognized", key); - } + if (!found) { + gf_msg(xl->name, GF_LOG_WARNING, 0, LG_MSG_XLATOR_OPTION_INVALID, + "option '%s' is not recognized", key); + } - return 0; + return 0; } - static void -_xlator_check_unknown_options (xlator_t *xl, void *data) +_xlator_check_unknown_options(xlator_t *xl, void *data) { - dict_foreach (xl->options, _log_if_unknown_option, xl); + dict_foreach(xl->options, _log_if_unknown_option, xl); } - int -glusterfs_graph_unknown_options (glusterfs_graph_t *graph) +glusterfs_graph_unknown_options(glusterfs_graph_t *graph) { - xlator_foreach (graph->first, _xlator_check_unknown_options, NULL); - return 0; + xlator_foreach(graph->first, _xlator_check_unknown_options, NULL); + return 0; } - void -fill_uuid (char *uuid, int size) +fill_uuid(char *uuid, int size) { - char hostname[256] = {0,}; - struct timeval tv = {0,}; - char now_str[64]; - - if (gettimeofday (&tv, NULL) == -1) { - gf_msg ("graph", GF_LOG_ERROR, errno, - LG_MSG_GETTIMEOFDAY_FAILED, "gettimeofday: " - "failed"); - } - - if (gethostname (hostname, 256) == -1) { - gf_msg ("graph", GF_LOG_ERROR, errno, - LG_MSG_GETHOSTNAME_FAILED, "gethostname: " - "failed"); - } - - gf_time_fmt (now_str, sizeof now_str, tv.tv_sec, gf_timefmt_dirent); - snprintf (uuid, size, "%s-%d-%s:%"GF_PRI_SUSECONDS, - hostname, getpid(), now_str, tv.tv_usec); - - return; + char hostname[256] = { + 0, + }; + struct timeval tv = { + 0, + }; + char now_str[64]; + + if (gettimeofday(&tv, NULL) == -1) { + gf_msg("graph", GF_LOG_ERROR, errno, LG_MSG_GETTIMEOFDAY_FAILED, + "gettimeofday: " + "failed"); + } + + if (gethostname(hostname, 256) == -1) { + gf_msg("graph", GF_LOG_ERROR, errno, LG_MSG_GETHOSTNAME_FAILED, + "gethostname: " + "failed"); + } + + gf_time_fmt(now_str, sizeof now_str, tv.tv_sec, gf_timefmt_dirent); + snprintf(uuid, size, "%s-%d-%s:%" GF_PRI_SUSECONDS, hostname, getpid(), + now_str, tv.tv_usec); + + return; } - static int -glusterfs_graph_settop (glusterfs_graph_t *graph, char *volume_name, - gf_boolean_t exact_match) +glusterfs_graph_settop(glusterfs_graph_t *graph, char *volume_name, + gf_boolean_t exact_match) { - int ret = -1; - xlator_t *trav = NULL; + int ret = -1; + xlator_t *trav = NULL; - if (!volume_name || !exact_match) { - graph->top = graph->first; + if (!volume_name || !exact_match) { + graph->top = graph->first; + ret = 0; + } else { + for (trav = graph->first; trav; trav = trav->next) { + if (strcmp(trav->name, volume_name) == 0) { + graph->top = trav; ret = 0; - } else { - for (trav = graph->first; trav; trav = trav->next) { - if (strcmp (trav->name, volume_name) == 0) { - graph->top = trav; - ret = 0; - break; - } - } + break; + } } + } - return ret; + return ret; } - int -glusterfs_graph_parent_up (glusterfs_graph_t *graph) +glusterfs_graph_parent_up(glusterfs_graph_t *graph) { - xlator_t *trav = NULL; - int ret = -1; + xlator_t *trav = NULL; + int ret = -1; - trav = graph->first; + trav = graph->first; - while (trav) { - if (!xlator_has_parent (trav)) { - ret = xlator_notify (trav, GF_EVENT_PARENT_UP, trav); - } + while (trav) { + if (!xlator_has_parent(trav)) { + ret = xlator_notify(trav, GF_EVENT_PARENT_UP, trav); + } - if (ret) - break; + if (ret) + break; - trav = trav->next; - } + trav = trav->next; + } - return ret; + return ret; } - int -glusterfs_graph_prepare (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx, - char *volume_name) +glusterfs_graph_prepare(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx, + char *volume_name) { - xlator_t *trav = NULL; - int ret = 0; - - /* XXX: CHECKSUM */ - - /* XXX: attach to -n volname */ - /* A '/' in the volume name suggests brick multiplexing is used, find - * the top of the (sub)graph. The volname MUST match the subvol in this - * case. In other cases (like for gfapi) the default top for the - * (sub)graph is ok. */ - if (!volume_name) { - /* GlusterD does not pass a volume_name */ - ret = glusterfs_graph_settop (graph, volume_name, _gf_false); - } else if (strncmp (volume_name, "/snaps/", 7) == 0) { - /* snap shots have their top xlator named like "/snaps/..." */ - ret = glusterfs_graph_settop (graph, volume_name, - _gf_false); - } else if (volume_name[0] == '/') { - /* brick multiplexing passes the brick path */ - ret = glusterfs_graph_settop (graph, volume_name, - _gf_true); - } else { - ret = glusterfs_graph_settop (graph, volume_name, - _gf_false); - } - if (!ret) { - goto ok; - } - - gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR, - "glusterfs graph settop failed"); - return -1; + xlator_t *trav = NULL; + int ret = 0; + + /* XXX: CHECKSUM */ + + /* XXX: attach to -n volname */ + /* A '/' in the volume name suggests brick multiplexing is used, find + * the top of the (sub)graph. The volname MUST match the subvol in this + * case. In other cases (like for gfapi) the default top for the + * (sub)graph is ok. */ + if (!volume_name) { + /* GlusterD does not pass a volume_name */ + ret = glusterfs_graph_settop(graph, volume_name, _gf_false); + } else if (strncmp(volume_name, "/snaps/", 7) == 0) { + /* snap shots have their top xlator named like "/snaps/..." */ + ret = glusterfs_graph_settop(graph, volume_name, _gf_false); + } else if (volume_name[0] == '/') { + /* brick multiplexing passes the brick path */ + ret = glusterfs_graph_settop(graph, volume_name, _gf_true); + } else { + ret = glusterfs_graph_settop(graph, volume_name, _gf_false); + } + if (!ret) { + goto ok; + } + + gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR, + "glusterfs graph settop failed"); + return -1; ok: - /* XXX: WORM VOLUME */ - ret = glusterfs_graph_worm (graph, ctx); - if (ret) { - gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR, - "glusterfs graph worm failed"); - return -1; - } - ret = glusterfs_graph_acl (graph, ctx); - if (ret) { - gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR, - "glusterfs graph ACL failed"); - return -1; - } + /* XXX: WORM VOLUME */ + ret = glusterfs_graph_worm(graph, ctx); + if (ret) { + gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR, + "glusterfs graph worm failed"); + return -1; + } + ret = glusterfs_graph_acl(graph, ctx); + if (ret) { + gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR, + "glusterfs graph ACL failed"); + return -1; + } - /* XXX: MAC COMPAT */ - ret = glusterfs_graph_mac_compat (graph, ctx); - if (ret) { - gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR, - "glusterfs graph mac compat failed"); - return -1; - } + /* XXX: MAC COMPAT */ + ret = glusterfs_graph_mac_compat(graph, ctx); + if (ret) { + gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR, + "glusterfs graph mac compat failed"); + return -1; + } - /* XXX: gfid-access */ - ret = glusterfs_graph_gfid_access (graph, ctx); - if (ret) { - gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR, - "glusterfs graph 'gfid-access' failed"); - return -1; - } + /* XXX: gfid-access */ + ret = glusterfs_graph_gfid_access(graph, ctx); + if (ret) { + gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR, + "glusterfs graph 'gfid-access' failed"); + return -1; + } - /* XXX: topmost xlator */ - ret = glusterfs_graph_meta (graph, ctx); - if (ret) { - gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR, - "glusterfs graph meta failed"); - return -1; - } + /* XXX: topmost xlator */ + ret = glusterfs_graph_meta(graph, ctx); + if (ret) { + gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_ERROR, + "glusterfs graph meta failed"); + return -1; + } - /* XXX: this->ctx setting */ - for (trav = graph->first; trav; trav = trav->next) { - trav->ctx = ctx; - } + /* XXX: this->ctx setting */ + for (trav = graph->first; trav; trav = trav->next) { + trav->ctx = ctx; + } - /* XXX: DOB setting */ - gettimeofday (&graph->dob, NULL); + /* XXX: DOB setting */ + gettimeofday(&graph->dob, NULL); - fill_uuid (graph->graph_uuid, 128); + fill_uuid(graph->graph_uuid, 128); - graph->id = ctx->graph_id++; + graph->id = ctx->graph_id++; - /* XXX: --xlator-option additions */ - gf_add_cmdline_options (graph, &ctx->cmd_args); + /* XXX: --xlator-option additions */ + gf_add_cmdline_options(graph, &ctx->cmd_args); - return 0; + return 0; } -static -xlator_t *glusterfs_root(glusterfs_graph_t *graph) +static xlator_t * +glusterfs_root(glusterfs_graph_t *graph) { - return graph->first; + return graph->first; } -static -int glusterfs_is_leaf(xlator_t *xl) +static int +glusterfs_is_leaf(xlator_t *xl) { - int ret = 0; + int ret = 0; - if (!xl->children) - ret = 1; + if (!xl->children) + ret = 1; - return ret; + return ret; } -static -uint32_t glusterfs_count_leaves(xlator_t *xl) +static uint32_t +glusterfs_count_leaves(xlator_t *xl) { - int n = 0; - xlator_list_t *list = NULL; + int n = 0; + xlator_list_t *list = NULL; - if (glusterfs_is_leaf(xl)) - n = 1; - else - for (list = xl->children; list; list = list->next) - n += glusterfs_count_leaves(list->xlator); + if (glusterfs_is_leaf(xl)) + n = 1; + else + for (list = xl->children; list; list = list->next) + n += glusterfs_count_leaves(list->xlator); - return n; + return n; } -int glusterfs_get_leaf_count(glusterfs_graph_t *graph) +int +glusterfs_get_leaf_count(glusterfs_graph_t *graph) { - return graph->leaf_count; + return graph->leaf_count; } -static -int _glusterfs_leaf_position(xlator_t *tgt, int *id, xlator_t *xl) +static int +_glusterfs_leaf_position(xlator_t *tgt, int *id, xlator_t *xl) { - xlator_list_t *list = NULL; - int found = 0; - - if (xl == tgt) - found = 1; - else if (glusterfs_is_leaf(xl)) - *id += 1; - else - for (list = xl->children; !found && list; list = list->next) - found = _glusterfs_leaf_position(tgt, id, list->xlator); - - return found; + xlator_list_t *list = NULL; + int found = 0; + + if (xl == tgt) + found = 1; + else if (glusterfs_is_leaf(xl)) + *id += 1; + else + for (list = xl->children; !found && list; list = list->next) + found = _glusterfs_leaf_position(tgt, id, list->xlator); + + return found; } -int glusterfs_leaf_position(xlator_t *tgt) +int +glusterfs_leaf_position(xlator_t *tgt) { - xlator_t *root = NULL; - int pos = 0; + xlator_t *root = NULL; + int pos = 0; - root = glusterfs_root(tgt->graph); + root = glusterfs_root(tgt->graph); - if (!_glusterfs_leaf_position(tgt, &pos, root)) - pos = -1; + if (!_glusterfs_leaf_position(tgt, &pos, root)) + pos = -1; - return pos; + return pos; } static int _glusterfs_reachable_leaves(xlator_t *base, xlator_t *xl, dict_t *leaves) { - xlator_list_t *list = NULL; - int err = 1; - int pos = 0; - char *strpos = NULL; + xlator_list_t *list = NULL; + int err = 1; + int pos = 0; + char *strpos = NULL; - if (glusterfs_is_leaf(xl)) { - pos = glusterfs_leaf_position(xl); - if (pos < 0) - goto out; + if (glusterfs_is_leaf(xl)) { + pos = glusterfs_leaf_position(xl); + if (pos < 0) + goto out; - err = gf_asprintf(&strpos, "%d", pos); + err = gf_asprintf(&strpos, "%d", pos); - if (err >= 0) { - err = dict_set_static_ptr(leaves, strpos, base); - GF_FREE (strpos); - } - } else { - for (err = 0, list = xl->children; - !err && list; - list = list->next) - err = _glusterfs_reachable_leaves(base, list->xlator, - leaves); + if (err >= 0) { + err = dict_set_static_ptr(leaves, strpos, base); + GF_FREE(strpos); } + } else { + for (err = 0, list = xl->children; !err && list; list = list->next) + err = _glusterfs_reachable_leaves(base, list->xlator, leaves); + } out: - return err; + return err; } /* @@ -703,230 +691,226 @@ out: int glusterfs_reachable_leaves(xlator_t *base, dict_t *leaves) { - xlator_list_t *list = NULL; - int err = 0; + xlator_list_t *list = NULL; + int err = 0; - for (list = base->children; !err && list; list = list->next) - err = _glusterfs_reachable_leaves(list->xlator, - list->xlator, leaves); + for (list = base->children; !err && list; list = list->next) + err = _glusterfs_reachable_leaves(list->xlator, list->xlator, leaves); - return err; + return err; } int -glusterfs_graph_activate (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx) +glusterfs_graph_activate(glusterfs_graph_t *graph, glusterfs_ctx_t *ctx) { - int ret = 0; - xlator_t *root = NULL; + int ret = 0; + xlator_t *root = NULL; - root = glusterfs_root(graph); + root = glusterfs_root(graph); - graph->leaf_count = glusterfs_count_leaves(root); + graph->leaf_count = glusterfs_count_leaves(root); - /* XXX: all xlator options validation */ - ret = glusterfs_graph_validate_options (graph); - if (ret) { - gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_VALIDATION_FAILED, - "validate options failed"); - return ret; - } - - /* XXX: perform init () */ - ret = glusterfs_graph_init (graph); - if (ret) { - gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_INIT_FAILED, - "init failed"); - return ret; - } + /* XXX: all xlator options validation */ + ret = glusterfs_graph_validate_options(graph); + if (ret) { + gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_VALIDATION_FAILED, + "validate options failed"); + return ret; + } - ret = glusterfs_graph_unknown_options (graph); - if (ret) { - gf_msg ("graph", GF_LOG_ERROR, 0, - LG_MSG_UNKNOWN_OPTIONS_FAILED, "unknown options " - "failed"); - return ret; - } + /* XXX: perform init () */ + ret = glusterfs_graph_init(graph); + if (ret) { + gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_GRAPH_INIT_FAILED, + "init failed"); + return ret; + } - /* XXX: log full graph (_gf_dump_details) */ + ret = glusterfs_graph_unknown_options(graph); + if (ret) { + gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_UNKNOWN_OPTIONS_FAILED, + "unknown options " + "failed"); + return ret; + } - list_add (&graph->list, &ctx->graphs); - ctx->active = graph; + /* XXX: log full graph (_gf_dump_details) */ - /* XXX: attach to master and set active pointer */ - if (ctx->master) { - ret = xlator_notify (ctx->master, GF_EVENT_GRAPH_NEW, graph); - if (ret) { - gf_msg ("graph", GF_LOG_ERROR, 0, - LG_MSG_EVENT_NOTIFY_FAILED, - "graph new notification failed"); - return ret; - } - ((xlator_t *)ctx->master)->next = graph->top; - } + list_add(&graph->list, &ctx->graphs); + ctx->active = graph; - /* XXX: perform parent up */ - ret = glusterfs_graph_parent_up (graph); + /* XXX: attach to master and set active pointer */ + if (ctx->master) { + ret = xlator_notify(ctx->master, GF_EVENT_GRAPH_NEW, graph); if (ret) { - gf_msg ("graph", GF_LOG_ERROR, 0, LG_MSG_EVENT_NOTIFY_FAILED, - "parent up notification failed"); - return ret; + gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_EVENT_NOTIFY_FAILED, + "graph new notification failed"); + return ret; } + ((xlator_t *)ctx->master)->next = graph->top; + } + + /* XXX: perform parent up */ + ret = glusterfs_graph_parent_up(graph); + if (ret) { + gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_EVENT_NOTIFY_FAILED, + "parent up notification failed"); + return ret; + } - return 0; + return 0; } - int -xlator_equal_rec (xlator_t *xl1, xlator_t *xl2) +xlator_equal_rec(xlator_t *xl1, xlator_t *xl2) { - xlator_list_t *trav1 = NULL; - xlator_list_t *trav2 = NULL; - int ret = 0; + xlator_list_t *trav1 = NULL; + xlator_list_t *trav2 = NULL; + int ret = 0; - if (xl1 == NULL || xl2 == NULL) { - gf_msg_debug ("xlator", 0, "invalid argument"); - return -1; - } - - trav1 = xl1->children; - trav2 = xl2->children; - - while (trav1 && trav2) { - ret = xlator_equal_rec (trav1->xlator, trav2->xlator); - if (ret) { - gf_msg_debug ("glusterfsd-mgmt", 0, "xlators children " - "not equal"); - goto out; - } - - trav1 = trav1->next; - trav2 = trav2->next; - } + if (xl1 == NULL || xl2 == NULL) { + gf_msg_debug("xlator", 0, "invalid argument"); + return -1; + } - if (trav1 || trav2) { - ret = -1; - goto out; - } + trav1 = xl1->children; + trav2 = xl2->children; - if (strcmp (xl1->name, xl2->name)) { - ret = -1; - goto out; + while (trav1 && trav2) { + ret = xlator_equal_rec(trav1->xlator, trav2->xlator); + if (ret) { + gf_msg_debug("glusterfsd-mgmt", 0, + "xlators children " + "not equal"); + goto out; } - /* type could have changed even if xlator names match, - e.g cluster/distribute and cluster/nufa share the same - xlator name - */ - if (strcmp (xl1->type, xl2->type)) { - ret = -1; - goto out; - } -out : - return ret; + trav1 = trav1->next; + trav2 = trav2->next; + } + + if (trav1 || trav2) { + ret = -1; + goto out; + } + + if (strcmp(xl1->name, xl2->name)) { + ret = -1; + goto out; + } + + /* type could have changed even if xlator names match, + e.g cluster/distribute and cluster/nufa share the same + xlator name + */ + if (strcmp(xl1->type, xl2->type)) { + ret = -1; + goto out; + } +out: + return ret; } - gf_boolean_t -is_graph_topology_equal (glusterfs_graph_t *graph1, glusterfs_graph_t *graph2) +is_graph_topology_equal(glusterfs_graph_t *graph1, glusterfs_graph_t *graph2) { - xlator_t *trav1 = NULL; - xlator_t *trav2 = NULL; - gf_boolean_t ret = _gf_true; - xlator_list_t *ltrav; - - trav1 = graph1->first; - trav2 = graph2->first; - - if (strcmp (trav2->type, "protocol/server") == 0) { - trav2 = trav2->children->xlator; - for (ltrav = trav1->children; ltrav; ltrav = ltrav->next) { - trav1 = ltrav->xlator; - if (!trav1->cleanup_starting && !strcmp (trav1->name, trav2->name)) { - break; - } - } - if (!ltrav) { - return _gf_false; - } + xlator_t *trav1 = NULL; + xlator_t *trav2 = NULL; + gf_boolean_t ret = _gf_true; + xlator_list_t *ltrav; + + trav1 = graph1->first; + trav2 = graph2->first; + + if (strcmp(trav2->type, "protocol/server") == 0) { + trav2 = trav2->children->xlator; + for (ltrav = trav1->children; ltrav; ltrav = ltrav->next) { + trav1 = ltrav->xlator; + if (!trav1->cleanup_starting && !strcmp(trav1->name, trav2->name)) { + break; + } + } + if (!ltrav) { + return _gf_false; } + } - ret = xlator_equal_rec (trav1, trav2); + ret = xlator_equal_rec(trav1, trav2); - if (ret) { - gf_msg_debug ("glusterfsd-mgmt", 0, "graphs are not equal"); - ret = _gf_false; - goto out; - } + if (ret) { + gf_msg_debug("glusterfsd-mgmt", 0, "graphs are not equal"); + ret = _gf_false; + goto out; + } - ret = _gf_true; - gf_msg_debug ("glusterfsd-mgmt", 0, "graphs are equal"); + ret = _gf_true; + gf_msg_debug("glusterfsd-mgmt", 0, "graphs are equal"); out: - return ret; + return ret; } - /* Function has 3types of return value 0, -ve , 1 * return 0 =======> reconfiguration of options has succeeded - * return 1 =======> the graph has to be reconstructed and all the xlators should be inited - * return -1(or -ve) =======> Some Internal Error occurred during the operation + * return 1 =======> the graph has to be reconstructed and all the + * xlators should be inited return -1(or -ve) =======> Some Internal Error + * occurred during the operation */ int -glusterfs_volfile_reconfigure (FILE *newvolfile_fp, glusterfs_ctx_t *ctx) +glusterfs_volfile_reconfigure(FILE *newvolfile_fp, glusterfs_ctx_t *ctx) { - glusterfs_graph_t *oldvolfile_graph = NULL; - glusterfs_graph_t *newvolfile_graph = NULL; - - int ret = -1; - - if (!ctx) { - gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL, - "ctx is NULL"); - goto out; - } - - oldvolfile_graph = ctx->active; - if (!oldvolfile_graph) { - ret = 1; - goto out; - } - - newvolfile_graph = glusterfs_graph_construct (newvolfile_fp); - - if (!newvolfile_graph) { - goto out; - } - - glusterfs_graph_prepare (newvolfile_graph, ctx, - ctx->cmd_args.volume_name); - - if (!is_graph_topology_equal (oldvolfile_graph, - newvolfile_graph)) { - - ret = 1; - gf_msg_debug ("glusterfsd-mgmt", 0, "Graph topology not " - "equal(should call INIT)"); - goto out; - } - - gf_msg_debug ("glusterfsd-mgmt", 0, "Only options have changed in the" - " new graph"); - - ret = glusterfs_graph_reconfigure (oldvolfile_graph, - newvolfile_graph); - if (ret) { - gf_msg_debug ("glusterfsd-mgmt", 0, "Could not reconfigure " - "new options in old graph"); - goto out; - } - - ret = 0; + glusterfs_graph_t *oldvolfile_graph = NULL; + glusterfs_graph_t *newvolfile_graph = NULL; + + int ret = -1; + + if (!ctx) { + gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL, + "ctx is NULL"); + goto out; + } + + oldvolfile_graph = ctx->active; + if (!oldvolfile_graph) { + ret = 1; + goto out; + } + + newvolfile_graph = glusterfs_graph_construct(newvolfile_fp); + + if (!newvolfile_graph) { + goto out; + } + + glusterfs_graph_prepare(newvolfile_graph, ctx, ctx->cmd_args.volume_name); + + if (!is_graph_topology_equal(oldvolfile_graph, newvolfile_graph)) { + ret = 1; + gf_msg_debug("glusterfsd-mgmt", 0, + "Graph topology not " + "equal(should call INIT)"); + goto out; + } + + gf_msg_debug("glusterfsd-mgmt", 0, + "Only options have changed in the" + " new graph"); + + ret = glusterfs_graph_reconfigure(oldvolfile_graph, newvolfile_graph); + if (ret) { + gf_msg_debug("glusterfsd-mgmt", 0, + "Could not reconfigure " + "new options in old graph"); + goto out; + } + + ret = 0; out: - if (newvolfile_graph) - glusterfs_graph_destroy (newvolfile_graph); + if (newvolfile_graph) + glusterfs_graph_destroy(newvolfile_graph); - return ret; + return ret; } /* This function need to remove. This added to support gfapi volfile @@ -934,183 +918,183 @@ out: */ int -gf_volfile_reconfigure (int oldvollen, FILE *newvolfile_fp, - glusterfs_ctx_t *ctx, const char *oldvolfile) +gf_volfile_reconfigure(int oldvollen, FILE *newvolfile_fp, glusterfs_ctx_t *ctx, + const char *oldvolfile) { - glusterfs_graph_t *oldvolfile_graph = NULL; - glusterfs_graph_t *newvolfile_graph = NULL; - FILE *oldvolfile_fp = NULL; - /*Since the function mkstemp() replaces XXXXXX, - * assigning it to a variable - */ - char temp_file[] = "/tmp/temp_vol_file_XXXXXX"; - gf_boolean_t active_graph_found = _gf_true; - - int ret = -1; - int u_ret = -1; - int file_desc = -1; - - if (!oldvollen) { - ret = 1; // Has to call INIT for the whole graph - goto out; - } - - if (!ctx) { - gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL, - "ctx is NULL"); - goto out; - } - - oldvolfile_graph = ctx->active; - if (!oldvolfile_graph) { - active_graph_found = _gf_false; - gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, 0, - LG_MSG_ACTIVE_GRAPH_NULL, - "glusterfs_ctx->active is NULL"); + glusterfs_graph_t *oldvolfile_graph = NULL; + glusterfs_graph_t *newvolfile_graph = NULL; + FILE *oldvolfile_fp = NULL; + /*Since the function mkstemp() replaces XXXXXX, + * assigning it to a variable + */ + char temp_file[] = "/tmp/temp_vol_file_XXXXXX"; + gf_boolean_t active_graph_found = _gf_true; + + int ret = -1; + int u_ret = -1; + int file_desc = -1; + + if (!oldvollen) { + ret = 1; // Has to call INIT for the whole graph + goto out; + } + + if (!ctx) { + gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL, + "ctx is NULL"); + goto out; + } + + oldvolfile_graph = ctx->active; + if (!oldvolfile_graph) { + active_graph_found = _gf_false; + gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_ACTIVE_GRAPH_NULL, + "glusterfs_ctx->active is NULL"); /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */ - file_desc = mkstemp(temp_file); - if (file_desc < 0) { - gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, errno, - LG_MSG_TMPFILE_CREATE_FAILED, "Unable to " - "create temporary volfile"); - goto out; - } - - /*Calling unlink so that when the file is closed or program - *terminates the tempfile is deleted. - */ - u_ret = sys_unlink(temp_file); - - if (u_ret < 0) { - gf_msg ("glusterfsd-mgmt", GF_LOG_ERROR, errno, - LG_MSG_TMPFILE_DELETE_FAILED, "Temporary file" - " delete failed."); - sys_close (file_desc); - goto out; - } - - - oldvolfile_fp = fdopen (file_desc, "w+b"); - if (!oldvolfile_fp) - goto out; - - fwrite (oldvolfile, oldvollen, 1, oldvolfile_fp); - fflush (oldvolfile_fp); - if (ferror (oldvolfile_fp)) { - goto out; - } - - oldvolfile_graph = glusterfs_graph_construct (oldvolfile_fp); - if (!oldvolfile_graph) - goto out; - } - - newvolfile_graph = glusterfs_graph_construct (newvolfile_fp); - if (!newvolfile_graph) { - goto out; + file_desc = mkstemp(temp_file); + if (file_desc < 0) { + gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, errno, + LG_MSG_TMPFILE_CREATE_FAILED, + "Unable to " + "create temporary volfile"); + goto out; } - glusterfs_graph_prepare (newvolfile_graph, ctx, - ctx->cmd_args.volume_name); - - if (!is_graph_topology_equal (oldvolfile_graph, - newvolfile_graph)) { - - ret = 1; - gf_msg_debug ("glusterfsd-mgmt", 0, "Graph topology not " - "equal(should call INIT)"); - goto out; + /*Calling unlink so that when the file is closed or program + *terminates the tempfile is deleted. + */ + u_ret = sys_unlink(temp_file); + + if (u_ret < 0) { + gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, errno, + LG_MSG_TMPFILE_DELETE_FAILED, + "Temporary file" + " delete failed."); + sys_close(file_desc); + goto out; } - gf_msg_debug ("glusterfsd-mgmt", 0, "Only options have changed in the" - " new graph"); + oldvolfile_fp = fdopen(file_desc, "w+b"); + if (!oldvolfile_fp) + goto out; - /* */ - ret = glusterfs_graph_reconfigure (oldvolfile_graph, - newvolfile_graph); - if (ret) { - gf_msg_debug ("glusterfsd-mgmt", 0, "Could not reconfigure " - "new options in old graph"); - goto out; + fwrite(oldvolfile, oldvollen, 1, oldvolfile_fp); + fflush(oldvolfile_fp); + if (ferror(oldvolfile_fp)) { + goto out; } - ret = 0; + oldvolfile_graph = glusterfs_graph_construct(oldvolfile_fp); + if (!oldvolfile_graph) + goto out; + } + + newvolfile_graph = glusterfs_graph_construct(newvolfile_fp); + if (!newvolfile_graph) { + goto out; + } + + glusterfs_graph_prepare(newvolfile_graph, ctx, ctx->cmd_args.volume_name); + + if (!is_graph_topology_equal(oldvolfile_graph, newvolfile_graph)) { + ret = 1; + gf_msg_debug("glusterfsd-mgmt", 0, + "Graph topology not " + "equal(should call INIT)"); + goto out; + } + + gf_msg_debug("glusterfsd-mgmt", 0, + "Only options have changed in the" + " new graph"); + + /* */ + ret = glusterfs_graph_reconfigure(oldvolfile_graph, newvolfile_graph); + if (ret) { + gf_msg_debug("glusterfsd-mgmt", 0, + "Could not reconfigure " + "new options in old graph"); + goto out; + } + + ret = 0; out: - if (oldvolfile_fp) - fclose (oldvolfile_fp); - - /* Do not simply destroy the old graph here. If the oldgraph - is constructed here in this function itself instead of getting - it from ctx->active (which happens only of ctx->active is NULL), - then destroy the old graph. If some i/o is still happening in - the old graph and the old graph is obtained from ctx->active, - then destroying the graph will cause problems. - */ - if (!active_graph_found && oldvolfile_graph) - glusterfs_graph_destroy (oldvolfile_graph); - if (newvolfile_graph) - glusterfs_graph_destroy (newvolfile_graph); - - return ret; + if (oldvolfile_fp) + fclose(oldvolfile_fp); + + /* Do not simply destroy the old graph here. If the oldgraph + is constructed here in this function itself instead of getting + it from ctx->active (which happens only of ctx->active is NULL), + then destroy the old graph. If some i/o is still happening in + the old graph and the old graph is obtained from ctx->active, + then destroying the graph will cause problems. + */ + if (!active_graph_found && oldvolfile_graph) + glusterfs_graph_destroy(oldvolfile_graph); + if (newvolfile_graph) + glusterfs_graph_destroy(newvolfile_graph); + + return ret; } int -glusterfs_graph_reconfigure (glusterfs_graph_t *oldgraph, - glusterfs_graph_t *newgraph) +glusterfs_graph_reconfigure(glusterfs_graph_t *oldgraph, + glusterfs_graph_t *newgraph) { - xlator_t *old_xl = NULL; - xlator_t *new_xl = NULL; - xlator_list_t *trav; - - GF_ASSERT (oldgraph); - GF_ASSERT (newgraph); - - old_xl = oldgraph->first; - while (old_xl->is_autoloaded) { - old_xl = old_xl->children->xlator; - } - - new_xl = newgraph->first; - while (new_xl->is_autoloaded) { - new_xl = new_xl->children->xlator; - } - - if (strcmp (old_xl->type, "protocol/server") != 0) { - return xlator_tree_reconfigure (old_xl, new_xl); - } - - /* Some options still need to be handled by the server translator. */ - if (old_xl->reconfigure) { - old_xl->reconfigure (old_xl, new_xl->options); - } - - (void) copy_opts_to_child (new_xl, FIRST_CHILD (new_xl), "*auth*"); - new_xl = FIRST_CHILD (new_xl); - - for (trav = old_xl->children; trav; trav = trav->next) { - if (!trav->xlator->cleanup_starting && !strcmp (trav->xlator->name, new_xl->name)) { - return xlator_tree_reconfigure (trav->xlator, new_xl); - } + xlator_t *old_xl = NULL; + xlator_t *new_xl = NULL; + xlator_list_t *trav; + + GF_ASSERT(oldgraph); + GF_ASSERT(newgraph); + + old_xl = oldgraph->first; + while (old_xl->is_autoloaded) { + old_xl = old_xl->children->xlator; + } + + new_xl = newgraph->first; + while (new_xl->is_autoloaded) { + new_xl = new_xl->children->xlator; + } + + if (strcmp(old_xl->type, "protocol/server") != 0) { + return xlator_tree_reconfigure(old_xl, new_xl); + } + + /* Some options still need to be handled by the server translator. */ + if (old_xl->reconfigure) { + old_xl->reconfigure(old_xl, new_xl->options); + } + + (void)copy_opts_to_child(new_xl, FIRST_CHILD(new_xl), "*auth*"); + new_xl = FIRST_CHILD(new_xl); + + for (trav = old_xl->children; trav; trav = trav->next) { + if (!trav->xlator->cleanup_starting && + !strcmp(trav->xlator->name, new_xl->name)) { + return xlator_tree_reconfigure(trav->xlator, new_xl); } + } - return -1; + return -1; } int -glusterfs_graph_destroy_residual (glusterfs_graph_t *graph) +glusterfs_graph_destroy_residual(glusterfs_graph_t *graph) { - int ret = -1; + int ret = -1; - if (graph == NULL) - return ret; + if (graph == NULL) + return ret; - ret = xlator_tree_free_memacct (graph->first); + ret = xlator_tree_free_memacct(graph->first); - list_del_init (&graph->list); - GF_FREE (graph); + list_del_init(&graph->list); + GF_FREE(graph); - return ret; + return ret; } /* This function destroys all the xlator members except for the @@ -1136,137 +1120,139 @@ glusterfs_graph_destroy_residual (glusterfs_graph_t *graph) * object itself. */ int -glusterfs_graph_destroy (glusterfs_graph_t *graph) +glusterfs_graph_destroy(glusterfs_graph_t *graph) { - int ret = 0; + int ret = 0; - GF_VALIDATE_OR_GOTO ("graph", graph, out); + GF_VALIDATE_OR_GOTO("graph", graph, out); - ret = xlator_tree_free_members (graph->first); + ret = xlator_tree_free_members(graph->first); - ret = glusterfs_graph_destroy_residual (graph); + ret = glusterfs_graph_destroy_residual(graph); out: - return ret; + return ret; } - int -glusterfs_graph_attach (glusterfs_graph_t *orig_graph, char *path, - glusterfs_graph_t **newgraph) +glusterfs_graph_attach(glusterfs_graph_t *orig_graph, char *path, + glusterfs_graph_t **newgraph) { - xlator_t *this = THIS; - FILE *fp; - glusterfs_graph_t *graph; - xlator_t *xl; - char *volfile_id = NULL; - char *volfile_content = NULL; - struct stat stbuf = {0,}; - size_t file_len = -1; - gf_volfile_t *volfile_obj = NULL; - int ret = -1; - char sha256_hash[SHA256_DIGEST_LENGTH] = {0, }; - - if (!orig_graph) { - return -EINVAL; - } - - ret = sys_stat (path, &stbuf); - if (ret < 0) { - gf_log (THIS->name, GF_LOG_ERROR, "Unable to stat %s (%s)", - path, strerror (errno)); - return -EINVAL; - } - - file_len = stbuf.st_size; - volfile_content = GF_MALLOC (file_len+1, gf_common_mt_char); - if (!volfile_content) - return -ENOMEM; - - fp = fopen (path, "r"); - if (!fp) { - gf_log (THIS->name, GF_LOG_WARNING, - "oops, %s disappeared on us", path); - GF_FREE (volfile_content); - return -EIO; - } - - ret = fread (volfile_content, sizeof (char), file_len, fp); - if (ret == file_len) { - glusterfs_compute_sha256 ((const unsigned char *) volfile_content, - file_len, sha256_hash); - } else { - gf_log (THIS->name, GF_LOG_ERROR, - "read failed on path %s. File size=%"GF_PRI_SIZET - "read size=%d", path, file_len, ret); - GF_FREE (volfile_content); - fclose (fp); - return -EIO; - } - - GF_FREE (volfile_content); - - graph = glusterfs_graph_construct (fp); + xlator_t *this = THIS; + FILE *fp; + glusterfs_graph_t *graph; + xlator_t *xl; + char *volfile_id = NULL; + char *volfile_content = NULL; + struct stat stbuf = { + 0, + }; + size_t file_len = -1; + gf_volfile_t *volfile_obj = NULL; + int ret = -1; + char sha256_hash[SHA256_DIGEST_LENGTH] = { + 0, + }; + + if (!orig_graph) { + return -EINVAL; + } + + ret = sys_stat(path, &stbuf); + if (ret < 0) { + gf_log(THIS->name, GF_LOG_ERROR, "Unable to stat %s (%s)", path, + strerror(errno)); + return -EINVAL; + } + + file_len = stbuf.st_size; + volfile_content = GF_MALLOC(file_len + 1, gf_common_mt_char); + if (!volfile_content) + return -ENOMEM; + + fp = fopen(path, "r"); + if (!fp) { + gf_log(THIS->name, GF_LOG_WARNING, "oops, %s disappeared on us", path); + GF_FREE(volfile_content); + return -EIO; + } + + ret = fread(volfile_content, sizeof(char), file_len, fp); + if (ret == file_len) { + glusterfs_compute_sha256((const unsigned char *)volfile_content, + file_len, sha256_hash); + } else { + gf_log(THIS->name, GF_LOG_ERROR, + "read failed on path %s. File size=%" GF_PRI_SIZET + "read size=%d", + path, file_len, ret); + GF_FREE(volfile_content); fclose(fp); - if (!graph) { - gf_log (this->name, GF_LOG_WARNING, - "could not create graph from %s", path); - return -EIO; - } - - /* - * If there's a server translator on top, we want whatever's below - * that. - */ - xl = graph->first; - if (strcmp(xl->type, "protocol/server") == 0) { - (void) copy_opts_to_child (xl, FIRST_CHILD (xl), "*auth*"); - xl = FIRST_CHILD(xl); - } - graph->first = xl; - *newgraph = graph; - - volfile_id = strstr (path, "/snaps/"); - if (!volfile_id) { - volfile_id = rindex (path, '/'); - if (volfile_id) { - ++volfile_id; - } - } + return -EIO; + } + + GF_FREE(volfile_content); + + graph = glusterfs_graph_construct(fp); + fclose(fp); + if (!graph) { + gf_log(this->name, GF_LOG_WARNING, "could not create graph from %s", + path); + return -EIO; + } + + /* + * If there's a server translator on top, we want whatever's below + * that. + */ + xl = graph->first; + if (strcmp(xl->type, "protocol/server") == 0) { + (void)copy_opts_to_child(xl, FIRST_CHILD(xl), "*auth*"); + xl = FIRST_CHILD(xl); + } + graph->first = xl; + *newgraph = graph; + + volfile_id = strstr(path, "/snaps/"); + if (!volfile_id) { + volfile_id = rindex(path, '/'); if (volfile_id) { - xl->volfile_id = gf_strdup (volfile_id); - /* There's a stray ".vol" at the end. */ - xl->volfile_id[strlen(xl->volfile_id)-4] = '\0'; - } - - /* TODO memory leaks everywhere need to free graph in case of error */ - if (glusterfs_graph_prepare (graph, this->ctx, xl->name)) { - gf_log (this->name, GF_LOG_WARNING, - "failed to prepare graph for xlator %s", xl->name); - return -EIO; - } else if (glusterfs_graph_init (graph)) { - gf_log (this->name, GF_LOG_WARNING, - "failed to initialize graph for xlator %s", xl->name); - return -EIO; - } else if (glusterfs_xlator_link (orig_graph->top, graph->top)) { - gf_log (this->name, GF_LOG_WARNING, - "failed to link the graphs for xlator %s ", xl->name); - return -EIO; + ++volfile_id; } - + } + if (volfile_id) { + xl->volfile_id = gf_strdup(volfile_id); + /* There's a stray ".vol" at the end. */ + xl->volfile_id[strlen(xl->volfile_id) - 4] = '\0'; + } + + /* TODO memory leaks everywhere need to free graph in case of error */ + if (glusterfs_graph_prepare(graph, this->ctx, xl->name)) { + gf_log(this->name, GF_LOG_WARNING, + "failed to prepare graph for xlator %s", xl->name); + return -EIO; + } else if (glusterfs_graph_init(graph)) { + gf_log(this->name, GF_LOG_WARNING, + "failed to initialize graph for xlator %s", xl->name); + return -EIO; + } else if (glusterfs_xlator_link(orig_graph->top, graph->top)) { + gf_log(this->name, GF_LOG_WARNING, + "failed to link the graphs for xlator %s ", xl->name); + return -EIO; + } + + if (!volfile_obj) { + volfile_obj = GF_CALLOC(1, sizeof(gf_volfile_t), gf_common_volfile_t); if (!volfile_obj) { - volfile_obj = GF_CALLOC (1, sizeof (gf_volfile_t), - gf_common_volfile_t); - if (!volfile_obj) { - return -EIO; - } + return -EIO; } + } - INIT_LIST_HEAD (&volfile_obj->volfile_list); - snprintf (volfile_obj->vol_id, sizeof (volfile_obj->vol_id), - "%s", xl->volfile_id); - memcpy (volfile_obj->volfile_checksum, sha256_hash, - sizeof (volfile_obj->volfile_checksum)); - list_add (&volfile_obj->volfile_list, &this->ctx->volfile_list); + INIT_LIST_HEAD(&volfile_obj->volfile_list); + snprintf(volfile_obj->vol_id, sizeof(volfile_obj->vol_id), "%s", + xl->volfile_id); + memcpy(volfile_obj->volfile_checksum, sha256_hash, + sizeof(volfile_obj->volfile_checksum)); + list_add(&volfile_obj->volfile_list, &this->ctx->volfile_list); - return 0; + return 0; } |