diff options
Diffstat (limited to '0250-Revert-mgmt-shd-Implement-multiplexing-in-self-heal-.patch')
| -rw-r--r-- | 0250-Revert-mgmt-shd-Implement-multiplexing-in-self-heal-.patch | 4572 |
1 files changed, 4572 insertions, 0 deletions
diff --git a/0250-Revert-mgmt-shd-Implement-multiplexing-in-self-heal-.patch b/0250-Revert-mgmt-shd-Implement-multiplexing-in-self-heal-.patch new file mode 100644 index 0000000..637a16a --- /dev/null +++ b/0250-Revert-mgmt-shd-Implement-multiplexing-in-self-heal-.patch @@ -0,0 +1,4572 @@ +From ec629963d61c3ec084c95366eec5ee3a976b1213 Mon Sep 17 00:00:00 2001 +From: Mohammed Rafi KC <rkavunga@redhat.com> +Date: Thu, 11 Jul 2019 12:57:45 +0530 +Subject: [PATCH 250/255] Revert "mgmt/shd: Implement multiplexing in self heal + daemon" + +This reverts commit 2cede2b87fb3e3e0673be9cf67e7d6eec3f7879c. + +BUG: 1471742 +Change-Id: I3830d9189dfdb567a44935aa97dc963f4594dfdb +fixes: bz#1471742 +Signed-off-by: Mohammed Rafi KC <rkavunga@redhat.com> +Reviewed-on: https://code.engineering.redhat.com/gerrit/175959 +Tested-by: RHGS Build Bot <nigelb@redhat.com> +Reviewed-by: Sunil Kumar Heggodu Gopala Acharya <sheggodu@redhat.com> +--- + glusterfsd/src/glusterfsd-messages.h | 2 +- + glusterfsd/src/glusterfsd-mgmt.c | 238 +------ + glusterfsd/src/glusterfsd.c | 20 +- + libglusterfs/src/defaults-tmpl.c | 19 +- + libglusterfs/src/glusterfs/glusterfs.h | 7 - + libglusterfs/src/glusterfs/libglusterfs-messages.h | 4 +- + libglusterfs/src/glusterfs/xlator.h | 3 - + libglusterfs/src/graph.c | 451 ------------- + libglusterfs/src/graph.y | 3 - + libglusterfs/src/libglusterfs.sym | 5 - + libglusterfs/src/statedump.c | 3 +- + libglusterfs/src/xlator.c | 16 - + rpc/rpc-lib/src/protocol-common.h | 2 - + tests/basic/glusterd/heald.t | 49 +- + .../reset-brick-and-daemons-follow-quorum.t | 8 +- + tests/volume.rc | 6 +- + xlators/mgmt/glusterd/src/Makefile.am | 6 +- + xlators/mgmt/glusterd/src/glusterd-brick-ops.c | 2 +- + xlators/mgmt/glusterd/src/glusterd-conn-mgmt.c | 42 -- + xlators/mgmt/glusterd/src/glusterd-conn-mgmt.h | 4 +- + xlators/mgmt/glusterd/src/glusterd-gfproxyd-svc.c | 3 +- + xlators/mgmt/glusterd/src/glusterd-handler.c | 11 +- + xlators/mgmt/glusterd/src/glusterd-handshake.c | 21 - + xlators/mgmt/glusterd/src/glusterd-mem-types.h | 1 - + xlators/mgmt/glusterd/src/glusterd-messages.h | 4 +- + xlators/mgmt/glusterd/src/glusterd-op-sm.c | 84 +-- + .../mgmt/glusterd/src/glusterd-shd-svc-helper.c | 140 ---- + .../mgmt/glusterd/src/glusterd-shd-svc-helper.h | 45 -- + xlators/mgmt/glusterd/src/glusterd-shd-svc.c | 540 ++-------------- + xlators/mgmt/glusterd/src/glusterd-shd-svc.h | 17 +- + xlators/mgmt/glusterd/src/glusterd-sm.c | 12 +- + xlators/mgmt/glusterd/src/glusterd-snapd-svc.c | 3 +- + xlators/mgmt/glusterd/src/glusterd-statedump.c | 3 + + xlators/mgmt/glusterd/src/glusterd-svc-helper.c | 715 +-------------------- + xlators/mgmt/glusterd/src/glusterd-svc-helper.h | 40 +- + xlators/mgmt/glusterd/src/glusterd-svc-mgmt.c | 246 ++----- + xlators/mgmt/glusterd/src/glusterd-svc-mgmt.h | 27 - + xlators/mgmt/glusterd/src/glusterd-tier.c | 3 +- + xlators/mgmt/glusterd/src/glusterd-tierd-svc.c | 4 +- + xlators/mgmt/glusterd/src/glusterd-utils.c | 137 +--- + xlators/mgmt/glusterd/src/glusterd-utils.h | 4 - + xlators/mgmt/glusterd/src/glusterd-volgen.c | 60 +- + xlators/mgmt/glusterd/src/glusterd-volgen.h | 11 +- + xlators/mgmt/glusterd/src/glusterd-volume-ops.c | 8 +- + xlators/mgmt/glusterd/src/glusterd.c | 12 +- + xlators/mgmt/glusterd/src/glusterd.h | 30 +- + xlators/protocol/client/src/client.c | 31 +- + 47 files changed, 292 insertions(+), 2810 deletions(-) + delete mode 100644 xlators/mgmt/glusterd/src/glusterd-shd-svc-helper.c + delete mode 100644 xlators/mgmt/glusterd/src/glusterd-shd-svc-helper.h + +diff --git a/glusterfsd/src/glusterfsd-messages.h b/glusterfsd/src/glusterfsd-messages.h +index 280624c..ce6c8ca 100644 +--- a/glusterfsd/src/glusterfsd-messages.h ++++ b/glusterfsd/src/glusterfsd-messages.h +@@ -36,6 +36,6 @@ GLFS_MSGID(GLUSTERFSD, glusterfsd_msg_1, glusterfsd_msg_2, glusterfsd_msg_3, + glusterfsd_msg_31, glusterfsd_msg_32, glusterfsd_msg_33, + glusterfsd_msg_34, glusterfsd_msg_35, glusterfsd_msg_36, + glusterfsd_msg_37, glusterfsd_msg_38, glusterfsd_msg_39, +- glusterfsd_msg_40, glusterfsd_msg_41, glusterfsd_msg_42, glusterfsd_msg_43); ++ glusterfsd_msg_40); + + #endif /* !_GLUSTERFSD_MESSAGES_H_ */ +diff --git a/glusterfsd/src/glusterfsd-mgmt.c b/glusterfsd/src/glusterfsd-mgmt.c +index 1d2cd1a..15acc10 100644 +--- a/glusterfsd/src/glusterfsd-mgmt.c ++++ b/glusterfsd/src/glusterfsd-mgmt.c +@@ -48,20 +48,7 @@ int + glusterfs_graph_unknown_options(glusterfs_graph_t *graph); + int + emancipate(glusterfs_ctx_t *ctx, int ret); +-int +-glusterfs_process_svc_attach_volfp(glusterfs_ctx_t *ctx, FILE *fp, +- char *volfile_id, char *checksum); +-int +-glusterfs_mux_volfile_reconfigure(FILE *newvolfile_fp, glusterfs_ctx_t *ctx, +- gf_volfile_t *volfile_obj, char *checksum); +-int +-glusterfs_process_svc_attach_volfp(glusterfs_ctx_t *ctx, FILE *fp, +- char *volfile_id, char *checksum); +-int +-glusterfs_process_svc_detach(glusterfs_ctx_t *ctx, gf_volfile_t *volfile_obj); + +-gf_boolean_t +-mgmt_is_multiplexed_daemon(char *name); + int + mgmt_cbk_spec(struct rpc_clnt *rpc, void *mydata, void *data) + { +@@ -75,96 +62,6 @@ mgmt_cbk_spec(struct rpc_clnt *rpc, void *mydata, void *data) + } + + int +-mgmt_process_volfile(const char *volfile, ssize_t size, char *volfile_id) +-{ +- glusterfs_ctx_t *ctx = NULL; +- int ret = 0; +- FILE *tmpfp = NULL; +- gf_volfile_t *volfile_obj = NULL; +- gf_volfile_t *volfile_tmp = NULL; +- char sha256_hash[SHA256_DIGEST_LENGTH] = { +- 0, +- }; +- int tmp_fd = -1; +- char template[] = "/tmp/glfs.volfile.XXXXXX"; +- +- glusterfs_compute_sha256((const unsigned char *)volfile, size, sha256_hash); +- ctx = THIS->ctx; +- LOCK(&ctx->volfile_lock); +- { +- list_for_each_entry(volfile_obj, &ctx->volfile_list, volfile_list) +- { +- if (!strcmp(volfile_id, volfile_obj->vol_id)) { +- if (!memcmp(sha256_hash, volfile_obj->volfile_checksum, +- sizeof(volfile_obj->volfile_checksum))) { +- UNLOCK(&ctx->volfile_lock); +- gf_msg(THIS->name, GF_LOG_INFO, 0, glusterfsd_msg_40, +- "No change in volfile, continuing"); +- goto out; +- } +- volfile_tmp = volfile_obj; +- break; +- } +- } +- +- /* coverity[secure_temp] mkstemp uses 0600 as the mode */ +- tmp_fd = mkstemp(template); +- if (-1 == tmp_fd) { +- UNLOCK(&ctx->volfile_lock); +- gf_msg(THIS->name, GF_LOG_ERROR, 0, glusterfsd_msg_39, +- "Unable to create temporary file: %s", template); +- ret = -1; +- goto out; +- } +- +- /* Calling unlink so that when the file is closed or program +- * terminates the temporary file is deleted. +- */ +- ret = sys_unlink(template); +- if (ret < 0) { +- gf_msg(THIS->name, GF_LOG_INFO, 0, glusterfsd_msg_39, +- "Unable to delete temporary file: %s", template); +- ret = 0; +- } +- +- tmpfp = fdopen(tmp_fd, "w+b"); +- if (!tmpfp) { +- ret = -1; +- goto unlock; +- } +- +- fwrite(volfile, size, 1, tmpfp); +- fflush(tmpfp); +- if (ferror(tmpfp)) { +- ret = -1; +- goto unlock; +- } +- +- if (!volfile_tmp) { +- /* There is no checksum in the list, which means simple attach +- * the volfile +- */ +- ret = glusterfs_process_svc_attach_volfp(ctx, tmpfp, volfile_id, +- sha256_hash); +- goto unlock; +- } +- ret = glusterfs_mux_volfile_reconfigure(tmpfp, ctx, volfile_obj, +- sha256_hash); +- if (ret < 0) { +- gf_msg_debug("glusterfsd-mgmt", EINVAL, "Reconfigure failed !!"); +- } +- } +-unlock: +- UNLOCK(&ctx->volfile_lock); +-out: +- if (tmpfp) +- fclose(tmpfp); +- else if (tmp_fd != -1) +- sys_close(tmp_fd); +- return ret; +-} +- +-int + mgmt_cbk_event(struct rpc_clnt *rpc, void *mydata, void *data) + { + return 0; +@@ -1069,110 +966,6 @@ glusterfs_handle_attach(rpcsvc_request_t *req) + } + + int +-glusterfs_handle_svc_attach(rpcsvc_request_t *req) +-{ +- int32_t ret = -1; +- gd1_mgmt_brick_op_req xlator_req = { +- 0, +- }; +- xlator_t *this = NULL; +- glusterfs_ctx_t *ctx = NULL; +- +- GF_ASSERT(req); +- this = THIS; +- GF_ASSERT(this); +- +- ctx = this->ctx; +- ret = xdr_to_generic(req->msg[0], &xlator_req, +- (xdrproc_t)xdr_gd1_mgmt_brick_op_req); +- +- if (ret < 0) { +- /*failed to decode msg;*/ +- req->rpc_err = GARBAGE_ARGS; +- goto out; +- } +- gf_msg(THIS->name, GF_LOG_INFO, 0, glusterfsd_msg_41, +- "received attach " +- "request for volfile-id=%s", +- xlator_req.name); +- ret = 0; +- +- if (ctx->active) { +- ret = mgmt_process_volfile(xlator_req.input.input_val, +- xlator_req.input.input_len, xlator_req.name); +- } else { +- gf_msg(this->name, GF_LOG_WARNING, EINVAL, glusterfsd_msg_42, +- "got attach for %s but no active graph", xlator_req.name); +- } +-out: +- if (xlator_req.input.input_val) +- free(xlator_req.input.input_val); +- if (xlator_req.name) +- free(xlator_req.name); +- glusterfs_translator_info_response_send(req, ret, NULL, NULL); +- return 0; +-} +- +-int +-glusterfs_handle_svc_detach(rpcsvc_request_t *req) +-{ +- gd1_mgmt_brick_op_req xlator_req = { +- 0, +- }; +- ssize_t ret; +- glusterfs_ctx_t *ctx = NULL; +- gf_volfile_t *volfile_obj = NULL; +- gf_volfile_t *volfile_tmp = NULL; +- +- ret = xdr_to_generic(req->msg[0], &xlator_req, +- (xdrproc_t)xdr_gd1_mgmt_brick_op_req); +- if (ret < 0) { +- req->rpc_err = GARBAGE_ARGS; +- return -1; +- } +- ctx = glusterfsd_ctx; +- +- LOCK(&ctx->volfile_lock); +- { +- list_for_each_entry(volfile_obj, &ctx->volfile_list, volfile_list) +- { +- if (!strcmp(xlator_req.name, volfile_obj->vol_id)) { +- volfile_tmp = volfile_obj; +- break; +- } +- } +- +- if (!volfile_tmp) { +- UNLOCK(&ctx->volfile_lock); +- gf_msg(THIS->name, GF_LOG_ERROR, 0, glusterfsd_msg_41, +- "can't detach %s - not found", xlator_req.name); +- /* +- * Used to be -ENOENT. However, the caller asked us to +- * make sure it's down and if it's already down that's +- * good enough. +- */ +- ret = 0; +- goto out; +- } +- ret = glusterfs_process_svc_detach(ctx, volfile_tmp); +- if (ret) { +- UNLOCK(&ctx->volfile_lock); +- gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, EINVAL, glusterfsd_msg_41, +- "Could not detach " +- "old graph. Aborting the reconfiguration operation"); +- goto out; +- } +- } +- UNLOCK(&ctx->volfile_lock); +-out: +- glusterfs_terminate_response_send(req, ret); +- free(xlator_req.name); +- xlator_req.name = NULL; +- +- return 0; +-} +- +-int + glusterfs_handle_dump_metrics(rpcsvc_request_t *req) + { + int32_t ret = -1; +@@ -2056,13 +1849,6 @@ rpcsvc_actor_t glusterfs_actors[GLUSTERD_BRICK_MAXVALUE] = { + + [GLUSTERD_DUMP_METRICS] = {"DUMP METRICS", GLUSTERD_DUMP_METRICS, + glusterfs_handle_dump_metrics, NULL, 0, DRC_NA}, +- +- [GLUSTERD_SVC_ATTACH] = {"ATTACH CLIENT", GLUSTERD_SVC_ATTACH, +- glusterfs_handle_svc_attach, NULL, 0, DRC_NA}, +- +- [GLUSTERD_SVC_DETACH] = {"DETACH CLIENT", GLUSTERD_SVC_DETACH, +- glusterfs_handle_svc_detach, NULL, 0, DRC_NA}, +- + }; + + struct rpcsvc_program glusterfs_mop_prog = { +@@ -2210,17 +1996,14 @@ mgmt_getspec_cbk(struct rpc_req *req, struct iovec *iov, int count, + } + + volfile: ++ ret = 0; + size = rsp.op_ret; +- volfile_id = frame->local; +- if (mgmt_is_multiplexed_daemon(ctx->cmd_args.process_name)) { +- ret = mgmt_process_volfile((const char *)rsp.spec, size, volfile_id); +- goto post_graph_mgmt; +- } + +- ret = 0; + glusterfs_compute_sha256((const unsigned char *)rsp.spec, size, + sha256_hash); + ++ volfile_id = frame->local; ++ + LOCK(&ctx->volfile_lock); + { + locked = 1; +@@ -2322,7 +2105,6 @@ volfile: + } + + INIT_LIST_HEAD(&volfile_tmp->volfile_list); +- volfile_tmp->graph = ctx->active; + list_add(&volfile_tmp->volfile_list, &ctx->volfile_list); + snprintf(volfile_tmp->vol_id, sizeof(volfile_tmp->vol_id), "%s", + volfile_id); +@@ -2334,7 +2116,6 @@ volfile: + + locked = 0; + +-post_graph_mgmt: + if (!is_mgmt_rpc_reconnect) { + need_emancipate = 1; + glusterfs_mgmt_pmap_signin(ctx); +@@ -2488,21 +2269,10 @@ glusterfs_volfile_fetch(glusterfs_ctx_t *ctx) + { + xlator_t *server_xl = NULL; + xlator_list_t *trav; +- gf_volfile_t *volfile_obj = NULL; +- int ret = 0; ++ int ret; + + LOCK(&ctx->volfile_lock); + { +- if (ctx->active && +- mgmt_is_multiplexed_daemon(ctx->cmd_args.process_name)) { +- list_for_each_entry(volfile_obj, &ctx->volfile_list, volfile_list) +- { +- ret |= glusterfs_volfile_fetch_one(ctx, volfile_obj->vol_id); +- } +- UNLOCK(&ctx->volfile_lock); +- return ret; +- } +- + if (ctx->active) { + server_xl = ctx->active->first; + if (strcmp(server_xl->type, "protocol/server") != 0) { +diff --git a/glusterfsd/src/glusterfsd.c b/glusterfsd/src/glusterfsd.c +index 2172af4..5b5e996 100644 +--- a/glusterfsd/src/glusterfsd.c ++++ b/glusterfsd/src/glusterfsd.c +@@ -2593,6 +2593,24 @@ out: + #endif + + int ++glusterfs_graph_fini(glusterfs_graph_t *graph) ++{ ++ xlator_t *trav = NULL; ++ ++ trav = graph->first; ++ ++ while (trav) { ++ if (trav->init_succeeded) { ++ trav->fini(trav); ++ trav->init_succeeded = 0; ++ } ++ trav = trav->next; ++ } ++ ++ return 0; ++} ++ ++int + glusterfs_process_volfp(glusterfs_ctx_t *ctx, FILE *fp) + { + glusterfs_graph_t *graph = NULL; +@@ -2791,7 +2809,7 @@ main(int argc, char *argv[]) + + /* set brick_mux mode only for server process */ + if ((ctx->process_mode != GF_SERVER_PROCESS) && cmd->brick_mux) { +- gf_msg("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_43, ++ gf_msg("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_40, + "command line argument --brick-mux is valid only for brick " + "process"); + goto out; +diff --git a/libglusterfs/src/defaults-tmpl.c b/libglusterfs/src/defaults-tmpl.c +index 82e7f78..5bf64e8 100644 +--- a/libglusterfs/src/defaults-tmpl.c ++++ b/libglusterfs/src/defaults-tmpl.c +@@ -127,12 +127,6 @@ default_notify(xlator_t *this, int32_t event, void *data, ...) + GF_UNUSED int ret = 0; + xlator_t *victim = data; + +- glusterfs_graph_t *graph = NULL; +- +- GF_VALIDATE_OR_GOTO("notify", this, out); +- graph = this->graph; +- GF_VALIDATE_OR_GOTO(this->name, graph, out); +- + switch (event) { + case GF_EVENT_PARENT_UP: + case GF_EVENT_PARENT_DOWN: { +@@ -165,17 +159,6 @@ default_notify(xlator_t *this, int32_t event, void *data, ...) + xlator_notify(parent->xlator, event, this, NULL); + parent = parent->next; + } +- +- if (event == GF_EVENT_CHILD_DOWN && +- !(this->ctx && this->ctx->master) && (graph->top == this)) { +- /* Make sure this is not a daemon with master xlator */ +- pthread_mutex_lock(&graph->mutex); +- { +- graph->used = 0; +- pthread_cond_broadcast(&graph->child_down_cond); +- } +- pthread_mutex_unlock(&graph->mutex); +- } + } break; + case GF_EVENT_UPCALL: { + xlator_list_t *parent = this->parents; +@@ -222,7 +205,7 @@ default_notify(xlator_t *this, int32_t event, void *data, ...) + * nothing to do with readability. + */ + } +-out: ++ + return 0; + } + +diff --git a/libglusterfs/src/glusterfs/glusterfs.h b/libglusterfs/src/glusterfs/glusterfs.h +index 9ec2365..2cedf1a 100644 +--- a/libglusterfs/src/glusterfs/glusterfs.h ++++ b/libglusterfs/src/glusterfs/glusterfs.h +@@ -597,10 +597,6 @@ struct _glusterfs_graph { + int used; /* Should be set when fuse gets + first CHILD_UP */ + uint32_t volfile_checksum; +- void *last_xl; /* Stores the last xl of the graph, as of now only populated +- in client multiplexed code path */ +- pthread_mutex_t mutex; +- pthread_cond_t child_down_cond; /* for broadcasting CHILD_DOWN */ + }; + typedef struct _glusterfs_graph glusterfs_graph_t; + +@@ -743,7 +739,6 @@ typedef struct { + char volfile_checksum[SHA256_DIGEST_LENGTH]; + char vol_id[NAME_MAX + 1]; + struct list_head volfile_list; +- glusterfs_graph_t *graph; + + } gf_volfile_t; + +@@ -827,6 +822,4 @@ gf_free_mig_locks(lock_migration_info_t *locks); + + int + glusterfs_read_secure_access_file(void); +-int +-glusterfs_graph_fini(glusterfs_graph_t *graph); + #endif /* _GLUSTERFS_H */ +diff --git a/libglusterfs/src/glusterfs/libglusterfs-messages.h b/libglusterfs/src/glusterfs/libglusterfs-messages.h +index ea2aa60..1b72f6d 100644 +--- a/libglusterfs/src/glusterfs/libglusterfs-messages.h ++++ b/libglusterfs/src/glusterfs/libglusterfs-messages.h +@@ -109,8 +109,6 @@ GLFS_MSGID( + LG_MSG_PTHREAD_ATTR_INIT_FAILED, LG_MSG_INVALID_INODE_LIST, + LG_MSG_COMPACT_FAILED, LG_MSG_COMPACT_STATUS, LG_MSG_UTIMENSAT_FAILED, + LG_MSG_PTHREAD_NAMING_FAILED, LG_MSG_SYSCALL_RETURNS_WRONG, +- LG_MSG_XXH64_TO_GFID_FAILED, LG_MSG_ASYNC_WARNING, LG_MSG_ASYNC_FAILURE, +- LG_MSG_GRAPH_CLEANUP_FAILED, LG_MSG_GRAPH_SETUP_FAILED, +- LG_MSG_GRAPH_DETACH_STARTED, LG_MSG_GRAPH_ATTACH_FAILED); ++ LG_MSG_XXH64_TO_GFID_FAILED); + + #endif /* !_LG_MESSAGES_H_ */ +diff --git a/libglusterfs/src/glusterfs/xlator.h b/libglusterfs/src/glusterfs/xlator.h +index 8998976..b78daad 100644 +--- a/libglusterfs/src/glusterfs/xlator.h ++++ b/libglusterfs/src/glusterfs/xlator.h +@@ -1089,7 +1089,4 @@ handle_default_options(xlator_t *xl, dict_t *options); + + void + gluster_graph_take_reference(xlator_t *tree); +- +-gf_boolean_t +-mgmt_is_multiplexed_daemon(char *name); + #endif /* _XLATOR_H */ +diff --git a/libglusterfs/src/graph.c b/libglusterfs/src/graph.c +index a492dd8..bb5e67a 100644 +--- a/libglusterfs/src/graph.c ++++ b/libglusterfs/src/graph.c +@@ -114,53 +114,6 @@ out: + return cert_depth; + } + +-xlator_t * +-glusterfs_get_last_xlator(glusterfs_graph_t *graph) +-{ +- xlator_t *trav = graph->first; +- if (!trav) +- return NULL; +- +- while (trav->next) +- trav = trav->next; +- +- return trav; +-} +- +-xlator_t * +-glusterfs_mux_xlator_unlink(xlator_t *pxl, xlator_t *cxl) +-{ +- xlator_list_t *unlink = NULL; +- xlator_list_t *prev = NULL; +- xlator_list_t **tmp = NULL; +- xlator_t *next_child = NULL; +- xlator_t *xl = NULL; +- +- for (tmp = &pxl->children; *tmp; tmp = &(*tmp)->next) { +- if ((*tmp)->xlator == cxl) { +- unlink = *tmp; +- *tmp = (*tmp)->next; +- if (*tmp) +- next_child = (*tmp)->xlator; +- break; +- } +- prev = *tmp; +- } +- +- if (!prev) +- xl = pxl; +- else if (prev->xlator) +- xl = prev->xlator->graph->last_xl; +- +- if (xl) +- xl->next = next_child; +- if (next_child) +- next_child->prev = xl; +- +- GF_FREE(unlink); +- return next_child; +-} +- + int + glusterfs_xlator_link(xlator_t *pxl, xlator_t *cxl) + { +@@ -1139,8 +1092,6 @@ glusterfs_graph_destroy_residual(glusterfs_graph_t *graph) + ret = xlator_tree_free_memacct(graph->first); + + list_del_init(&graph->list); +- pthread_mutex_destroy(&graph->mutex); +- pthread_cond_destroy(&graph->child_down_cond); + GF_FREE(graph); + + return ret; +@@ -1183,25 +1134,6 @@ out: + } + + int +-glusterfs_graph_fini(glusterfs_graph_t *graph) +-{ +- xlator_t *trav = NULL; +- +- trav = graph->first; +- +- while (trav) { +- if (trav->init_succeeded) { +- trav->cleanup_starting = 1; +- trav->fini(trav); +- trav->init_succeeded = 0; +- } +- trav = trav->next; +- } +- +- return 0; +-} +- +-int + glusterfs_graph_attach(glusterfs_graph_t *orig_graph, char *path, + glusterfs_graph_t **newgraph) + { +@@ -1324,386 +1256,3 @@ glusterfs_graph_attach(glusterfs_graph_t *orig_graph, char *path, + + return 0; + } +-int +-glusterfs_muxsvc_cleanup_parent(glusterfs_ctx_t *ctx, +- glusterfs_graph_t *parent_graph) +-{ +- if (parent_graph) { +- if (parent_graph->first) { +- xlator_destroy(parent_graph->first); +- } +- ctx->active = NULL; +- GF_FREE(parent_graph); +- parent_graph = NULL; +- } +- return 0; +-} +- +-void * +-glusterfs_graph_cleanup(void *arg) +-{ +- glusterfs_graph_t *graph = NULL; +- glusterfs_ctx_t *ctx = THIS->ctx; +- int ret = -1; +- graph = arg; +- +- if (!graph) +- return NULL; +- +- /* To destroy the graph, fitst sent a GF_EVENT_PARENT_DOWN +- * Then wait for GF_EVENT_CHILD_DOWN to get on the top +- * xl. Once we have GF_EVENT_CHILD_DOWN event, then proceed +- * to fini. +- * +- * During fini call, this will take a last unref on rpc and +- * rpc_transport_object. +- */ +- if (graph->first) +- default_notify(graph->first, GF_EVENT_PARENT_DOWN, graph->first); +- +- ret = pthread_mutex_lock(&graph->mutex); +- if (ret != 0) { +- gf_msg("glusterfs", GF_LOG_ERROR, EAGAIN, LG_MSG_GRAPH_CLEANUP_FAILED, +- "Failed to aquire a lock"); +- goto out; +- } +- /* check and wait for CHILD_DOWN for top xlator*/ +- while (graph->used) { +- ret = pthread_cond_wait(&graph->child_down_cond, &graph->mutex); +- if (ret != 0) +- gf_msg("glusterfs", GF_LOG_INFO, 0, LG_MSG_GRAPH_CLEANUP_FAILED, +- "cond wait failed "); +- } +- +- ret = pthread_mutex_unlock(&graph->mutex); +- if (ret != 0) { +- gf_msg("glusterfs", GF_LOG_ERROR, EAGAIN, LG_MSG_GRAPH_CLEANUP_FAILED, +- "Failed to release a lock"); +- } +- +- /* Though we got a child down on top xlator, we have to wait until +- * all the notifier to exit. Because there should not be any threads +- * that access xl variables. +- */ +- pthread_mutex_lock(&ctx->notify_lock); +- { +- while (ctx->notifying) +- pthread_cond_wait(&ctx->notify_cond, &ctx->notify_lock); +- } +- pthread_mutex_unlock(&ctx->notify_lock); +- +- glusterfs_graph_fini(graph); +- glusterfs_graph_destroy(graph); +-out: +- return NULL; +-} +- +-glusterfs_graph_t * +-glusterfs_muxsvc_setup_parent_graph(glusterfs_ctx_t *ctx, char *name, +- char *type) +-{ +- glusterfs_graph_t *parent_graph = NULL; +- xlator_t *ixl = NULL; +- int ret = -1; +- parent_graph = GF_CALLOC(1, sizeof(*parent_graph), +- gf_common_mt_glusterfs_graph_t); +- if (!parent_graph) +- goto out; +- +- INIT_LIST_HEAD(&parent_graph->list); +- +- ctx->active = parent_graph; +- ixl = GF_CALLOC(1, sizeof(*ixl), gf_common_mt_xlator_t); +- if (!ixl) +- goto out; +- +- ixl->ctx = ctx; +- ixl->graph = parent_graph; +- ixl->options = dict_new(); +- if (!ixl->options) +- goto out; +- +- ixl->name = gf_strdup(name); +- if (!ixl->name) +- goto out; +- +- ixl->is_autoloaded = 1; +- +- if (xlator_set_type(ixl, type) == -1) { +- gf_msg("glusterfs", GF_LOG_ERROR, EINVAL, LG_MSG_GRAPH_SETUP_FAILED, +- "%s (%s) set type failed", name, type); +- goto out; +- } +- +- glusterfs_graph_set_first(parent_graph, ixl); +- parent_graph->top = ixl; +- ixl = NULL; +- +- gettimeofday(&parent_graph->dob, NULL); +- fill_uuid(parent_graph->graph_uuid, 128); +- parent_graph->id = ctx->graph_id++; +- ret = 0; +-out: +- if (ixl) +- xlator_destroy(ixl); +- +- if (ret) { +- glusterfs_muxsvc_cleanup_parent(ctx, parent_graph); +- parent_graph = NULL; +- } +- return parent_graph; +-} +- +-int +-glusterfs_process_svc_detach(glusterfs_ctx_t *ctx, gf_volfile_t *volfile_obj) +-{ +- xlator_t *last_xl = NULL; +- glusterfs_graph_t *graph = NULL; +- glusterfs_graph_t *parent_graph = NULL; +- pthread_t clean_graph = { +- 0, +- }; +- int ret = -1; +- xlator_t *xl = NULL; +- +- if (!ctx || !ctx->active || !volfile_obj) +- goto out; +- parent_graph = ctx->active; +- graph = volfile_obj->graph; +- if (graph && graph->first) +- xl = graph->first; +- +- last_xl = graph->last_xl; +- if (last_xl) +- last_xl->next = NULL; +- if (!xl || xl->cleanup_starting) +- goto out; +- +- xl->cleanup_starting = 1; +- gf_msg("mgmt", GF_LOG_INFO, 0, LG_MSG_GRAPH_DETACH_STARTED, +- "detaching child %s", volfile_obj->vol_id); +- +- list_del_init(&volfile_obj->volfile_list); +- glusterfs_mux_xlator_unlink(parent_graph->top, xl); +- parent_graph->last_xl = glusterfs_get_last_xlator(parent_graph); +- parent_graph->xl_count -= graph->xl_count; +- parent_graph->leaf_count -= graph->leaf_count; +- default_notify(xl, GF_EVENT_PARENT_DOWN, xl); +- parent_graph->id++; +- ret = 0; +-out: +- if (!ret) { +- list_del_init(&volfile_obj->volfile_list); +- if (graph) { +- ret = gf_thread_create_detached( +- &clean_graph, glusterfs_graph_cleanup, graph, "graph_clean"); +- if (ret) { +- gf_msg("glusterfs", GF_LOG_ERROR, EINVAL, +- LG_MSG_GRAPH_CLEANUP_FAILED, +- "%s failed to create clean " +- "up thread", +- volfile_obj->vol_id); +- ret = 0; +- } +- } +- GF_FREE(volfile_obj); +- } +- return ret; +-} +- +-int +-glusterfs_process_svc_attach_volfp(glusterfs_ctx_t *ctx, FILE *fp, +- char *volfile_id, char *checksum) +-{ +- glusterfs_graph_t *graph = NULL; +- glusterfs_graph_t *parent_graph = NULL; +- glusterfs_graph_t *clean_graph = NULL; +- int ret = -1; +- xlator_t *xl = NULL; +- xlator_t *last_xl = NULL; +- gf_volfile_t *volfile_obj = NULL; +- pthread_t thread_id = { +- 0, +- }; +- +- if (!ctx) +- goto out; +- parent_graph = ctx->active; +- graph = glusterfs_graph_construct(fp); +- if (!graph) { +- gf_msg("glusterfsd", GF_LOG_ERROR, EINVAL, LG_MSG_GRAPH_ATTACH_FAILED, +- "failed to construct the graph"); +- goto out; +- } +- graph->last_xl = glusterfs_get_last_xlator(graph); +- +- for (xl = graph->first; xl; xl = xl->next) { +- if (strcmp(xl->type, "mount/fuse") == 0) { +- gf_msg("glusterfsd", GF_LOG_ERROR, EINVAL, +- LG_MSG_GRAPH_ATTACH_FAILED, +- "fuse xlator cannot be specified in volume file"); +- goto out; +- } +- } +- +- graph->leaf_count = glusterfs_count_leaves(glusterfs_root(graph)); +- xl = graph->first; +- /* TODO memory leaks everywhere need to free graph in case of error */ +- if (glusterfs_graph_prepare(graph, ctx, xl->name)) { +- gf_msg("glusterfsd", GF_LOG_WARNING, EINVAL, LG_MSG_GRAPH_ATTACH_FAILED, +- "failed to prepare graph for xlator %s", xl->name); +- ret = -1; +- goto out; +- } else if (glusterfs_graph_init(graph)) { +- gf_msg("glusterfsd", GF_LOG_WARNING, EINVAL, LG_MSG_GRAPH_ATTACH_FAILED, +- "failed to initialize graph for xlator %s", xl->name); +- ret = -1; +- goto out; +- } else if (glusterfs_graph_parent_up(graph)) { +- gf_msg("glusterfsd", GF_LOG_WARNING, EINVAL, LG_MSG_GRAPH_ATTACH_FAILED, +- "failed to link the graphs for xlator %s ", xl->name); +- ret = -1; +- goto out; +- } +- +- if (!parent_graph) { +- parent_graph = glusterfs_muxsvc_setup_parent_graph(ctx, "glustershd", +- "debug/io-stats"); +- if (!parent_graph) +- goto out; +- ((xlator_t *)parent_graph->top)->next = xl; +- clean_graph = parent_graph; +- } else { +- last_xl = parent_graph->last_xl; +- if (last_xl) +- last_xl->next = xl; +- xl->prev = last_xl; +- } +- parent_graph->last_xl = graph->last_xl; +- +- ret = glusterfs_xlator_link(parent_graph->top, xl); +- if (ret) { +- gf_msg("graph", GF_LOG_ERROR, 0, LG_MSG_EVENT_NOTIFY_FAILED, +- "parent up notification failed"); +- goto out; +- } +- parent_graph->xl_count += graph->xl_count; +- parent_graph->leaf_count += graph->leaf_count; +- parent_graph->id++; +- +- if (!volfile_obj) { +- volfile_obj = GF_CALLOC(1, sizeof(gf_volfile_t), gf_common_volfile_t); +- if (!volfile_obj) { +- ret = -1; +- goto out; +- } +- } +- +- graph->used = 1; +- parent_graph->id++; +- list_add(&graph->list, &ctx->graphs); +- INIT_LIST_HEAD(&volfile_obj->volfile_list); +- volfile_obj->graph = graph; +- snprintf(volfile_obj->vol_id, sizeof(volfile_obj->vol_id), "%s", +- volfile_id); +- memcpy(volfile_obj->volfile_checksum, checksum, +- sizeof(volfile_obj->volfile_checksum)); +- list_add_tail(&volfile_obj->volfile_list, &ctx->volfile_list); +- +- gf_log_dump_graph(fp, graph); +- graph = NULL; +- +- ret = 0; +-out: +- if (ret) { +- if (graph) { +- gluster_graph_take_reference(graph->first); +- ret = gf_thread_create_detached(&thread_id, glusterfs_graph_cleanup, +- graph, "graph_clean"); +- if (ret) { +- gf_msg("glusterfs", GF_LOG_ERROR, EINVAL, +- LG_MSG_GRAPH_CLEANUP_FAILED, +- "%s failed to create clean " +- "up thread", +- volfile_id); +- ret = 0; +- } +- } +- if (clean_graph) +- glusterfs_muxsvc_cleanup_parent(ctx, clean_graph); +- } +- return ret; +-} +- +-int +-glusterfs_mux_volfile_reconfigure(FILE *newvolfile_fp, glusterfs_ctx_t *ctx, +- gf_volfile_t *volfile_obj, char *checksum) +-{ +- 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; +- } +- +- /* Change the message id */ +- if (!volfile_obj) { +- gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, 0, LG_MSG_CTX_NULL, +- "failed to get volfile object"); +- goto out; +- } +- +- oldvolfile_graph = volfile_obj->graph; +- if (!oldvolfile_graph) { +- goto out; +- } +- +- newvolfile_graph = glusterfs_graph_construct(newvolfile_fp); +- +- if (!newvolfile_graph) { +- goto out; +- } +- newvolfile_graph->last_xl = glusterfs_get_last_xlator(newvolfile_graph); +- +- glusterfs_graph_prepare(newvolfile_graph, ctx, newvolfile_graph->first); +- +- if (!is_graph_topology_equal(oldvolfile_graph, newvolfile_graph)) { +- ret = glusterfs_process_svc_detach(ctx, volfile_obj); +- if (ret) { +- gf_msg("glusterfsd-mgmt", GF_LOG_ERROR, EINVAL, +- LG_MSG_GRAPH_CLEANUP_FAILED, +- "Could not detach " +- "old graph. Aborting the reconfiguration operation"); +- goto out; +- } +- ret = glusterfs_process_svc_attach_volfp(ctx, newvolfile_fp, +- volfile_obj->vol_id, checksum); +- 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; +- } +- memcpy(volfile_obj->volfile_checksum, checksum, +- sizeof(volfile_obj->volfile_checksum)); +- +- ret = 0; +-out: +- +- if (newvolfile_graph) +- glusterfs_graph_destroy(newvolfile_graph); +- +- return ret; +-} +diff --git a/libglusterfs/src/graph.y b/libglusterfs/src/graph.y +index c60ff38..5b92985 100644 +--- a/libglusterfs/src/graph.y ++++ b/libglusterfs/src/graph.y +@@ -542,9 +542,6 @@ glusterfs_graph_new () + + INIT_LIST_HEAD (&graph->list); + +- pthread_mutex_init(&graph->mutex, NULL); +- pthread_cond_init(&graph->child_down_cond, NULL); +- + gettimeofday (&graph->dob, NULL); + + return graph; +diff --git a/libglusterfs/src/libglusterfs.sym b/libglusterfs/src/libglusterfs.sym +index 05f93b4..4dca7de 100644 +--- a/libglusterfs/src/libglusterfs.sym ++++ b/libglusterfs/src/libglusterfs.sym +@@ -1155,8 +1155,3 @@ gf_changelog_register_generic + gf_gfid_generate_from_xxh64 + find_xlator_option_in_cmd_args_t + gf_d_type_from_ia_type +-glusterfs_graph_fini +-glusterfs_process_svc_attach_volfp +-glusterfs_mux_volfile_reconfigure +-glusterfs_process_svc_detach +-mgmt_is_multiplexed_daemon +diff --git a/libglusterfs/src/statedump.c b/libglusterfs/src/statedump.c +index 0cf80c0..d18b50f 100644 +--- a/libglusterfs/src/statedump.c ++++ b/libglusterfs/src/statedump.c +@@ -810,8 +810,7 @@ gf_proc_dump_info(int signum, glusterfs_ctx_t *ctx) + if (!ctx) + goto out; + +- if (!mgmt_is_multiplexed_daemon(ctx->cmd_args.process_name) && +- (ctx && ctx->active)) { ++ if (ctx && ctx->active) { + top = ctx->active->first; + for (trav_p = &top->children; *trav_p; trav_p = &(*trav_p)->next) { + brick_count++; +diff --git a/libglusterfs/src/xlator.c b/libglusterfs/src/xlator.c +index 022c3ed..6bd4f09 100644 +--- a/libglusterfs/src/xlator.c ++++ b/libglusterfs/src/xlator.c +@@ -1470,19 +1470,3 @@ gluster_graph_take_reference(xlator_t *tree) + } + return; + } +- +-gf_boolean_t +-mgmt_is_multiplexed_daemon(char *name) +-{ +- const char *mux_daemons[] = {"glustershd", NULL}; +- int i; +- +- if (!name) +- return _gf_false; +- +- for (i = 0; mux_daemons[i]; i++) { +- if (!strcmp(name, mux_daemons[i])) +- return _gf_true; +- } +- return _gf_false; +-} +diff --git a/rpc/rpc-lib/src/protocol-common.h b/rpc/rpc-lib/src/protocol-common.h +index 7275d75..779878f 100644 +--- a/rpc/rpc-lib/src/protocol-common.h ++++ b/rpc/rpc-lib/src/protocol-common.h +@@ -245,8 +245,6 @@ enum glusterd_brick_procnum { + GLUSTERD_NODE_BITROT, + GLUSTERD_BRICK_ATTACH, + GLUSTERD_DUMP_METRICS, +- GLUSTERD_SVC_ATTACH, +- GLUSTERD_SVC_DETACH, + GLUSTERD_BRICK_MAXVALUE, + }; + +diff --git a/tests/basic/glusterd/heald.t b/tests/basic/glusterd/heald.t +index 7dae3c3..ca112ad 100644 +--- a/tests/basic/glusterd/heald.t ++++ b/tests/basic/glusterd/heald.t +@@ -7,16 +7,11 @@ + # Covers enable/disable at the moment. Will be enhanced later to include + # the other commands as well. + +-function is_pid_running { +- local pid=$1 +- num=`ps auxww | grep glustershd | grep $pid | grep -v grep | wc -l` +- echo $num +-} +- + cleanup; + TEST glusterd + TEST pidof glusterd + ++volfile=$(gluster system:: getwd)"/glustershd/glustershd-server.vol" + #Commands should fail when volume doesn't exist + TEST ! $CLI volume heal non-existent-volume enable + TEST ! $CLI volume heal non-existent-volume disable +@@ -25,55 +20,51 @@ TEST ! $CLI volume heal non-existent-volume disable + # volumes + TEST $CLI volume create dist $H0:$B0/dist + TEST $CLI volume start dist +-TEST "[ -z $(get_shd_process_pid dist)]" ++TEST "[ -z $(get_shd_process_pid)]" + TEST ! $CLI volume heal dist enable + TEST ! $CLI volume heal dist disable + + # Commands should work on replicate/disperse volume. + TEST $CLI volume create r2 replica 2 $H0:$B0/r2_0 $H0:$B0/r2_1 +-TEST "[ -z $(get_shd_process_pid r2)]" ++TEST "[ -z $(get_shd_process_pid)]" + TEST $CLI volume start r2 +-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid r2 ++EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid + TEST $CLI volume heal r2 enable + EXPECT "enable" volume_option r2 "cluster.self-heal-daemon" +-volfiler2=$(gluster system:: getwd)"/vols/r2/r2-shd.vol" +-EXPECT "enable" volgen_volume_option $volfiler2 r2-replicate-0 cluster replicate self-heal-daemon +-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid r2 +-pid=$( get_shd_process_pid r2 ) ++EXPECT "enable" volgen_volume_option $volfile r2-replicate-0 cluster replicate self-heal-daemon ++EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid + TEST $CLI volume heal r2 disable + EXPECT "disable" volume_option r2 "cluster.self-heal-daemon" +-EXPECT "disable" volgen_volume_option $volfiler2 r2-replicate-0 cluster replicate self-heal-daemon +-EXPECT "1" is_pid_running $pid ++EXPECT "disable" volgen_volume_option $volfile r2-replicate-0 cluster replicate self-heal-daemon ++EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid + + # Commands should work on disperse volume. + TEST $CLI volume create ec2 disperse 3 redundancy 1 $H0:$B0/ec2_0 $H0:$B0/ec2_1 $H0:$B0/ec2_2 + TEST $CLI volume start ec2 +-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid ec2 ++EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid + TEST $CLI volume heal ec2 enable + EXPECT "enable" volume_option ec2 "cluster.disperse-self-heal-daemon" +-volfileec2=$(gluster system:: getwd)"/vols/ec2/ec2-shd.vol" +-EXPECT "enable" volgen_volume_option $volfileec2 ec2-disperse-0 cluster disperse self-heal-daemon +-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid ec2 +-pid=$(get_shd_process_pid ec2) ++EXPECT "enable" volgen_volume_option $volfile ec2-disperse-0 cluster disperse self-heal-daemon ++EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid + TEST $CLI volume heal ec2 disable + EXPECT "disable" volume_option ec2 "cluster.disperse-self-heal-daemon" +-EXPECT "disable" volgen_volume_option $volfileec2 ec2-disperse-0 cluster disperse self-heal-daemon +-EXPECT "1" is_pid_running $pid ++EXPECT "disable" volgen_volume_option $volfile ec2-disperse-0 cluster disperse self-heal-daemon ++EXPECT_WITHIN $PROCESS_UP_TIMEOUT "[0-9][0-9]*" get_shd_process_pid + + #Check that shd graph is rewritten correctly on volume stop/start +-EXPECT "Y" volgen_volume_exists $volfileec2 ec2-disperse-0 cluster disperse +- +-EXPECT "Y" volgen_volume_exists $volfiler2 r2-replicate-0 cluster replicate ++EXPECT "Y" volgen_volume_exists $volfile ec2-disperse-0 cluster disperse ++EXPECT "Y" volgen_volume_exists $volfile r2-replicate-0 cluster replicate + TEST $CLI volume stop r2 +-EXPECT "Y" volgen_volume_exists $volfileec2 ec2-disperse-0 cluster disperse ++EXPECT "Y" volgen_volume_exists $volfile ec2-disperse-0 cluster disperse ++EXPECT "N" volgen_volume_exists $volfile r2-replicate-0 cluster replicate + TEST $CLI volume stop ec2 + # When both the volumes are stopped glustershd volfile is not modified just the + # process is stopped +-TEST "[ -z $(get_shd_process_pid dist) ]" +-TEST "[ -z $(get_shd_process_pid ec2) ]" ++TEST "[ -z $(get_shd_process_pid) ]" + + TEST $CLI volume start r2 +-EXPECT "Y" volgen_volume_exists $volfiler2 r2-replicate-0 cluster replicate ++EXPECT "N" volgen_volume_exists $volfile ec2-disperse-0 cluster disperse ++EXPECT "Y" volgen_volume_exists $volfile r2-replicate-0 cluster replicate + + TEST $CLI volume set r2 self-heal-daemon on + TEST $CLI volume set r2 cluster.self-heal-daemon off +diff --git a/tests/bugs/glusterd/reset-brick-and-daemons-follow-quorum.t b/tests/bugs/glusterd/reset-brick-and-daemons-follow-quorum.t +index e6e65c4..cdb1a33 100644 +--- a/tests/bugs/glusterd/reset-brick-and-daemons-follow-quorum.t ++++ b/tests/bugs/glusterd/reset-brick-and-daemons-follow-quorum.t +@@ -55,9 +55,9 @@ TEST kill_glusterd 1 + #Bring back 1st glusterd + TEST $glusterd_1 + +-# We need to wait till PROCESS_UP_TIMEOUT and then check shd service started +-#on node 2, because once glusterd regains quorum, it will restart all volume +-#level daemons +-EXPECT_WITHIN $PROCESS_UP_TIMEOUT "Y" shd_up_status_2 ++# We need to wait till PROCESS_UP_TIMEOUT and then check shd service does not ++# come up on node 2 ++sleep $PROCESS_UP_TIMEOUT ++EXPECT "N" shd_up_status_2 + + cleanup; +diff --git a/tests/volume.rc b/tests/volume.rc +index 022d972..76a8fd4 100644 +--- a/tests/volume.rc ++++ b/tests/volume.rc +@@ -237,13 +237,11 @@ function ec_child_up_count_shd { + } + + function get_shd_process_pid { +- local vol=$1 +- ps auxww | grep "process-name\ glustershd" | awk '{print $2}' | head -1 ++ ps auxww | grep glusterfs | grep -E "glustershd/glustershd.pid" | awk '{print $2}' | head -1 + } + + function generate_shd_statedump { +- local vol=$1 +- generate_statedump $(get_shd_process_pid $vol) ++ generate_statedump $(get_shd_process_pid) + } + + function generate_nfs_statedump { +diff --git a/xlators/mgmt/glusterd/src/Makefile.am b/xlators/mgmt/glusterd/src/Makefile.am +index 11ae189..5fe5156 100644 +--- a/xlators/mgmt/glusterd/src/Makefile.am ++++ b/xlators/mgmt/glusterd/src/Makefile.am +@@ -18,12 +18,11 @@ glusterd_la_SOURCES = glusterd.c glusterd-handler.c glusterd-sm.c \ + glusterd-locks.c glusterd-snapshot.c glusterd-mgmt-handler.c \ + glusterd-mgmt.c glusterd-peer-utils.c glusterd-statedump.c \ + glusterd-snapshot-utils.c glusterd-conn-mgmt.c \ +- glusterd-proc-mgmt.c glusterd-svc-mgmt.c \ ++ glusterd-proc-mgmt.c glusterd-svc-mgmt.c glusterd-shd-svc.c \ + glusterd-nfs-svc.c glusterd-quotad-svc.c glusterd-svc-helper.c \ + glusterd-conn-helper.c glusterd-snapd-svc.c glusterd-snapd-svc-helper.c \ + glusterd-bitd-svc.c glusterd-scrub-svc.c glusterd-server-quorum.c \ + glusterd-reset-brick.c glusterd-tierd-svc.c glusterd-tierd-svc-helper.c \ +- glusterd-shd-svc.c glusterd-shd-svc-helper.c \ + glusterd-gfproxyd-svc.c glusterd-gfproxyd-svc-helper.c + + +@@ -39,12 +38,11 @@ noinst_HEADERS = glusterd.h glusterd-utils.h glusterd-op-sm.h \ + glusterd-mgmt.h glusterd-messages.h glusterd-peer-utils.h \ + glusterd-statedump.h glusterd-snapshot-utils.h glusterd-geo-rep.h \ + glusterd-conn-mgmt.h glusterd-conn-helper.h glusterd-proc-mgmt.h \ +- glusterd-svc-mgmt.h glusterd-nfs-svc.h \ ++ glusterd-svc-mgmt.h glusterd-shd-svc.h glusterd-nfs-svc.h \ + glusterd-quotad-svc.h glusterd-svc-helper.h glusterd-snapd-svc.h \ + glusterd-snapd-svc-helper.h glusterd-rcu.h glusterd-bitd-svc.h \ + glusterd-scrub-svc.h glusterd-server-quorum.h glusterd-errno.h \ + glusterd-tierd-svc.h glusterd-tierd-svc-helper.h \ +- glusterd-shd-svc.h glusterd-shd-svc-helper.h \ + glusterd-gfproxyd-svc.h glusterd-gfproxyd-svc-helper.h \ + $(CONTRIBDIR)/userspace-rcu/rculist-extra.h + +diff --git a/xlators/mgmt/glusterd/src/glusterd-brick-ops.c b/xlators/mgmt/glusterd/src/glusterd-brick-ops.c +index 042a805..ad9a572 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-brick-ops.c ++++ b/xlators/mgmt/glusterd/src/glusterd-brick-ops.c +@@ -2863,7 +2863,7 @@ glusterd_op_remove_brick(dict_t *dict, char **op_errstr) + } + + if (start_remove && volinfo->status == GLUSTERD_STATUS_STARTED) { +- ret = glusterd_svcs_reconfigure(volinfo); ++ ret = glusterd_svcs_reconfigure(); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, 0, GD_MSG_NFS_RECONF_FAIL, + "Unable to reconfigure NFS-Server"); +diff --git a/xlators/mgmt/glusterd/src/glusterd-conn-mgmt.c b/xlators/mgmt/glusterd/src/glusterd-conn-mgmt.c +index 16eefa1..c6d7a00 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-conn-mgmt.c ++++ b/xlators/mgmt/glusterd/src/glusterd-conn-mgmt.c +@@ -138,45 +138,3 @@ glusterd_conn_build_socket_filepath(char *rundir, uuid_t uuid, char *socketpath, + glusterd_set_socket_filepath(sockfilepath, socketpath, len); + return 0; + } +- +-int +-__glusterd_muxsvc_conn_common_notify(struct rpc_clnt *rpc, void *mydata, +- rpc_clnt_event_t event, void *data) +-{ +- glusterd_conf_t *conf = THIS->private; +- glusterd_svc_proc_t *mux_proc = mydata; +- int ret = -1; +- +- /* Silently ignoring this error, exactly like the current +- * implementation */ +- if (!mux_proc) +- return 0; +- +- if (event == RPC_CLNT_DESTROY) { +- /*RPC_CLNT_DESTROY will only called after mux_proc detached from the +- * list. So it is safe to call without lock. Processing +- * RPC_CLNT_DESTROY under a lock will lead to deadlock. +- */ +- if (mux_proc->data) { +- glusterd_volinfo_unref(mux_proc->data); +- mux_proc->data = NULL; +- } +- GF_FREE(mux_proc); +- ret = 0; +- } else { +- pthread_mutex_lock(&conf->attach_lock); +- { +- ret = mux_proc->notify(mux_proc, event); +- } +- pthread_mutex_unlock(&conf->attach_lock); +- } +- return ret; +-} +- +-int +-glusterd_muxsvc_conn_common_notify(struct rpc_clnt *rpc, void *mydata, +- rpc_clnt_event_t event, void *data) +-{ +- return glusterd_big_locked_notify(rpc, mydata, event, data, +- __glusterd_muxsvc_conn_common_notify); +-} +diff --git a/xlators/mgmt/glusterd/src/glusterd-conn-mgmt.h b/xlators/mgmt/glusterd/src/glusterd-conn-mgmt.h +index d1c4607..602c0ba 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-conn-mgmt.h ++++ b/xlators/mgmt/glusterd/src/glusterd-conn-mgmt.h +@@ -43,11 +43,9 @@ glusterd_conn_disconnect(glusterd_conn_t *conn); + int + glusterd_conn_common_notify(struct rpc_clnt *rpc, void *mydata, + rpc_clnt_event_t event, void *data); +-int +-glusterd_muxsvc_conn_common_notify(struct rpc_clnt *rpc, void *mydata, +- rpc_clnt_event_t event, void *data); + + int32_t + glusterd_conn_build_socket_filepath(char *rundir, uuid_t uuid, char *socketpath, + int len); ++ + #endif +diff --git a/xlators/mgmt/glusterd/src/glusterd-gfproxyd-svc.c b/xlators/mgmt/glusterd/src/glusterd-gfproxyd-svc.c +index b01fd4d..f9c8617 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-gfproxyd-svc.c ++++ b/xlators/mgmt/glusterd/src/glusterd-gfproxyd-svc.c +@@ -370,7 +370,6 @@ int + glusterd_gfproxydsvc_restart() + { + glusterd_volinfo_t *volinfo = NULL; +- glusterd_volinfo_t *tmp = NULL; + int ret = -1; + xlator_t *this = THIS; + glusterd_conf_t *conf = NULL; +@@ -381,7 +380,7 @@ glusterd_gfproxydsvc_restart() + conf = this->private; + GF_VALIDATE_OR_GOTO(this->name, conf, out); + +- cds_list_for_each_entry_safe(volinfo, tmp, &conf->volumes, vol_list) ++ cds_list_for_each_entry(volinfo, &conf->volumes, vol_list) + { + /* Start per volume gfproxyd svc */ + if (volinfo->status == GLUSTERD_STATUS_STARTED) { +diff --git a/xlators/mgmt/glusterd/src/glusterd-handler.c b/xlators/mgmt/glusterd/src/glusterd-handler.c +index ac788a0..cb2666b 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-handler.c ++++ b/xlators/mgmt/glusterd/src/glusterd-handler.c +@@ -5940,11 +5940,6 @@ glusterd_get_state(rpcsvc_request_t *req, dict_t *dict) + + GF_FREE(rebal_data); + +- fprintf(fp, "Volume%d.shd_svc.online_status: %s\n", count, +- volinfo->shd.svc.online ? "Online" : "Offline"); +- fprintf(fp, "Volume%d.shd_svc.inited: %s\n", count, +- volinfo->shd.svc.inited ? "True" : "False"); +- + if (volinfo->type == GF_CLUSTER_TYPE_TIER) { + ret = glusterd_volume_get_hot_tier_type_str(volinfo, + &hot_tier_type_str); +@@ -6014,6 +6009,12 @@ glusterd_get_state(rpcsvc_request_t *req, dict_t *dict) + + fprintf(fp, "\n[Services]\n"); + ++ if (priv->shd_svc.inited) { ++ fprintf(fp, "svc%d.name: %s\n", ++count, priv->shd_svc.name); ++ fprintf(fp, "svc%d.online_status: %s\n\n", count, ++ priv->shd_svc.online ? "Online" : "Offline"); ++ } ++ + if (priv->nfs_svc.inited) { + fprintf(fp, "svc%d.name: %s\n", ++count, priv->nfs_svc.name); + fprintf(fp, "svc%d.online_status: %s\n\n", count, +diff --git a/xlators/mgmt/glusterd/src/glusterd-handshake.c b/xlators/mgmt/glusterd/src/glusterd-handshake.c +index 1ba58c3..5599a63 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-handshake.c ++++ b/xlators/mgmt/glusterd/src/glusterd-handshake.c +@@ -30,7 +30,6 @@ + #include "rpcsvc.h" + #include "rpc-common-xdr.h" + #include "glusterd-gfproxyd-svc-helper.h" +-#include "glusterd-shd-svc-helper.h" + + extern struct rpc_clnt_program gd_peer_prog; + extern struct rpc_clnt_program gd_mgmt_prog; +@@ -329,26 +328,6 @@ build_volfile_path(char *volume_id, char *path, size_t path_len, + goto out; + } + +- volid_ptr = strstr(volume_id, "shd/"); +- if (volid_ptr) { +- volid_ptr = strchr(volid_ptr, '/'); +- if (!volid_ptr) { +- ret = -1; +- goto out; +- } +- volid_ptr++; +- +- ret = glusterd_volinfo_find(volid_ptr, &volinfo); +- if (ret == -1) { +- gf_log(this->name, GF_LOG_ERROR, "Couldn't find volinfo"); +- goto out; +- } +- +- glusterd_svc_build_shd_volfile_path(volinfo, path, path_len); +- ret = 0; +- goto out; +- } +- + volid_ptr = strstr(volume_id, "/snaps/"); + if (volid_ptr) { + ret = get_snap_volname_and_volinfo(volid_ptr, &volname, &volinfo); +diff --git a/xlators/mgmt/glusterd/src/glusterd-mem-types.h b/xlators/mgmt/glusterd/src/glusterd-mem-types.h +index 17052ce..7a784db 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-mem-types.h ++++ b/xlators/mgmt/glusterd/src/glusterd-mem-types.h +@@ -51,7 +51,6 @@ typedef enum gf_gld_mem_types_ { + gf_gld_mt_missed_snapinfo_t, + gf_gld_mt_snap_create_args_t, + gf_gld_mt_glusterd_brick_proc_t, +- gf_gld_mt_glusterd_svc_proc_t, + gf_gld_mt_end, + } gf_gld_mem_types_t; + #endif +diff --git a/xlators/mgmt/glusterd/src/glusterd-messages.h b/xlators/mgmt/glusterd/src/glusterd-messages.h +index 424e15f..c7b3ca8 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-messages.h ++++ b/xlators/mgmt/glusterd/src/glusterd-messages.h +@@ -298,8 +298,6 @@ GLFS_MSGID( + GD_MSG_LOCALTIME_LOGGING_ENABLE, GD_MSG_LOCALTIME_LOGGING_DISABLE, + GD_MSG_PORTS_EXHAUSTED, GD_MSG_CHANGELOG_GET_FAIL, + GD_MSG_MANAGER_FUNCTION_FAILED, GD_MSG_NFS_GANESHA_DISABLED, +- GD_MSG_GANESHA_NOT_RUNNING, GD_MSG_DAEMON_LOG_LEVEL_VOL_OPT_VALIDATE_FAIL, +- GD_MSG_SHD_START_FAIL, GD_MSG_SHD_OBJ_GET_FAIL, GD_MSG_SVC_ATTACH_FAIL, +- GD_MSG_ATTACH_INFO, GD_MSG_DETACH_INFO, GD_MSG_SVC_DETACH_FAIL); ++ GD_MSG_GANESHA_NOT_RUNNING, GD_MSG_DAEMON_LOG_LEVEL_VOL_OPT_VALIDATE_FAIL); + + #endif /* !_GLUSTERD_MESSAGES_H_ */ +diff --git a/xlators/mgmt/glusterd/src/glusterd-op-sm.c b/xlators/mgmt/glusterd/src/glusterd-op-sm.c +index 9ea695e..0d29de2 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-op-sm.c ++++ b/xlators/mgmt/glusterd/src/glusterd-op-sm.c +@@ -44,7 +44,6 @@ + #include "glusterd-snapshot-utils.h" + #include "glusterd-svc-mgmt.h" + #include "glusterd-svc-helper.h" +-#include "glusterd-shd-svc-helper.h" + #include "glusterd-shd-svc.h" + #include "glusterd-nfs-svc.h" + #include "glusterd-quotad-svc.h" +@@ -2225,11 +2224,6 @@ glusterd_options_reset(glusterd_volinfo_t *volinfo, char *key, + if (ret) + goto out; + +- svc = &(volinfo->shd.svc); +- ret = svc->reconfigure(volinfo); +- if (ret) +- goto out; +- + ret = glusterd_create_volfiles_and_notify_services(volinfo); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_VOLFILE_CREATE_FAIL, +@@ -2244,7 +2238,7 @@ glusterd_options_reset(glusterd_volinfo_t *volinfo, char *key, + goto out; + + if (GLUSTERD_STATUS_STARTED == volinfo->status) { +- ret = glusterd_svcs_reconfigure(volinfo); ++ ret = glusterd_svcs_reconfigure(); + if (ret) + goto out; + } +@@ -2700,11 +2694,6 @@ glusterd_op_set_all_volume_options(xlator_t *this, dict_t *dict, + if (ret) + goto out; + +- svc = &(volinfo->shd.svc); +- ret = svc->reconfigure(volinfo); +- if (ret) +- goto out; +- + ret = glusterd_create_volfiles_and_notify_services(volinfo); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, +@@ -2718,7 +2707,7 @@ glusterd_op_set_all_volume_options(xlator_t *this, dict_t *dict, + } + } + if (svcs_reconfigure) { +- ret = glusterd_svcs_reconfigure(NULL); ++ ret = glusterd_svcs_reconfigure(); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_SVC_RESTART_FAIL, + "Unable to restart " +@@ -3103,11 +3092,6 @@ glusterd_op_set_volume(dict_t *dict, char **errstr) + if (ret) + goto out; + +- svc = &(volinfo->shd.svc); +- ret = svc->reconfigure(volinfo); +- if (ret) +- goto out; +- + ret = glusterd_create_volfiles_and_notify_services(volinfo); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_VOLFILE_CREATE_FAIL, +@@ -3123,7 +3107,7 @@ glusterd_op_set_volume(dict_t *dict, char **errstr) + goto out; + + if (GLUSTERD_STATUS_STARTED == volinfo->status) { +- ret = glusterd_svcs_reconfigure(volinfo); ++ ret = glusterd_svcs_reconfigure(); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_SVC_RESTART_FAIL, + "Unable to restart services"); +@@ -3156,11 +3140,6 @@ glusterd_op_set_volume(dict_t *dict, char **errstr) + if (ret) + goto out; + +- svc = &(volinfo->shd.svc); +- ret = svc->reconfigure(volinfo); +- if (ret) +- goto out; +- + ret = glusterd_create_volfiles_and_notify_services(volinfo); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_VOLFILE_CREATE_FAIL, +@@ -3176,7 +3155,7 @@ glusterd_op_set_volume(dict_t *dict, char **errstr) + goto out; + + if (GLUSTERD_STATUS_STARTED == volinfo->status) { +- ret = glusterd_svcs_reconfigure(volinfo); ++ ret = glusterd_svcs_reconfigure(); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_SVC_RESTART_FAIL, + "Unable to restart services"); +@@ -3383,7 +3362,7 @@ glusterd_op_stats_volume(dict_t *dict, char **op_errstr, dict_t *rsp_dict) + goto out; + + if (GLUSTERD_STATUS_STARTED == volinfo->status) { +- ret = glusterd_svcs_reconfigure(volinfo); ++ ret = glusterd_svcs_reconfigure(); + if (ret) + goto out; + } +@@ -3666,6 +3645,14 @@ glusterd_op_status_volume(dict_t *dict, char **op_errstr, dict_t *rsp_dict) + other_count++; + node_count++; + ++ } else if ((cmd & GF_CLI_STATUS_SHD) != 0) { ++ ret = glusterd_add_node_to_dict(priv->shd_svc.name, rsp_dict, 0, ++ vol_opts); ++ if (ret) ++ goto out; ++ other_count++; ++ node_count++; ++ + } else if ((cmd & GF_CLI_STATUS_QUOTAD) != 0) { + ret = glusterd_add_node_to_dict(priv->quotad_svc.name, rsp_dict, 0, + vol_opts); +@@ -3699,12 +3686,6 @@ glusterd_op_status_volume(dict_t *dict, char **op_errstr, dict_t *rsp_dict) + goto out; + other_count++; + node_count++; +- } else if ((cmd & GF_CLI_STATUS_SHD) != 0) { +- ret = glusterd_add_shd_to_dict(volinfo, rsp_dict, other_index); +- if (ret) +- goto out; +- other_count++; +- node_count++; + } else if ((cmd & GF_CLI_STATUS_BRICK) != 0) { + ret = dict_get_strn(dict, "brick", SLEN("brick"), &brick); + if (ret) +@@ -3767,19 +3748,6 @@ glusterd_op_status_volume(dict_t *dict, char **op_errstr, dict_t *rsp_dict) + node_count++; + } + +- if (glusterd_is_shd_compatible_volume(volinfo)) { +- shd_enabled = gd_is_self_heal_enabled(volinfo, vol_opts); +- if (shd_enabled) { +- ret = glusterd_add_shd_to_dict(volinfo, rsp_dict, +- other_index); +- if (ret) +- goto out; +- other_count++; +- other_index++; +- node_count++; +- } +- } +- + nfs_disabled = dict_get_str_boolean(vol_opts, NFS_DISABLE_MAP_KEY, + _gf_false); + if (!nfs_disabled) { +@@ -3792,6 +3760,18 @@ glusterd_op_status_volume(dict_t *dict, char **op_errstr, dict_t *rsp_dict) + node_count++; + } + ++ if (glusterd_is_shd_compatible_volume(volinfo)) ++ shd_enabled = gd_is_self_heal_enabled(volinfo, vol_opts); ++ if (shd_enabled) { ++ ret = glusterd_add_node_to_dict(priv->shd_svc.name, rsp_dict, ++ other_index, vol_opts); ++ if (ret) ++ goto out; ++ other_count++; ++ node_count++; ++ other_index++; ++ } ++ + if (glusterd_is_volume_quota_enabled(volinfo)) { + ret = glusterd_add_node_to_dict(priv->quotad_svc.name, rsp_dict, + other_index, vol_opts); +@@ -6904,18 +6884,16 @@ glusterd_shd_select_brick_xlator(dict_t *dict, gf_xl_afr_op_t heal_op, + int ret = -1; + glusterd_conf_t *priv = NULL; + xlator_t *this = NULL; +- glusterd_svc_t *svc = NULL; + + this = THIS; + GF_ASSERT(this); + priv = this->private; + GF_ASSERT(priv); +- svc = &(volinfo->shd.svc); + + switch (heal_op) { + case GF_SHD_OP_INDEX_SUMMARY: + case GF_SHD_OP_STATISTICS_HEAL_COUNT: +- if (!svc->online) { ++ if (!priv->shd_svc.online) { + if (!rsp_dict) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_OPCTX_NULL, + "Received " +@@ -6936,7 +6914,7 @@ glusterd_shd_select_brick_xlator(dict_t *dict, gf_xl_afr_op_t heal_op, + break; + + case GF_SHD_OP_STATISTICS_HEAL_COUNT_PER_REPLICA: +- if (!svc->online) { ++ if (!priv->shd_svc.online) { + if (!rsp_dict) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_OPCTX_NULL, + "Received " +@@ -7071,7 +7049,7 @@ glusterd_bricks_select_heal_volume(dict_t *dict, char **op_errstr, + ret = -1; + goto out; + } else { +- pending_node->node = &(volinfo->shd.svc); ++ pending_node->node = &(priv->shd_svc); + pending_node->type = GD_NODE_SHD; + cds_list_add_tail(&pending_node->list, selected); + pending_node = NULL; +@@ -7205,7 +7183,6 @@ glusterd_bricks_select_status_volume(dict_t *dict, char **op_errstr, + glusterd_pending_node_t *pending_node = NULL; + xlator_t *this = NULL; + glusterd_conf_t *priv = NULL; +- glusterd_svc_t *svc = NULL; + + GF_ASSERT(dict); + +@@ -7301,8 +7278,7 @@ glusterd_bricks_select_status_volume(dict_t *dict, char **op_errstr, + + ret = 0; + } else if ((cmd & GF_CLI_STATUS_SHD) != 0) { +- svc = &(volinfo->shd.svc); +- if (!svc->online) { ++ if (!priv->shd_svc.online) { + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_SELF_HEALD_DISABLED, + "Self-heal daemon is not running"); +@@ -7314,7 +7290,7 @@ glusterd_bricks_select_status_volume(dict_t *dict, char **op_errstr, + ret = -1; + goto out; + } +- pending_node->node = svc; ++ pending_node->node = &(priv->shd_svc); + pending_node->type = GD_NODE_SHD; + pending_node->index = 0; + cds_list_add_tail(&pending_node->list, selected); +diff --git a/xlators/mgmt/glusterd/src/glusterd-shd-svc-helper.c b/xlators/mgmt/glusterd/src/glusterd-shd-svc-helper.c +deleted file mode 100644 +index 9196758..0000000 +--- a/xlators/mgmt/glusterd/src/glusterd-shd-svc-helper.c ++++ /dev/null +@@ -1,140 +0,0 @@ +-/* +- Copyright (c) 2016 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. +-*/ +- +-#include "glusterd.h" +-#include "glusterd-utils.h" +-#include "glusterd-shd-svc-helper.h" +-#include "glusterd-messages.h" +-#include "glusterd-volgen.h" +- +-void +-glusterd_svc_build_shd_socket_filepath(glusterd_volinfo_t *volinfo, char *path, +- int path_len) +-{ +- char sockfilepath[PATH_MAX] = { +- 0, +- }; +- char rundir[PATH_MAX] = { +- 0, +- }; +- int32_t len = 0; +- glusterd_conf_t *priv = THIS->private; +- +- if (!priv) +- return; +- +- GLUSTERD_GET_SHD_RUNDIR(rundir, volinfo, priv); +- len = snprintf(sockfilepath, sizeof(sockfilepath), "%s/run-%s", rundir, +- uuid_utoa(MY_UUID)); +- if ((len < 0) || (len >= sizeof(sockfilepath))) { +- sockfilepath[0] = 0; +- } +- +- glusterd_set_socket_filepath(sockfilepath, path, path_len); +-} +- +-void +-glusterd_svc_build_shd_pidfile(glusterd_volinfo_t *volinfo, char *path, +- int path_len) +-{ +- char rundir[PATH_MAX] = { +- 0, +- }; +- glusterd_conf_t *priv = THIS->private; +- +- if (!priv) +- return; +- +- GLUSTERD_GET_SHD_RUNDIR(rundir, volinfo, priv); +- +- snprintf(path, path_len, "%s/%s-shd.pid", rundir, volinfo->volname); +-} +- +-void +-glusterd_svc_build_shd_volfile_path(glusterd_volinfo_t *volinfo, char *path, +- int path_len) +-{ +- char workdir[PATH_MAX] = { +- 0, +- }; +- glusterd_conf_t *priv = THIS->private; +- +- if (!priv) +- return; +- +- GLUSTERD_GET_VOLUME_DIR(workdir, volinfo, priv); +- +- snprintf(path, path_len, "%s/%s-shd.vol", workdir, volinfo->volname); +-} +- +-void +-glusterd_svc_build_shd_logdir(char *logdir, char *volname, size_t len) +-{ +- snprintf(logdir, len, "%s/shd/%s", DEFAULT_LOG_FILE_DIRECTORY, volname); +-} +- +-void +-glusterd_svc_build_shd_logfile(char *logfile, char *logdir, size_t len) +-{ +- snprintf(logfile, len, "%s/shd.log", logdir); +-} +- +-void +-glusterd_shd_svcproc_cleanup(glusterd_shdsvc_t *shd) +-{ +- glusterd_svc_proc_t *svc_proc = NULL; +- glusterd_svc_t *svc = NULL; +- glusterd_conf_t *conf = NULL; +- gf_boolean_t need_unref = _gf_false; +- rpc_clnt_t *rpc = NULL; +- +- conf = THIS->private; +- if (!conf) +- return; +- +- GF_VALIDATE_OR_GOTO(THIS->name, conf, out); +- GF_VALIDATE_OR_GOTO(THIS->name, shd, out); +- +- svc = &shd->svc; +- shd->attached = _gf_false; +- +- if (svc->conn.rpc) { +- rpc_clnt_unref(svc->conn.rpc); +- svc->conn.rpc = NULL; +- } +- +- pthread_mutex_lock(&conf->attach_lock); +- { +- svc_proc = svc->svc_proc; +- svc->svc_proc = NULL; +- svc->inited = _gf_false; +- cds_list_del_init(&svc->mux_svc); +- glusterd_unlink_file(svc->proc.pidfile); +- +- if (svc_proc && cds_list_empty(&svc_proc->svcs)) { +- cds_list_del_init(&svc_proc->svc_proc_list); +- /* We cannot free svc_proc list from here. Because +- * if there are pending events on the rpc, it will +- * try to access the corresponding svc_proc, so unrefing +- * rpc request and then cleaning up the memory is carried +- * from the notify function upon RPC_CLNT_DESTROY destroy. +- */ +- need_unref = _gf_true; +- rpc = svc_proc->rpc; +- svc_proc->rpc = NULL; +- } +- } +- pthread_mutex_unlock(&conf->attach_lock); +- /*rpc unref has to be performed outside the lock*/ +- if (need_unref && rpc) +- rpc_clnt_unref(rpc); +-out: +- return; +-} +diff --git a/xlators/mgmt/glusterd/src/glusterd-shd-svc-helper.h b/xlators/mgmt/glusterd/src/glusterd-shd-svc-helper.h +deleted file mode 100644 +index c70702c..0000000 +--- a/xlators/mgmt/glusterd/src/glusterd-shd-svc-helper.h ++++ /dev/null +@@ -1,45 +0,0 @@ +-/* +- Copyright (c) 2016 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 _GLUSTERD_SHD_SVC_HELPER_H_ +-#define _GLUSTERD_SHD_SVC_HELPER_H_ +- +-#include "glusterd.h" +-#include "glusterd-svc-mgmt.h" +- +-void +-glusterd_svc_build_shd_socket_filepath(glusterd_volinfo_t *volinfo, char *path, +- int path_len); +- +-void +-glusterd_svc_build_shd_pidfile(glusterd_volinfo_t *volinfo, char *path, +- int path_len); +- +-void +-glusterd_svc_build_shd_volfile_path(glusterd_volinfo_t *volinfo, char *path, +- int path_len); +- +-void +-glusterd_svc_build_shd_logdir(char *logdir, char *volname, size_t len); +- +-void +-glusterd_svc_build_shd_logfile(char *logfile, char *logdir, size_t len); +- +-void +-glusterd_shd_svcproc_cleanup(glusterd_shdsvc_t *shd); +- +-int +-glusterd_recover_shd_attach_failure(glusterd_volinfo_t *volinfo, +- glusterd_svc_t *svc, int flags); +- +-int +-glusterd_shdsvc_create_volfile(glusterd_volinfo_t *volinfo); +- +-#endif +diff --git a/xlators/mgmt/glusterd/src/glusterd-shd-svc.c b/xlators/mgmt/glusterd/src/glusterd-shd-svc.c +index 4789843..f5379b0 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-shd-svc.c ++++ b/xlators/mgmt/glusterd/src/glusterd-shd-svc.c +@@ -13,10 +13,9 @@ + #include "glusterd.h" + #include "glusterd-utils.h" + #include "glusterd-volgen.h" ++#include "glusterd-svc-mgmt.h" + #include "glusterd-shd-svc.h" +-#include "glusterd-shd-svc-helper.h" + #include "glusterd-svc-helper.h" +-#include "glusterd-store.h" + + #define GD_SHD_PROCESS_NAME "--process-name" + char *shd_svc_name = "glustershd"; +@@ -24,145 +23,27 @@ char *shd_svc_name = "glustershd"; + void + glusterd_shdsvc_build(glusterd_svc_t *svc) + { +- int ret = -1; +- ret = snprintf(svc->name, sizeof(svc->name), "%s", shd_svc_name); +- if (ret < 0) +- return; +- +- CDS_INIT_LIST_HEAD(&svc->mux_svc); + svc->manager = glusterd_shdsvc_manager; + svc->start = glusterd_shdsvc_start; +- svc->stop = glusterd_shdsvc_stop; +- svc->reconfigure = glusterd_shdsvc_reconfigure; ++ svc->stop = glusterd_svc_stop; + } + + int +-glusterd_shdsvc_init(void *data, glusterd_conn_t *mux_conn, +- glusterd_svc_proc_t *mux_svc) ++glusterd_shdsvc_init(glusterd_svc_t *svc) + { +- int ret = -1; +- char rundir[PATH_MAX] = { +- 0, +- }; +- char sockpath[PATH_MAX] = { +- 0, +- }; +- char pidfile[PATH_MAX] = { +- 0, +- }; +- char volfile[PATH_MAX] = { +- 0, +- }; +- char logdir[PATH_MAX] = { +- 0, +- }; +- char logfile[PATH_MAX] = { +- 0, +- }; +- char volfileid[256] = {0}; +- glusterd_svc_t *svc = NULL; +- glusterd_volinfo_t *volinfo = NULL; +- glusterd_conf_t *priv = NULL; +- glusterd_muxsvc_conn_notify_t notify = NULL; +- xlator_t *this = NULL; +- char *volfileserver = NULL; +- int32_t len = 0; +- +- this = THIS; +- GF_VALIDATE_OR_GOTO(THIS->name, this, out); +- +- priv = this->private; +- GF_VALIDATE_OR_GOTO(this->name, priv, out); +- +- volinfo = data; +- GF_VALIDATE_OR_GOTO(this->name, data, out); +- GF_VALIDATE_OR_GOTO(this->name, mux_svc, out); +- +- svc = &(volinfo->shd.svc); +- +- ret = snprintf(svc->name, sizeof(svc->name), "%s", shd_svc_name); +- if (ret < 0) +- goto out; +- +- notify = glusterd_muxsvc_common_rpc_notify; +- glusterd_store_perform_node_state_store(volinfo); +- +- GLUSTERD_GET_SHD_RUNDIR(rundir, volinfo, priv); +- glusterd_svc_create_rundir(rundir); +- +- glusterd_svc_build_shd_logdir(logdir, volinfo->volname, sizeof(logdir)); +- glusterd_svc_build_shd_logfile(logfile, logdir, sizeof(logfile)); +- +- /* Initialize the connection mgmt */ +- if (mux_conn && mux_svc->rpc) { +- /* multiplexed svc */ +- svc->conn.frame_timeout = mux_conn->frame_timeout; +- /* This will be unrefed from glusterd_shd_svcproc_cleanup*/ +- svc->conn.rpc = rpc_clnt_ref(mux_svc->rpc); +- ret = snprintf(svc->conn.sockpath, sizeof(svc->conn.sockpath), "%s", +- mux_conn->sockpath); +- } else { +- ret = mkdir_p(logdir, 0755, _gf_true); +- if ((ret == -1) && (EEXIST != errno)) { +- gf_msg(this->name, GF_LOG_ERROR, errno, GD_MSG_CREATE_DIR_FAILED, +- "Unable to create logdir %s", logdir); +- goto out; +- } +- +- glusterd_svc_build_shd_socket_filepath(volinfo, sockpath, +- sizeof(sockpath)); +- ret = glusterd_muxsvc_conn_init(&(svc->conn), mux_svc, sockpath, 600, +- notify); +- if (ret) +- goto out; +- /* This will be unrefed when the last svcs is detached from the list */ +- if (!mux_svc->rpc) +- mux_svc->rpc = rpc_clnt_ref(svc->conn.rpc); +- } +- +- /* Initialize the process mgmt */ +- glusterd_svc_build_shd_pidfile(volinfo, pidfile, sizeof(pidfile)); +- glusterd_svc_build_shd_volfile_path(volinfo, volfile, PATH_MAX); +- len = snprintf(volfileid, sizeof(volfileid), "shd/%s", volinfo->volname); +- if ((len < 0) || (len >= sizeof(volfileid))) { +- ret = -1; +- goto out; +- } +- +- if (dict_get_strn(this->options, "transport.socket.bind-address", +- SLEN("transport.socket.bind-address"), +- &volfileserver) != 0) { +- volfileserver = "localhost"; +- } +- ret = glusterd_proc_init(&(svc->proc), shd_svc_name, pidfile, logdir, +- logfile, volfile, volfileid, volfileserver); +- if (ret) +- goto out; +- +-out: +- gf_msg_debug(this ? this->name : "glusterd", 0, "Returning %d", ret); +- return ret; ++ return glusterd_svc_init(svc, shd_svc_name); + } + +-int +-glusterd_shdsvc_create_volfile(glusterd_volinfo_t *volinfo) ++static int ++glusterd_shdsvc_create_volfile() + { + char filepath[PATH_MAX] = { + 0, + }; +- + int ret = -1; ++ glusterd_conf_t *conf = THIS->private; + dict_t *mod_dict = NULL; + +- glusterd_svc_build_shd_volfile_path(volinfo, filepath, PATH_MAX); +- if (!glusterd_is_shd_compatible_volume(volinfo)) { +- /* If volfile exist, delete it. This case happens when we +- * change from replica/ec to distribute. +- */ +- (void)glusterd_unlink_file(filepath); +- ret = 0; +- goto out; +- } + mod_dict = dict_new(); + if (!mod_dict) + goto out; +@@ -183,7 +64,9 @@ glusterd_shdsvc_create_volfile(glusterd_volinfo_t *volinfo) + if (ret) + goto out; + +- ret = glusterd_shdsvc_generate_volfile(volinfo, filepath, mod_dict); ++ glusterd_svc_build_volfile_path(shd_svc_name, conf->workdir, filepath, ++ sizeof(filepath)); ++ ret = glusterd_create_global_volfile(build_shd_graph, filepath, mod_dict); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_VOLFILE_CREATE_FAIL, + "Failed to create volfile"); +@@ -198,89 +81,26 @@ out: + return ret; + } + +-gf_boolean_t +-glusterd_svcs_shd_compatible_volumes_stopped(glusterd_svc_t *svc) +-{ +- glusterd_svc_proc_t *svc_proc = NULL; +- glusterd_shdsvc_t *shd = NULL; +- glusterd_svc_t *temp_svc = NULL; +- glusterd_volinfo_t *volinfo = NULL; +- gf_boolean_t comp = _gf_false; +- glusterd_conf_t *conf = THIS->private; +- +- GF_VALIDATE_OR_GOTO("glusterd", conf, out); +- GF_VALIDATE_OR_GOTO("glusterd", svc, out); +- pthread_mutex_lock(&conf->attach_lock); +- { +- svc_proc = svc->svc_proc; +- if (!svc_proc) +- goto unlock; +- cds_list_for_each_entry(temp_svc, &svc_proc->svcs, mux_svc) +- { +- /* Get volinfo->shd from svc object */ +- shd = cds_list_entry(svc, glusterd_shdsvc_t, svc); +- if (!shd) { +- gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_SHD_OBJ_GET_FAIL, +- "Failed to get shd object " +- "from shd service"); +- goto unlock; +- } +- +- /* Get volinfo from shd */ +- volinfo = cds_list_entry(shd, glusterd_volinfo_t, shd); +- if (!volinfo) { +- gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_VOLINFO_GET_FAIL, +- "Failed to get volinfo from " +- "from shd"); +- goto unlock; +- } +- if (!glusterd_is_shd_compatible_volume(volinfo)) +- continue; +- if (volinfo->status == GLUSTERD_STATUS_STARTED) +- goto unlock; +- } +- comp = _gf_true; +- } +-unlock: +- pthread_mutex_unlock(&conf->attach_lock); +-out: +- return comp; +-} +- + int + glusterd_shdsvc_manager(glusterd_svc_t *svc, void *data, int flags) + { +- int ret = -1; ++ int ret = 0; + glusterd_volinfo_t *volinfo = NULL; + +- volinfo = data; +- GF_VALIDATE_OR_GOTO("glusterd", svc, out); +- GF_VALIDATE_OR_GOTO("glusterd", volinfo, out); +- +- if (volinfo) +- glusterd_volinfo_ref(volinfo); +- +- ret = glusterd_shdsvc_create_volfile(volinfo); +- if (ret) +- goto out; +- +- if (!glusterd_is_shd_compatible_volume(volinfo)) { +- ret = 0; +- if (svc->inited) { +- /* This means glusterd was running for this volume and now +- * it was converted to a non-shd volume. So just stop the shd +- */ +- ret = svc->stop(svc, SIGTERM); ++ if (!svc->inited) { ++ ret = glusterd_shdsvc_init(svc); ++ if (ret) { ++ gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_FAILED_INIT_SHDSVC, ++ "Failed to init shd " ++ "service"); ++ goto out; ++ } else { ++ svc->inited = _gf_true; ++ gf_msg_debug(THIS->name, 0, "shd service initialized"); + } +- goto out; + } + +- ret = glusterd_shd_svc_mux_init(volinfo, svc); +- if (ret) { +- gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_FAILED_INIT_SHDSVC, +- "Failed to init shd service"); +- goto out; +- } ++ volinfo = data; + + /* If all the volumes are stopped or all shd compatible volumes + * are stopped then stop the service if: +@@ -290,26 +110,31 @@ glusterd_shdsvc_manager(glusterd_svc_t *svc, void *data, int flags) + * - volinfo is NULL or + * - volinfo is present and volume is shd compatible + */ +- if (glusterd_svcs_shd_compatible_volumes_stopped(svc)) { +- /* TODO +- * Take a lock and detach all svc's to stop the process +- * also reset the init flag +- */ +- ret = svc->stop(svc, SIGTERM); +- } else if (volinfo) { +- ret = svc->stop(svc, SIGTERM); +- if (ret) +- goto out; ++ if (glusterd_are_all_volumes_stopped() || ++ glusterd_all_shd_compatible_volumes_stopped()) { ++ if (!(volinfo && !glusterd_is_shd_compatible_volume(volinfo))) { ++ ret = svc->stop(svc, SIGTERM); ++ } ++ } else { ++ if (!(volinfo && !glusterd_is_shd_compatible_volume(volinfo))) { ++ ret = glusterd_shdsvc_create_volfile(); ++ if (ret) ++ goto out; ++ ++ ret = svc->stop(svc, SIGTERM); ++ if (ret) ++ goto out; + +- if (volinfo->status == GLUSTERD_STATUS_STARTED) { + ret = svc->start(svc, flags); + if (ret) + goto out; ++ ++ ret = glusterd_conn_connect(&(svc->conn)); ++ if (ret) ++ goto out; + } + } + out: +- if (volinfo) +- glusterd_volinfo_unref(volinfo); + if (ret) + gf_event(EVENT_SVC_MANAGER_FAILED, "svc_name=%s", svc->name); + gf_msg_debug(THIS->name, 0, "Returning %d", ret); +@@ -318,7 +143,7 @@ out: + } + + int +-glusterd_new_shd_svc_start(glusterd_svc_t *svc, int flags) ++glusterd_shdsvc_start(glusterd_svc_t *svc, int flags) + { + int ret = -1; + char glusterd_uuid_option[PATH_MAX] = {0}; +@@ -363,136 +188,31 @@ glusterd_new_shd_svc_start(glusterd_svc_t *svc, int flags) + goto out; + + ret = glusterd_svc_start(svc, flags, cmdline); +- if (ret) +- goto out; + +- ret = glusterd_conn_connect(&(svc->conn)); + out: + if (cmdline) + dict_unref(cmdline); +- return ret; +-} + +-int +-glusterd_recover_shd_attach_failure(glusterd_volinfo_t *volinfo, +- glusterd_svc_t *svc, int flags) +-{ +- int ret = -1; +- glusterd_svc_proc_t *mux_proc = NULL; +- glusterd_conf_t *conf = NULL; +- +- conf = THIS->private; +- +- if (!conf || !volinfo || !svc) +- return -1; +- glusterd_shd_svcproc_cleanup(&volinfo->shd); +- mux_proc = glusterd_svcprocess_new(); +- if (!mux_proc) { +- return -1; +- } +- ret = glusterd_shdsvc_init(volinfo, NULL, mux_proc); +- if (ret) +- return -1; +- pthread_mutex_lock(&conf->attach_lock); +- { +- cds_list_add_tail(&mux_proc->svc_proc_list, &conf->shd_procs); +- svc->svc_proc = mux_proc; +- cds_list_del_init(&svc->mux_svc); +- cds_list_add_tail(&svc->mux_svc, &mux_proc->svcs); +- } +- pthread_mutex_unlock(&conf->attach_lock); +- +- ret = glusterd_new_shd_svc_start(svc, flags); +- if (!ret) { +- volinfo->shd.attached = _gf_true; +- } +- return ret; +-} +- +-int +-glusterd_shdsvc_start(glusterd_svc_t *svc, int flags) +-{ +- int ret = -1; +- glusterd_shdsvc_t *shd = NULL; +- glusterd_volinfo_t *volinfo = NULL; +- glusterd_conf_t *conf = NULL; +- +- GF_VALIDATE_OR_GOTO("glusterd", svc, out); +- conf = THIS->private; +- GF_VALIDATE_OR_GOTO("glusterd", conf, out); +- +- /* Get volinfo->shd from svc object */ +- shd = cds_list_entry(svc, glusterd_shdsvc_t, svc); +- if (!shd) { +- gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_SHD_OBJ_GET_FAIL, +- "Failed to get shd object " +- "from shd service"); +- return -1; +- } +- +- /* Get volinfo from shd */ +- volinfo = cds_list_entry(shd, glusterd_volinfo_t, shd); +- if (!volinfo) { +- gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_VOLINFO_GET_FAIL, +- "Failed to get volinfo from " +- "from shd"); +- return -1; +- } +- +- if (volinfo->status != GLUSTERD_STATUS_STARTED) +- return -1; +- +- glusterd_volinfo_ref(volinfo); +- if (!svc->inited) { +- ret = glusterd_shd_svc_mux_init(volinfo, svc); +- if (ret) +- goto out; +- } +- +- if (shd->attached) { +- ret = glusterd_attach_svc(svc, volinfo, flags); +- if (ret) { +- gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_VOLINFO_GET_FAIL, +- "Failed to attach shd svc(volume=%s) to pid=%d. Starting" +- "a new process", +- volinfo->volname, glusterd_proc_get_pid(&svc->proc)); +- ret = glusterd_recover_shd_attach_failure(volinfo, svc, flags); +- } +- goto out; +- } +- ret = glusterd_new_shd_svc_start(svc, flags); +- if (!ret) { +- shd->attached = _gf_true; +- } +-out: +- if (volinfo) +- glusterd_volinfo_unref(volinfo); + gf_msg_debug(THIS->name, 0, "Returning %d", ret); + + return ret; + } + + int +-glusterd_shdsvc_reconfigure(glusterd_volinfo_t *volinfo) ++glusterd_shdsvc_reconfigure() + { + int ret = -1; + xlator_t *this = NULL; ++ glusterd_conf_t *priv = NULL; + gf_boolean_t identical = _gf_false; +- dict_t *mod_dict = NULL; +- glusterd_svc_t *svc = NULL; + + this = THIS; + GF_VALIDATE_OR_GOTO("glusterd", this, out); + +- if (!volinfo) { +- /* reconfigure will be called separately*/ +- ret = 0; +- goto out; +- } ++ priv = this->private; ++ GF_VALIDATE_OR_GOTO(this->name, priv, out); + +- glusterd_volinfo_ref(volinfo); +- svc = &(volinfo->shd.svc); +- if (glusterd_svcs_shd_compatible_volumes_stopped(svc)) ++ if (glusterd_all_shd_compatible_volumes_stopped()) + goto manager; + + /* +@@ -500,42 +220,8 @@ glusterd_shdsvc_reconfigure(glusterd_volinfo_t *volinfo) + * and cksum i.e. "character-by-character". If YES, then + * NOTHING has been changed, just return. + */ +- +- if (!glusterd_is_shd_compatible_volume(volinfo)) { +- if (svc->inited) +- goto manager; +- +- /* Nothing to do if not shd compatible */ +- ret = 0; +- goto out; +- } +- 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_int32(mod_dict, "graph-check", 1); +- if (ret) +- goto out; +- +- ret = dict_set_str(mod_dict, "cluster.entry-self-heal", "on"); +- if (ret) +- goto out; +- +- ret = glusterd_volume_svc_check_volfile_identical( +- "glustershd", mod_dict, volinfo, glusterd_shdsvc_generate_volfile, +- &identical); ++ ret = glusterd_svc_check_volfile_identical(priv->shd_svc.name, ++ build_shd_graph, &identical); + if (ret) + goto out; + +@@ -550,9 +236,8 @@ glusterd_shdsvc_reconfigure(glusterd_volinfo_t *volinfo) + * changed, then inform the xlator to reconfigure the options. + */ + identical = _gf_false; /* RESET the FLAG */ +- ret = glusterd_volume_svc_check_topology_identical( +- "glustershd", mod_dict, volinfo, glusterd_shdsvc_generate_volfile, +- &identical); ++ ret = glusterd_svc_check_topology_identical(priv->shd_svc.name, ++ build_shd_graph, &identical); + if (ret) + goto out; + +@@ -560,7 +245,7 @@ glusterd_shdsvc_reconfigure(glusterd_volinfo_t *volinfo) + * options to shd volfile, so that shd will be reconfigured. + */ + if (identical) { +- ret = glusterd_shdsvc_create_volfile(volinfo); ++ ret = glusterd_shdsvc_create_volfile(); + if (ret == 0) { /* Only if above PASSES */ + ret = glusterd_fetchspec_notify(THIS); + } +@@ -568,129 +253,12 @@ glusterd_shdsvc_reconfigure(glusterd_volinfo_t *volinfo) + } + manager: + /* +- * shd volfile's topology has been changed. volfile needs +- * to be RECONFIGURED to ACT on the changed volfile. ++ * shd volfile's topology has been changed. shd server needs ++ * to be RESTARTED to ACT on the changed volfile. + */ +- ret = svc->manager(svc, volinfo, PROC_START_NO_WAIT); ++ ret = priv->shd_svc.manager(&(priv->shd_svc), NULL, PROC_START_NO_WAIT); + + out: +- if (volinfo) +- glusterd_volinfo_unref(volinfo); +- if (mod_dict) +- dict_unref(mod_dict); + gf_msg_debug(this ? this->name : "glusterd", 0, "Returning %d", ret); + return ret; + } +- +-int +-glusterd_shdsvc_restart() +-{ +- glusterd_volinfo_t *volinfo = NULL; +- glusterd_volinfo_t *tmp = NULL; +- int ret = -1; +- xlator_t *this = THIS; +- glusterd_conf_t *conf = NULL; +- glusterd_svc_t *svc = NULL; +- +- GF_VALIDATE_OR_GOTO("glusterd", this, out); +- +- conf = this->private; +- GF_VALIDATE_OR_GOTO(this->name, conf, out); +- +- pthread_mutex_lock(&conf->volume_lock); +- cds_list_for_each_entry_safe(volinfo, tmp, &conf->volumes, vol_list) +- { +- glusterd_volinfo_ref(volinfo); +- pthread_mutex_unlock(&conf->volume_lock); +- /* Start per volume shd svc */ +- if (volinfo->status == GLUSTERD_STATUS_STARTED) { +- svc = &(volinfo->shd.svc); +- ret = svc->manager(svc, volinfo, PROC_START_NO_WAIT); +- if (ret) { +- gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_SHD_START_FAIL, +- "Couldn't start shd for " +- "vol: %s on restart", +- volinfo->volname); +- gf_event(EVENT_SVC_MANAGER_FAILED, "volume=%s;svc_name=%s", +- volinfo->volname, svc->name); +- glusterd_volinfo_unref(volinfo); +- goto out; +- } +- } +- glusterd_volinfo_unref(volinfo); +- pthread_mutex_lock(&conf->volume_lock); +- } +- pthread_mutex_unlock(&conf->volume_lock); +-out: +- return ret; +-} +- +-int +-glusterd_shdsvc_stop(glusterd_svc_t *svc, int sig) +-{ +- int ret = -1; +- glusterd_svc_proc_t *svc_proc = NULL; +- glusterd_shdsvc_t *shd = NULL; +- glusterd_volinfo_t *volinfo = NULL; +- gf_boolean_t empty = _gf_false; +- glusterd_conf_t *conf = NULL; +- int pid = -1; +- +- conf = THIS->private; +- GF_VALIDATE_OR_GOTO("glusterd", svc, out); +- svc_proc = svc->svc_proc; +- GF_VALIDATE_OR_GOTO("glusterd", svc_proc, out); +- GF_VALIDATE_OR_GOTO("glusterd", conf, out); +- +- /* Get volinfo->shd from svc object */ +- shd = cds_list_entry(svc, glusterd_shdsvc_t, svc); +- if (!shd) { +- gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_SHD_OBJ_GET_FAIL, +- "Failed to get shd object " +- "from shd service"); +- return -1; +- } +- +- /* Get volinfo from shd */ +- volinfo = cds_list_entry(shd, glusterd_volinfo_t, shd); +- if (!volinfo) { +- gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_VOLINFO_GET_FAIL, +- "Failed to get volinfo from " +- "from shd"); +- return -1; +- } +- +- glusterd_volinfo_ref(volinfo); +- pthread_mutex_lock(&conf->attach_lock); +- { +- gf_is_service_running(svc->proc.pidfile, &pid); +- cds_list_del_init(&svc->mux_svc); +- empty = cds_list_empty(&svc_proc->svcs); +- } +- pthread_mutex_unlock(&conf->attach_lock); +- if (empty) { +- /* Unref will happen when destroying the connection */ +- glusterd_volinfo_ref(volinfo); +- svc_proc->data = volinfo; +- ret = glusterd_svc_stop(svc, sig); +- } +- if (!empty && pid != -1) { +- ret = glusterd_detach_svc(svc, volinfo, sig); +- if (ret) +- gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_SVC_STOP_FAIL, +- "shd service is failed to detach volume %s from pid %d", +- volinfo->volname, glusterd_proc_get_pid(&svc->proc)); +- else +- gf_msg(THIS->name, GF_LOG_INFO, 0, GD_MSG_SVC_STOP_SUCCESS, +- "Shd service is detached for volume %s from pid %d", +- volinfo->volname, glusterd_proc_get_pid(&svc->proc)); +- } +- svc->online = _gf_false; +- (void)glusterd_unlink_file((char *)svc->proc.pidfile); +- glusterd_shd_svcproc_cleanup(shd); +- ret = 0; +- glusterd_volinfo_unref(volinfo); +-out: +- gf_msg_debug(THIS->name, 0, "Returning %d", ret); +- return ret; +-} +diff --git a/xlators/mgmt/glusterd/src/glusterd-shd-svc.h b/xlators/mgmt/glusterd/src/glusterd-shd-svc.h +index 55b409f..775a9d4 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-shd-svc.h ++++ b/xlators/mgmt/glusterd/src/glusterd-shd-svc.h +@@ -12,20 +12,12 @@ + #define _GLUSTERD_SHD_SVC_H_ + + #include "glusterd-svc-mgmt.h" +-#include "glusterd.h" +- +-typedef struct glusterd_shdsvc_ glusterd_shdsvc_t; +-struct glusterd_shdsvc_ { +- glusterd_svc_t svc; +- gf_boolean_t attached; +-}; + + void + glusterd_shdsvc_build(glusterd_svc_t *svc); + + int +-glusterd_shdsvc_init(void *data, glusterd_conn_t *mux_conn, +- glusterd_svc_proc_t *svc_proc); ++glusterd_shdsvc_init(glusterd_svc_t *svc); + + int + glusterd_shdsvc_manager(glusterd_svc_t *svc, void *data, int flags); +@@ -35,11 +27,4 @@ glusterd_shdsvc_start(glusterd_svc_t *svc, int flags); + + int + glusterd_shdsvc_reconfigure(); +- +-int +-glusterd_shdsvc_restart(); +- +-int +-glusterd_shdsvc_stop(glusterd_svc_t *svc, int sig); +- + #endif +diff --git a/xlators/mgmt/glusterd/src/glusterd-sm.c b/xlators/mgmt/glusterd/src/glusterd-sm.c +index 943b1c6..54a7bd1 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-sm.c ++++ b/xlators/mgmt/glusterd/src/glusterd-sm.c +@@ -748,16 +748,6 @@ glusterd_peer_detach_cleanup(glusterd_conf_t *priv) + } + } + +- if (glusterd_is_shd_compatible_volume(volinfo)) { +- svc = &(volinfo->shd.svc); +- ret = svc->stop(svc, SIGTERM); +- if (ret) { +- gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_SVC_STOP_FAIL, +- "Failed " +- "to stop shd daemon service"); +- } +- } +- + if (glusterd_is_gfproxyd_enabled(volinfo)) { + svc = &(volinfo->gfproxyd.svc); + ret = svc->stop(svc, SIGTERM); +@@ -785,7 +775,7 @@ glusterd_peer_detach_cleanup(glusterd_conf_t *priv) + } + + /*Reconfigure all daemon services upon peer detach*/ +- ret = glusterd_svcs_reconfigure(NULL); ++ ret = glusterd_svcs_reconfigure(); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_SVC_STOP_FAIL, + "Failed to reconfigure all daemon services."); +diff --git a/xlators/mgmt/glusterd/src/glusterd-snapd-svc.c b/xlators/mgmt/glusterd/src/glusterd-snapd-svc.c +index 1da4076..56bab07 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-snapd-svc.c ++++ b/xlators/mgmt/glusterd/src/glusterd-snapd-svc.c +@@ -366,7 +366,6 @@ int + glusterd_snapdsvc_restart() + { + glusterd_volinfo_t *volinfo = NULL; +- glusterd_volinfo_t *tmp = NULL; + int ret = 0; + xlator_t *this = THIS; + glusterd_conf_t *conf = NULL; +@@ -377,7 +376,7 @@ glusterd_snapdsvc_restart() + conf = this->private; + GF_ASSERT(conf); + +- cds_list_for_each_entry_safe(volinfo, tmp, &conf->volumes, vol_list) ++ cds_list_for_each_entry(volinfo, &conf->volumes, vol_list) + { + /* Start per volume snapd svc */ + if (volinfo->status == GLUSTERD_STATUS_STARTED) { +diff --git a/xlators/mgmt/glusterd/src/glusterd-statedump.c b/xlators/mgmt/glusterd/src/glusterd-statedump.c +index 69d4cf4..f5ecde7 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-statedump.c ++++ b/xlators/mgmt/glusterd/src/glusterd-statedump.c +@@ -202,6 +202,9 @@ glusterd_dump_priv(xlator_t *this) + gf_proc_dump_build_key(key, "glusterd", "ping-timeout"); + gf_proc_dump_write(key, "%d", priv->ping_timeout); + ++ gf_proc_dump_build_key(key, "glusterd", "shd.online"); ++ gf_proc_dump_write(key, "%d", priv->shd_svc.online); ++ + gf_proc_dump_build_key(key, "glusterd", "nfs.online"); + gf_proc_dump_write(key, "%d", priv->nfs_svc.online); + +diff --git a/xlators/mgmt/glusterd/src/glusterd-svc-helper.c b/xlators/mgmt/glusterd/src/glusterd-svc-helper.c +index e42703c..ca19a75 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-svc-helper.c ++++ b/xlators/mgmt/glusterd/src/glusterd-svc-helper.c +@@ -7,7 +7,6 @@ + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. + */ +-#include <signal.h> + + #include <glusterfs/globals.h> + #include <glusterfs/run.h> +@@ -21,14 +20,12 @@ + #include "glusterd-bitd-svc.h" + #include "glusterd-tierd-svc.h" + #include "glusterd-tierd-svc-helper.h" +-#include "glusterd-shd-svc-helper.h" + #include "glusterd-scrub-svc.h" + #include "glusterd-svc-helper.h" + #include <glusterfs/syscall.h> +-#include "glusterd-snapshot-utils.h" + + int +-glusterd_svcs_reconfigure(glusterd_volinfo_t *volinfo) ++glusterd_svcs_reconfigure() + { + int ret = 0; + xlator_t *this = THIS; +@@ -46,11 +43,9 @@ glusterd_svcs_reconfigure(glusterd_volinfo_t *volinfo) + goto out; + + svc_name = "self-heald"; +- if (volinfo) { +- ret = glusterd_shdsvc_reconfigure(volinfo); +- if (ret) +- goto out; +- } ++ ret = glusterd_shdsvc_reconfigure(); ++ if (ret) ++ goto out; + + if (conf->op_version == GD_OP_VERSION_MIN) + goto out; +@@ -74,7 +69,7 @@ out: + } + + int +-glusterd_svcs_stop(glusterd_volinfo_t *volinfo) ++glusterd_svcs_stop() + { + int ret = 0; + xlator_t *this = NULL; +@@ -90,15 +85,13 @@ glusterd_svcs_stop(glusterd_volinfo_t *volinfo) + if (ret) + goto out; + +- ret = glusterd_svc_stop(&(priv->quotad_svc), SIGTERM); ++ ret = glusterd_svc_stop(&(priv->shd_svc), SIGTERM); + if (ret) + goto out; + +- if (volinfo) { +- ret = glusterd_svc_stop(&(volinfo->shd.svc), PROC_START_NO_WAIT); +- if (ret) +- goto out; +- } ++ ret = glusterd_svc_stop(&(priv->quotad_svc), SIGTERM); ++ if (ret) ++ goto out; + + ret = glusterd_svc_stop(&(priv->bitd_svc), SIGTERM); + if (ret) +@@ -128,6 +121,12 @@ glusterd_svcs_manager(glusterd_volinfo_t *volinfo) + if (ret) + goto out; + ++ ret = conf->shd_svc.manager(&(conf->shd_svc), volinfo, PROC_START_NO_WAIT); ++ if (ret == -EINVAL) ++ ret = 0; ++ if (ret) ++ goto out; ++ + if (conf->op_version == GD_OP_VERSION_MIN) + goto out; + +@@ -144,15 +143,6 @@ glusterd_svcs_manager(glusterd_volinfo_t *volinfo) + if (ret) + goto out; + +- if (volinfo) { +- ret = volinfo->shd.svc.manager(&(volinfo->shd.svc), volinfo, +- PROC_START_NO_WAIT); +- if (ret == -EINVAL) +- ret = 0; +- if (ret) +- goto out; +- } +- + ret = conf->scrub_svc.manager(&(conf->scrub_svc), NULL, PROC_START_NO_WAIT); + if (ret == -EINVAL) + ret = 0; +@@ -279,678 +269,3 @@ out: + GF_FREE(tmpvol); + return ret; + } +- +-int +-glusterd_volume_svc_check_volfile_identical( +- char *svc_name, dict_t *mode_dict, glusterd_volinfo_t *volinfo, +- glusterd_vol_graph_builder_t builder, gf_boolean_t *identical) +-{ +- char orgvol[PATH_MAX] = { +- 0, +- }; +- char *tmpvol = NULL; +- xlator_t *this = NULL; +- int ret = -1; +- int need_unlink = 0; +- int tmp_fd = -1; +- +- this = THIS; +- +- GF_VALIDATE_OR_GOTO(this->name, this, out); +- GF_VALIDATE_OR_GOTO(this->name, identical, out); +- +- /* This builds volfile for volume level dameons */ +- glusterd_volume_svc_build_volfile_path(svc_name, volinfo, orgvol, +- sizeof(orgvol)); +- +- ret = gf_asprintf(&tmpvol, "/tmp/g%s-XXXXXX", svc_name); +- if (ret < 0) { +- goto out; +- } +- +- /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */ +- tmp_fd = mkstemp(tmpvol); +- if (tmp_fd < 0) { +- gf_msg(this->name, GF_LOG_WARNING, errno, GD_MSG_FILE_OP_FAILED, +- "Unable to create temp file" +- " %s:(%s)", +- tmpvol, strerror(errno)); +- ret = -1; +- goto out; +- } +- +- need_unlink = 1; +- +- ret = builder(volinfo, tmpvol, mode_dict); +- if (ret) +- goto out; +- +- ret = glusterd_check_files_identical(orgvol, tmpvol, identical); +-out: +- if (need_unlink) +- sys_unlink(tmpvol); +- +- if (tmpvol != NULL) +- GF_FREE(tmpvol); +- +- if (tmp_fd >= 0) +- sys_close(tmp_fd); +- +- return ret; +-} +- +-int +-glusterd_volume_svc_check_topology_identical( +- char *svc_name, dict_t *mode_dict, glusterd_volinfo_t *volinfo, +- glusterd_vol_graph_builder_t builder, gf_boolean_t *identical) +-{ +- char orgvol[PATH_MAX] = { +- 0, +- }; +- char *tmpvol = NULL; +- 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; +- +- conf = this->private; +- GF_VALIDATE_OR_GOTO(this->name, conf, out); +- +- /* This builds volfile for volume level dameons */ +- glusterd_volume_svc_build_volfile_path(svc_name, volinfo, orgvol, +- sizeof(orgvol)); +- /* Create the temporary volfile */ +- ret = gf_asprintf(&tmpvol, "/tmp/g%s-XXXXXX", svc_name); +- if (ret < 0) { +- goto out; +- } +- +- /* coverity[secure_temp] mkstemp uses 0600 as the mode and is safe */ +- tmpfd = mkstemp(tmpvol); +- if (tmpfd < 0) { +- gf_msg(this->name, GF_LOG_WARNING, errno, GD_MSG_FILE_OP_FAILED, +- "Unable to create temp file" +- " %s:(%s)", +- tmpvol, strerror(errno)); +- ret = -1; +- goto out; +- } +- +- tmpclean = 1; /* SET the flag to unlink() tmpfile */ +- +- ret = builder(volinfo, tmpvol, mode_dict); +- if (ret) +- goto out; +- +- /* Compare the topology of volfiles */ +- ret = glusterd_check_topology_identical(orgvol, tmpvol, identical); +-out: +- if (tmpfd >= 0) +- sys_close(tmpfd); +- if (tmpclean) +- sys_unlink(tmpvol); +- if (tmpvol != NULL) +- GF_FREE(tmpvol); +- return ret; +-} +- +-void * +-__gf_find_compatible_svc(gd_node_type daemon) +-{ +- glusterd_svc_proc_t *svc_proc = NULL; +- glusterd_svc_proc_t *return_proc = NULL; +- glusterd_svc_t *parent_svc = NULL; +- struct cds_list_head *svc_procs = NULL; +- glusterd_conf_t *conf = NULL; +- int pid = -1; +- +- conf = THIS->private; +- GF_VALIDATE_OR_GOTO("glusterd", conf, out); +- +- if (daemon == GD_NODE_SHD) { +- svc_procs = &conf->shd_procs; +- if (!svc_procs) +- goto out; +- } +- +- cds_list_for_each_entry(svc_proc, svc_procs, svc_proc_list) +- { +- parent_svc = cds_list_entry(svc_proc->svcs.next, glusterd_svc_t, +- mux_svc); +- if (!return_proc) +- return_proc = svc_proc; +- +- /* If there is an already running shd daemons, select it. Otehrwise +- * select the first one. +- */ +- if (parent_svc && gf_is_service_running(parent_svc->proc.pidfile, &pid)) +- return (void *)svc_proc; +- /* +- * Logic to select one process goes here. Currently there is only one +- * shd_proc. So selecting the first one; +- */ +- } +-out: +- return return_proc; +-} +- +-glusterd_svc_proc_t * +-glusterd_svcprocess_new() +-{ +- glusterd_svc_proc_t *new_svcprocess = NULL; +- +- new_svcprocess = GF_CALLOC(1, sizeof(*new_svcprocess), +- gf_gld_mt_glusterd_svc_proc_t); +- +- if (!new_svcprocess) +- return NULL; +- +- CDS_INIT_LIST_HEAD(&new_svcprocess->svc_proc_list); +- CDS_INIT_LIST_HEAD(&new_svcprocess->svcs); +- new_svcprocess->notify = glusterd_muxsvc_common_rpc_notify; +- return new_svcprocess; +-} +- +-int +-glusterd_shd_svc_mux_init(glusterd_volinfo_t *volinfo, glusterd_svc_t *svc) +-{ +- int ret = -1; +- glusterd_svc_proc_t *mux_proc = NULL; +- glusterd_conn_t *mux_conn = NULL; +- glusterd_conf_t *conf = NULL; +- glusterd_svc_t *parent_svc = NULL; +- int pid = -1; +- +- GF_VALIDATE_OR_GOTO("glusterd", svc, out); +- GF_VALIDATE_OR_GOTO("glusterd", volinfo, out); +- conf = THIS->private; +- GF_VALIDATE_OR_GOTO("glusterd", conf, out); +- GF_VALIDATE_OR_GOTO("glusterd", svc, out); +- +- pthread_mutex_lock(&conf->attach_lock); +- { +- if (!svc->inited) { +- if (gf_is_service_running(svc->proc.pidfile, &pid)) { +- /* Just connect is required, but we don't know what happens +- * during the disconnect. So better to reattach. +- */ +- mux_proc = __gf_find_compatible_svc_from_pid(GD_NODE_SHD, pid); +- } +- +- if (!mux_proc) { +- if (pid != -1 && sys_access(svc->proc.pidfile, R_OK) == 0) { +- /* stale pid file, unlink it. */ +- kill(pid, SIGTERM); +- sys_unlink(svc->proc.pidfile); +- } +- mux_proc = __gf_find_compatible_svc(GD_NODE_SHD); +- } +- if (mux_proc) { +- /* Take first entry from the process */ +- parent_svc = cds_list_entry(mux_proc->svcs.next, glusterd_svc_t, +- mux_svc); +- sys_link(parent_svc->proc.pidfile, svc->proc.pidfile); +- mux_conn = &parent_svc->conn; +- if (volinfo) +- volinfo->shd.attached = _gf_true; +- } else { +- mux_proc = glusterd_svcprocess_new(); +- if (!mux_proc) { +- ret = -1; +- goto unlock; +- } +- cds_list_add_tail(&mux_proc->svc_proc_list, &conf->shd_procs); +- } +- svc->svc_proc = mux_proc; +- cds_list_del_init(&svc->mux_svc); +- cds_list_add_tail(&svc->mux_svc, &mux_proc->svcs); +- ret = glusterd_shdsvc_init(volinfo, mux_conn, mux_proc); +- if (ret) { +- pthread_mutex_unlock(&conf->attach_lock); +- gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_FAILED_INIT_SHDSVC, +- "Failed to init shd " +- "service"); +- goto out; +- } +- gf_msg_debug(THIS->name, 0, "shd service initialized"); +- svc->inited = _gf_true; +- } +- ret = 0; +- } +-unlock: +- pthread_mutex_unlock(&conf->attach_lock); +-out: +- return ret; +-} +- +-void * +-__gf_find_compatible_svc_from_pid(gd_node_type daemon, pid_t pid) +-{ +- glusterd_svc_proc_t *svc_proc = NULL; +- struct cds_list_head *svc_procs = NULL; +- glusterd_svc_t *svc = NULL; +- pid_t mux_pid = -1; +- glusterd_conf_t *conf = NULL; +- +- conf = THIS->private; +- if (!conf) +- return NULL; +- +- if (daemon == GD_NODE_SHD) { +- svc_procs = &conf->shd_procs; +- if (!svc_proc) +- return NULL; +- } /* Can be moved to switch when mux is implemented for other daemon; */ +- +- cds_list_for_each_entry(svc_proc, svc_procs, svc_proc_list) +- { +- cds_list_for_each_entry(svc, &svc_proc->svcs, mux_svc) +- { +- if (gf_is_service_running(svc->proc.pidfile, &mux_pid)) { +- if (mux_pid == pid) { +- /*TODO +- * inefficient loop, but at the moment, there is only +- * one shd. +- */ +- return svc_proc; +- } +- } +- } +- } +- return NULL; +-} +- +-static int32_t +-my_callback(struct rpc_req *req, struct iovec *iov, int count, void *v_frame) +-{ +- call_frame_t *frame = v_frame; +- xlator_t *this = NULL; +- glusterd_conf_t *conf = NULL; +- +- GF_VALIDATE_OR_GOTO("glusterd", frame, out); +- this = frame->this; +- GF_VALIDATE_OR_GOTO("glusterd", this, out); +- conf = this->private; +- GF_VALIDATE_OR_GOTO(this->name, conf, out); +- +- GF_ATOMIC_DEC(conf->blockers); +- +- STACK_DESTROY(frame->root); +-out: +- return 0; +-} +- +-static int32_t +-glusterd_svc_attach_cbk(struct rpc_req *req, struct iovec *iov, int count, +- void *v_frame) +-{ +- call_frame_t *frame = v_frame; +- glusterd_volinfo_t *volinfo = NULL; +- glusterd_shdsvc_t *shd = NULL; +- glusterd_svc_t *svc = frame->cookie; +- glusterd_svc_t *parent_svc = NULL; +- glusterd_svc_proc_t *mux_proc = NULL; +- glusterd_conf_t *conf = NULL; +- int *flag = (int *)frame->local; +- xlator_t *this = THIS; +- int pid = -1; +- int ret = -1; +- gf_getspec_rsp rsp = { +- 0, +- }; +- +- GF_VALIDATE_OR_GOTO("glusterd", this, out); +- conf = this->private; +- GF_VALIDATE_OR_GOTO("glusterd", conf, out); +- GF_VALIDATE_OR_GOTO("glusterd", frame, out); +- GF_VALIDATE_OR_GOTO("glusterd", svc, out); +- +- frame->local = NULL; +- frame->cookie = NULL; +- +- if (!strcmp(svc->name, "glustershd")) { +- /* Get volinfo->shd from svc object */ +- shd = cds_list_entry(svc, glusterd_shdsvc_t, svc); +- if (!shd) { +- gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_SHD_OBJ_GET_FAIL, +- "Failed to get shd object " +- "from shd service"); +- goto out; +- } +- +- /* Get volinfo from shd */ +- volinfo = cds_list_entry(shd, glusterd_volinfo_t, shd); +- if (!volinfo) { +- gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_VOLINFO_GET_FAIL, +- "Failed to get volinfo from " +- "from shd"); +- goto out; +- } +- } +- +- if (!iov) { +- gf_msg(frame->this->name, GF_LOG_ERROR, 0, GD_MSG_REQ_DECODE_FAIL, +- "iov is NULL"); +- ret = -1; +- goto out; +- } +- +- ret = xdr_to_generic(*iov, &rsp, (xdrproc_t)xdr_gf_getspec_rsp); +- if (ret < 0) { +- gf_msg(frame->this->name, GF_LOG_ERROR, 0, GD_MSG_REQ_DECODE_FAIL, +- "XDR decoding error"); +- ret = -1; +- goto out; +- } +- +- if (rsp.op_ret == 0) { +- pthread_mutex_lock(&conf->attach_lock); +- { +- if (!strcmp(svc->name, "glustershd")) { +- mux_proc = svc->svc_proc; +- if (mux_proc && +- !gf_is_service_running(svc->proc.pidfile, &pid)) { +- /* +- * When svc's are restarting, there is a chance that the +- * attached svc might not have updated it's pid. Because +- * it was at connection stage. So in that case, we need +- * to retry the pid file copy. +- */ +- parent_svc = cds_list_entry(mux_proc->svcs.next, +- glusterd_svc_t, mux_svc); +- if (parent_svc) +- sys_link(parent_svc->proc.pidfile, svc->proc.pidfile); +- } +- } +- svc->online = _gf_true; +- } +- pthread_mutex_unlock(&conf->attach_lock); +- gf_msg(this->name, GF_LOG_INFO, 0, GD_MSG_SVC_ATTACH_FAIL, +- "svc %s of volume %s attached successfully to pid %d", svc->name, +- volinfo->volname, glusterd_proc_get_pid(&svc->proc)); +- } else { +- gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_SVC_ATTACH_FAIL, +- "svc %s of volume %s failed to " +- "attach to pid %d. Starting a new process", +- svc->name, volinfo->volname, glusterd_proc_get_pid(&svc->proc)); +- if (!strcmp(svc->name, "glustershd")) { +- glusterd_recover_shd_attach_failure(volinfo, svc, *flag); +- } +- } +-out: +- if (flag) { +- GF_FREE(flag); +- } +- GF_ATOMIC_DEC(conf->blockers); +- STACK_DESTROY(frame->root); +- return 0; +-} +- +-extern size_t +-build_volfile_path(char *volume_id, char *path, size_t path_len, +- char *trusted_str); +- +-int +-__glusterd_send_svc_configure_req(glusterd_svc_t *svc, int flags, +- struct rpc_clnt *rpc, char *volfile_id, +- int op) +-{ +- int ret = -1; +- struct iobuf *iobuf = NULL; +- struct iobref *iobref = NULL; +- struct iovec iov = { +- 0, +- }; +- char path[PATH_MAX] = { +- '\0', +- }; +- struct stat stbuf = { +- 0, +- }; +- int32_t spec_fd = -1; +- size_t file_len = -1; +- char *volfile_content = NULL; +- ssize_t req_size = 0; +- call_frame_t *frame = NULL; +- gd1_mgmt_brick_op_req brick_req; +- void *req = &brick_req; +- void *errlbl = &&err; +- struct rpc_clnt_connection *conn; +- xlator_t *this = THIS; +- glusterd_conf_t *conf = THIS->private; +- extern struct rpc_clnt_program gd_brick_prog; +- fop_cbk_fn_t cbkfn = my_callback; +- +- if (!rpc) { +- gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_PARAM_NULL, +- "called with null rpc"); +- return -1; +- } +- +- conn = &rpc->conn; +- if (!conn->connected || conn->disconnected) { +- gf_msg(this->name, GF_LOG_INFO, 0, GD_MSG_CONNECT_RETURNED, +- "not connected yet"); +- return -1; +- } +- +- brick_req.op = op; +- brick_req.name = volfile_id; +- brick_req.input.input_val = NULL; +- brick_req.input.input_len = 0; +- +- frame = create_frame(this, this->ctx->pool); +- if (!frame) { +- goto *errlbl; +- } +- +- if (op == GLUSTERD_SVC_ATTACH) { +- (void)build_volfile_path(volfile_id, path, sizeof(path), NULL); +- +- ret = sys_stat(path, &stbuf); +- if (ret < 0) { +- gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_SVC_ATTACH_FAIL, +- "Unable to stat %s (%s)", path, strerror(errno)); +- ret = -EINVAL; +- goto *errlbl; +- } +- +- file_len = stbuf.st_size; +- volfile_content = GF_MALLOC(file_len + 1, gf_common_mt_char); +- if (!volfile_content) { +- ret = -ENOMEM; +- goto *errlbl; +- } +- spec_fd = open(path, O_RDONLY); +- if (spec_fd < 0) { +- gf_msg(THIS->name, GF_LOG_WARNING, 0, GD_MSG_SVC_ATTACH_FAIL, +- "failed to read volfile %s", path); +- ret = -EIO; +- goto *errlbl; +- } +- ret = sys_read(spec_fd, volfile_content, file_len); +- if (ret == file_len) { +- brick_req.input.input_val = volfile_content; +- brick_req.input.input_len = file_len; +- } else { +- gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_SVC_ATTACH_FAIL, +- "read failed on path %s. File size=%" GF_PRI_SIZET +- "read size=%d", +- path, file_len, ret); +- ret = -EIO; +- goto *errlbl; +- } +- +- frame->cookie = svc; +- frame->local = GF_CALLOC(1, sizeof(int), gf_gld_mt_int); +- *((int *)frame->local) = flags; +- cbkfn = glusterd_svc_attach_cbk; +- } +- +- req_size = xdr_sizeof((xdrproc_t)xdr_gd1_mgmt_brick_op_req, req); +- iobuf = iobuf_get2(rpc->ctx->iobuf_pool, req_size); +- if (!iobuf) { +- goto *errlbl; +- } +- errlbl = &&maybe_free_iobuf; +- +- iov.iov_base = iobuf->ptr; +- iov.iov_len = iobuf_pagesize(iobuf); +- +- iobref = iobref_new(); +- if (!iobref) { +- goto *errlbl; +- } +- errlbl = &&free_iobref; +- +- iobref_add(iobref, iobuf); +- /* +- * Drop our reference to the iobuf. The iobref should already have +- * one after iobref_add, so when we unref that we'll free the iobuf as +- * well. This allows us to pass just the iobref as frame->local. +- */ +- iobuf_unref(iobuf); +- /* Set the pointer to null so we don't free it on a later error. */ +- iobuf = NULL; +- +- /* Create the xdr payload */ +- ret = xdr_serialize_generic(iov, req, (xdrproc_t)xdr_gd1_mgmt_brick_op_req); +- if (ret == -1) { +- goto *errlbl; +- } +- iov.iov_len = ret; +- +- /* Send the msg */ +- GF_ATOMIC_INC(conf->blockers); +- ret = rpc_clnt_submit(rpc, &gd_brick_prog, op, cbkfn, &iov, 1, NULL, 0, +- iobref, frame, NULL, 0, NULL, 0, NULL); +- GF_FREE(volfile_content); +- if (spec_fd >= 0) +- sys_close(spec_fd); +- return ret; +- +-free_iobref: +- iobref_unref(iobref); +-maybe_free_iobuf: +- if (iobuf) { +- iobuf_unref(iobuf); +- } +-err: +- GF_FREE(volfile_content); +- if (spec_fd >= 0) +- sys_close(spec_fd); +- if (frame) +- STACK_DESTROY(frame->root); +- return -1; +-} +- +-int +-glusterd_attach_svc(glusterd_svc_t *svc, glusterd_volinfo_t *volinfo, int flags) +-{ +- glusterd_conf_t *conf = THIS->private; +- int ret = -1; +- int tries; +- rpc_clnt_t *rpc = NULL; +- +- GF_VALIDATE_OR_GOTO("glusterd", conf, out); +- GF_VALIDATE_OR_GOTO("glusterd", svc, out); +- GF_VALIDATE_OR_GOTO("glusterd", volinfo, out); +- +- gf_msg("glusterd", GF_LOG_INFO, 0, GD_MSG_ATTACH_INFO, +- "adding svc %s (volume=%s) to existing " +- "process with pid %d", +- svc->name, volinfo->volname, glusterd_proc_get_pid(&svc->proc)); +- +- rpc = rpc_clnt_ref(svc->conn.rpc); +- for (tries = 15; tries > 0; --tries) { +- if (rpc) { +- pthread_mutex_lock(&conf->attach_lock); +- { +- ret = __glusterd_send_svc_configure_req( +- svc, flags, rpc, svc->proc.volfileid, GLUSTERD_SVC_ATTACH); +- } +- pthread_mutex_unlock(&conf->attach_lock); +- if (!ret) { +- volinfo->shd.attached = _gf_true; +- goto out; +- } +- } +- /* +- * It might not actually be safe to manipulate the lock +- * like this, but if we don't then the connection can +- * never actually complete and retries are useless. +- * Unfortunately, all of the alternatives (e.g. doing +- * all of this in a separate thread) are much more +- * complicated and risky. +- * TBD: see if there's a better way +- */ +- synclock_unlock(&conf->big_lock); +- sleep(1); +- synclock_lock(&conf->big_lock); +- } +- ret = -1; +- gf_msg("glusterd", GF_LOG_WARNING, 0, GD_MSG_SVC_ATTACH_FAIL, +- "attach failed for %s(volume=%s)", svc->name, volinfo->volname); +-out: +- if (rpc) +- rpc_clnt_unref(rpc); +- return ret; +-} +- +-int +-glusterd_detach_svc(glusterd_svc_t *svc, glusterd_volinfo_t *volinfo, int sig) +-{ +- glusterd_conf_t *conf = THIS->private; +- int ret = -1; +- int tries; +- rpc_clnt_t *rpc = NULL; +- +- GF_VALIDATE_OR_GOTO(THIS->name, conf, out); +- GF_VALIDATE_OR_GOTO(THIS->name, svc, out); +- GF_VALIDATE_OR_GOTO(THIS->name, volinfo, out); +- +- gf_msg(THIS->name, GF_LOG_INFO, 0, GD_MSG_DETACH_INFO, +- "removing svc %s (volume=%s) from existing " +- "process with pid %d", +- svc->name, volinfo->volname, glusterd_proc_get_pid(&svc->proc)); +- +- rpc = rpc_clnt_ref(svc->conn.rpc); +- for (tries = 15; tries > 0; --tries) { +- if (rpc) { +- /*For detach there is no flags, and we are not using sig.*/ +- pthread_mutex_lock(&conf->attach_lock); +- { +- ret = __glusterd_send_svc_configure_req(svc, 0, svc->conn.rpc, +- svc->proc.volfileid, +- GLUSTERD_SVC_DETACH); +- } +- pthread_mutex_unlock(&conf->attach_lock); +- if (!ret) { +- goto out; +- } +- } +- /* +- * It might not actually be safe to manipulate the lock +- * like this, but if we don't then the connection can +- * never actually complete and retries are useless. +- * Unfortunately, all of the alternatives (e.g. doing +- * all of this in a separate thread) are much more +- * complicated and risky. +- * TBD: see if there's a better way +- */ +- synclock_unlock(&conf->big_lock); +- sleep(1); +- synclock_lock(&conf->big_lock); +- } +- ret = -1; +- gf_msg("glusterd", GF_LOG_WARNING, 0, GD_MSG_SVC_DETACH_FAIL, +- "detach failed for %s(volume=%s)", svc->name, volinfo->volname); +-out: +- if (rpc) +- rpc_clnt_unref(rpc); +- return ret; +-} +diff --git a/xlators/mgmt/glusterd/src/glusterd-svc-helper.h b/xlators/mgmt/glusterd/src/glusterd-svc-helper.h +index 5def246..cc98e78 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-svc-helper.h ++++ b/xlators/mgmt/glusterd/src/glusterd-svc-helper.h +@@ -16,10 +16,10 @@ + #include "glusterd-volgen.h" + + int +-glusterd_svcs_reconfigure(glusterd_volinfo_t *volinfo); ++glusterd_svcs_reconfigure(); + + int +-glusterd_svcs_stop(glusterd_volinfo_t *vol); ++glusterd_svcs_stop(); + + int + glusterd_svcs_manager(glusterd_volinfo_t *volinfo); +@@ -41,41 +41,5 @@ int + glusterd_svc_check_tier_topology_identical(char *svc_name, + glusterd_volinfo_t *volinfo, + gf_boolean_t *identical); +-int +-glusterd_volume_svc_check_volfile_identical(char *svc_name, dict_t *mode_dict, +- glusterd_volinfo_t *volinfo, +- glusterd_vol_graph_builder_t, +- gf_boolean_t *identical); +-int +-glusterd_volume_svc_check_topology_identical(char *svc_name, dict_t *mode_dict, +- glusterd_volinfo_t *volinfo, +- glusterd_vol_graph_builder_t, +- gf_boolean_t *identical); +-void +-glusterd_volume_svc_build_volfile_path(char *server, glusterd_volinfo_t *vol, +- char *volfile, size_t len); +-void * +-__gf_find_compatible_svc(gd_node_type daemon); +- +-glusterd_svc_proc_t * +-glusterd_svcprocess_new(); +- +-int +-glusterd_shd_svc_mux_init(glusterd_volinfo_t *volinfo, glusterd_svc_t *svc); +- +-void * +-__gf_find_compatible_svc_from_pid(gd_node_type daemon, pid_t pid); +- +-int +-glusterd_attach_svc(glusterd_svc_t *svc, glusterd_volinfo_t *volinfo, +- int flags); +- +-int +-glusterd_detach_svc(glusterd_svc_t *svc, glusterd_volinfo_t *volinfo, int sig); +- +-int +-__glusterd_send_svc_configure_req(glusterd_svc_t *svc, int flag, +- struct rpc_clnt *rpc, char *volfile_id, +- int op); + + #endif +diff --git a/xlators/mgmt/glusterd/src/glusterd-svc-mgmt.c b/xlators/mgmt/glusterd/src/glusterd-svc-mgmt.c +index f32dafc..4cd4cea 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-svc-mgmt.c ++++ b/xlators/mgmt/glusterd/src/glusterd-svc-mgmt.c +@@ -18,7 +18,6 @@ + #include "glusterd-conn-mgmt.h" + #include "glusterd-messages.h" + #include <glusterfs/syscall.h> +-#include "glusterd-shd-svc-helper.h" + + int + glusterd_svc_create_rundir(char *rundir) +@@ -168,75 +167,68 @@ glusterd_svc_start(glusterd_svc_t *svc, int flags, dict_t *cmdline) + GF_ASSERT(this); + + priv = this->private; +- GF_VALIDATE_OR_GOTO("glusterd", priv, out); +- GF_VALIDATE_OR_GOTO("glusterd", svc, out); +- +- pthread_mutex_lock(&priv->attach_lock); +- { +- if (glusterd_proc_is_running(&(svc->proc))) { +- ret = 0; +- goto unlock; +- } ++ GF_ASSERT(priv); + +- ret = sys_access(svc->proc.volfile, F_OK); +- if (ret) { +- gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_VOLFILE_NOT_FOUND, +- "Volfile %s is not present", svc->proc.volfile); +- goto unlock; +- } ++ if (glusterd_proc_is_running(&(svc->proc))) { ++ ret = 0; ++ goto out; ++ } + +- runinit(&runner); ++ ret = sys_access(svc->proc.volfile, F_OK); ++ if (ret) { ++ gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_VOLFILE_NOT_FOUND, ++ "Volfile %s is not present", svc->proc.volfile); ++ goto out; ++ } + +- if (this->ctx->cmd_args.valgrind) { +- len = snprintf(valgrind_logfile, PATH_MAX, "%s/valgrind-%s.log", +- svc->proc.logfile, svc->name); +- if ((len < 0) || (len >= PATH_MAX)) { +- ret = -1; +- goto unlock; +- } ++ runinit(&runner); + +- runner_add_args(&runner, "valgrind", "--leak-check=full", +- "--trace-children=yes", "--track-origins=yes", +- NULL); +- runner_argprintf(&runner, "--log-file=%s", valgrind_logfile); ++ if (this->ctx->cmd_args.valgrind) { ++ len = snprintf(valgrind_logfile, PATH_MAX, "%s/valgrind-%s.log", ++ svc->proc.logfile, svc->name); ++ if ((len < 0) || (len >= PATH_MAX)) { ++ ret = -1; ++ goto out; + } + +- runner_add_args(&runner, SBIN_DIR "/glusterfs", "-s", +- svc->proc.volfileserver, "--volfile-id", +- svc->proc.volfileid, "-p", svc->proc.pidfile, "-l", +- svc->proc.logfile, "-S", svc->conn.sockpath, NULL); ++ runner_add_args(&runner, "valgrind", "--leak-check=full", ++ "--trace-children=yes", "--track-origins=yes", NULL); ++ runner_argprintf(&runner, "--log-file=%s", valgrind_logfile); ++ } + +- if (dict_get_strn(priv->opts, GLUSTERD_LOCALTIME_LOGGING_KEY, +- SLEN(GLUSTERD_LOCALTIME_LOGGING_KEY), +- &localtime_logging) == 0) { +- if (strcmp(localtime_logging, "enable") == 0) +- runner_add_arg(&runner, "--localtime-logging"); +- } +- if (dict_get_strn(priv->opts, GLUSTERD_DAEMON_LOG_LEVEL_KEY, +- SLEN(GLUSTERD_DAEMON_LOG_LEVEL_KEY), +- &log_level) == 0) { +- snprintf(daemon_log_level, 30, "--log-level=%s", log_level); +- runner_add_arg(&runner, daemon_log_level); +- } ++ runner_add_args(&runner, SBIN_DIR "/glusterfs", "-s", ++ svc->proc.volfileserver, "--volfile-id", ++ svc->proc.volfileid, "-p", svc->proc.pidfile, "-l", ++ svc->proc.logfile, "-S", svc->conn.sockpath, NULL); ++ ++ if (dict_get_strn(priv->opts, GLUSTERD_LOCALTIME_LOGGING_KEY, ++ SLEN(GLUSTERD_LOCALTIME_LOGGING_KEY), ++ &localtime_logging) == 0) { ++ if (strcmp(localtime_logging, "enable") == 0) ++ runner_add_arg(&runner, "--localtime-logging"); ++ } ++ if (dict_get_strn(priv->opts, GLUSTERD_DAEMON_LOG_LEVEL_KEY, ++ SLEN(GLUSTERD_DAEMON_LOG_LEVEL_KEY), &log_level) == 0) { ++ snprintf(daemon_log_level, 30, "--log-level=%s", log_level); ++ runner_add_arg(&runner, daemon_log_level); ++ } + +- if (cmdline) +- dict_foreach(cmdline, svc_add_args, (void *)&runner); ++ if (cmdline) ++ dict_foreach(cmdline, svc_add_args, (void *)&runner); + +- gf_msg(this->name, GF_LOG_INFO, 0, GD_MSG_SVC_START_SUCCESS, +- "Starting %s service", svc->name); ++ gf_msg(this->name, GF_LOG_INFO, 0, GD_MSG_SVC_START_SUCCESS, ++ "Starting %s service", svc->name); + +- if (flags == PROC_START_NO_WAIT) { +- ret = runner_run_nowait(&runner); +- } else { +- synclock_unlock(&priv->big_lock); +- { +- ret = runner_run(&runner); +- } +- synclock_lock(&priv->big_lock); ++ if (flags == PROC_START_NO_WAIT) { ++ ret = runner_run_nowait(&runner); ++ } else { ++ synclock_unlock(&priv->big_lock); ++ { ++ ret = runner_run(&runner); + } ++ synclock_lock(&priv->big_lock); + } +-unlock: +- pthread_mutex_unlock(&priv->attach_lock); ++ + out: + gf_msg_debug(this->name, 0, "Returning %d", ret); + +@@ -289,8 +281,7 @@ glusterd_svc_build_volfile_path(char *server, char *workdir, char *volfile, + + glusterd_svc_build_svcdir(server, workdir, dir, sizeof(dir)); + +- if (!strcmp(server, "quotad")) +- /*quotad has different volfile name*/ ++ if (!strcmp(server, "quotad")) /*quotad has different volfile name*/ + snprintf(volfile, len, "%s/%s.vol", dir, server); + else + snprintf(volfile, len, "%s/%s-server.vol", dir, server); +@@ -375,138 +366,3 @@ glusterd_svc_common_rpc_notify(glusterd_conn_t *conn, rpc_clnt_event_t event) + + return ret; + } +- +-void +-glusterd_volume_svc_build_volfile_path(char *server, glusterd_volinfo_t *vol, +- char *volfile, size_t len) +-{ +- GF_ASSERT(len == PATH_MAX); +- +- if (!strcmp(server, "glustershd")) { +- glusterd_svc_build_shd_volfile_path(vol, volfile, len); +- } +-} +- +-int +-glusterd_muxsvc_common_rpc_notify(glusterd_svc_proc_t *mux_proc, +- rpc_clnt_event_t event) +-{ +- int ret = 0; +- glusterd_svc_t *svc = NULL; +- glusterd_svc_t *tmp = NULL; +- xlator_t *this = NULL; +- gf_boolean_t need_logging = _gf_false; +- +- this = THIS; +- GF_ASSERT(this); +- +- if (!mux_proc) { +- gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_SVC_GET_FAIL, +- "Failed to get the svc proc data"); +- return -1; +- } +- +- /* Currently this function was used for shd svc, if this function is +- * using for another svc, change ths glustershd reference. We can get +- * the svc name from any of the attached svc's +- */ +- switch (event) { +- case RPC_CLNT_CONNECT: +- gf_msg_debug(this->name, 0, +- "glustershd has connected with glusterd."); +- gf_event(EVENT_SVC_CONNECTED, "svc_name=glustershd"); +- cds_list_for_each_entry_safe(svc, tmp, &mux_proc->svcs, mux_svc) +- { +- if (svc->online) +- continue; +- svc->online = _gf_true; +- } +- break; +- +- case RPC_CLNT_DISCONNECT: +- cds_list_for_each_entry_safe(svc, tmp, &mux_proc->svcs, mux_svc) +- { +- if (svc->online) { +- if (!need_logging) +- need_logging = _gf_true; +- svc->online = _gf_false; +- } +- } +- if (need_logging) { +- gf_msg(this->name, GF_LOG_INFO, 0, GD_MSG_NODE_DISCONNECTED, +- "glustershd has disconnected from glusterd."); +- gf_event(EVENT_SVC_DISCONNECTED, "svc_name=glustershd"); +- } +- break; +- +- default: +- gf_msg_trace(this->name, 0, "got some other RPC event %d", event); +- break; +- } +- +- return ret; +-} +- +-int +-glusterd_muxsvc_conn_init(glusterd_conn_t *conn, glusterd_svc_proc_t *mux_proc, +- char *sockpath, int frame_timeout, +- glusterd_muxsvc_conn_notify_t notify) +-{ +- int ret = -1; +- dict_t *options = NULL; +- struct rpc_clnt *rpc = NULL; +- xlator_t *this = THIS; +- glusterd_svc_t *svc = NULL; +- +- options = dict_new(); +- if (!this || !options) +- goto out; +- +- svc = cds_list_entry(conn, glusterd_svc_t, conn); +- if (!svc) { +- gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_SVC_GET_FAIL, +- "Failed to get the service"); +- goto out; +- } +- +- ret = rpc_transport_unix_options_build(options, sockpath, frame_timeout); +- if (ret) +- goto out; +- +- ret = dict_set_int32n(options, "transport.socket.ignore-enoent", +- SLEN("transport.socket.ignore-enoent"), 1); +- if (ret) +- goto out; +- +- /* @options is free'd by rpc_transport when destroyed */ +- rpc = rpc_clnt_new(options, this, (char *)svc->name, 16); +- if (!rpc) { +- ret = -1; +- goto out; +- } +- +- ret = rpc_clnt_register_notify(rpc, glusterd_muxsvc_conn_common_notify, +- mux_proc); +- if (ret) +- goto out; +- +- ret = snprintf(conn->sockpath, sizeof(conn->sockpath), "%s", sockpath); +- if (ret < 0) +- goto out; +- else +- ret = 0; +- +- conn->frame_timeout = frame_timeout; +- conn->rpc = rpc; +- mux_proc->notify = notify; +-out: +- if (options) +- dict_unref(options); +- if (ret) { +- if (rpc) { +- rpc_clnt_unref(rpc); +- rpc = NULL; +- } +- } +- return ret; +-} +diff --git a/xlators/mgmt/glusterd/src/glusterd-svc-mgmt.h b/xlators/mgmt/glusterd/src/glusterd-svc-mgmt.h +index fbc5225..c850bfd 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-svc-mgmt.h ++++ b/xlators/mgmt/glusterd/src/glusterd-svc-mgmt.h +@@ -13,12 +13,9 @@ + + #include "glusterd-proc-mgmt.h" + #include "glusterd-conn-mgmt.h" +-#include "glusterd-rcu.h" + + struct glusterd_svc_; +- + typedef struct glusterd_svc_ glusterd_svc_t; +-typedef struct glusterd_svc_proc_ glusterd_svc_proc_t; + + typedef void (*glusterd_svc_build_t)(glusterd_svc_t *svc); + +@@ -28,17 +25,6 @@ typedef int (*glusterd_svc_start_t)(glusterd_svc_t *svc, int flags); + typedef int (*glusterd_svc_stop_t)(glusterd_svc_t *svc, int sig); + typedef int (*glusterd_svc_reconfigure_t)(void *data); + +-typedef int (*glusterd_muxsvc_conn_notify_t)(glusterd_svc_proc_t *mux_proc, +- rpc_clnt_event_t event); +- +-struct glusterd_svc_proc_ { +- struct cds_list_head svc_proc_list; +- struct cds_list_head svcs; +- glusterd_muxsvc_conn_notify_t notify; +- rpc_clnt_t *rpc; +- void *data; +-}; +- + struct glusterd_svc_ { + char name[NAME_MAX]; + glusterd_conn_t conn; +@@ -49,8 +35,6 @@ struct glusterd_svc_ { + gf_boolean_t online; + gf_boolean_t inited; + glusterd_svc_reconfigure_t reconfigure; +- glusterd_svc_proc_t *svc_proc; +- struct cds_list_head mux_svc; + }; + + int +@@ -85,15 +69,4 @@ glusterd_svc_reconfigure(int (*create_volfile)()); + int + glusterd_svc_common_rpc_notify(glusterd_conn_t *conn, rpc_clnt_event_t event); + +-int +-glusterd_muxsvc_common_rpc_notify(glusterd_svc_proc_t *conn, +- rpc_clnt_event_t event); +- +-int +-glusterd_proc_get_pid(glusterd_proc_t *proc); +- +-int +-glusterd_muxsvc_conn_init(glusterd_conn_t *conn, glusterd_svc_proc_t *mux_proc, +- char *sockpath, int frame_timeout, +- glusterd_muxsvc_conn_notify_t notify); + #endif +diff --git a/xlators/mgmt/glusterd/src/glusterd-tier.c b/xlators/mgmt/glusterd/src/glusterd-tier.c +index 23a9592..4dc0d44 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-tier.c ++++ b/xlators/mgmt/glusterd/src/glusterd-tier.c +@@ -27,7 +27,6 @@ + #include "glusterd-messages.h" + #include "glusterd-mgmt.h" + #include "glusterd-syncop.h" +-#include "glusterd-shd-svc-helper.h" + + #include <sys/wait.h> + #include <dlfcn.h> +@@ -616,7 +615,7 @@ glusterd_op_remove_tier_brick(dict_t *dict, char **op_errstr, dict_t *rsp_dict) + + if (cmd == GF_DEFRAG_CMD_DETACH_START && + volinfo->status == GLUSTERD_STATUS_STARTED) { +- ret = glusterd_svcs_reconfigure(volinfo); ++ ret = glusterd_svcs_reconfigure(); + if (ret) { + gf_msg(this->name, GF_LOG_WARNING, 0, GD_MSG_NFS_RECONF_FAIL, + "Unable to reconfigure NFS-Server"); +diff --git a/xlators/mgmt/glusterd/src/glusterd-tierd-svc.c b/xlators/mgmt/glusterd/src/glusterd-tierd-svc.c +index ab463f1..04ceec5 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-tierd-svc.c ++++ b/xlators/mgmt/glusterd/src/glusterd-tierd-svc.c +@@ -83,6 +83,7 @@ glusterd_tierdsvc_init(void *data) + goto out; + + notify = glusterd_svc_common_rpc_notify; ++ glusterd_store_perform_node_state_store(volinfo); + + volinfo->type = GF_CLUSTER_TYPE_TIER; + +@@ -394,7 +395,6 @@ int + glusterd_tierdsvc_restart() + { + glusterd_volinfo_t *volinfo = NULL; +- glusterd_volinfo_t *tmp = NULL; + int ret = 0; + xlator_t *this = THIS; + glusterd_conf_t *conf = NULL; +@@ -405,7 +405,7 @@ glusterd_tierdsvc_restart() + conf = this->private; + GF_VALIDATE_OR_GOTO(this->name, conf, out); + +- cds_list_for_each_entry_safe(volinfo, tmp, &conf->volumes, vol_list) ++ cds_list_for_each_entry(volinfo, &conf->volumes, vol_list) + { + /* Start per volume tierd svc */ + if (volinfo->status == GLUSTERD_STATUS_STARTED && +diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.c b/xlators/mgmt/glusterd/src/glusterd-utils.c +index 4525ec7..2aa975b 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-utils.c ++++ b/xlators/mgmt/glusterd/src/glusterd-utils.c +@@ -61,7 +61,6 @@ + #include "glusterd-server-quorum.h" + #include <glusterfs/quota-common-utils.h> + #include <glusterfs/common-utils.h> +-#include "glusterd-shd-svc-helper.h" + + #include "xdr-generic.h" + #include <sys/resource.h> +@@ -625,17 +624,13 @@ glusterd_volinfo_t * + glusterd_volinfo_unref(glusterd_volinfo_t *volinfo) + { + int refcnt = -1; +- glusterd_conf_t *conf = THIS->private; + +- pthread_mutex_lock(&conf->volume_lock); ++ pthread_mutex_lock(&volinfo->reflock); + { +- pthread_mutex_lock(&volinfo->reflock); +- { +- refcnt = --volinfo->refcnt; +- } +- pthread_mutex_unlock(&volinfo->reflock); ++ refcnt = --volinfo->refcnt; + } +- pthread_mutex_unlock(&conf->volume_lock); ++ pthread_mutex_unlock(&volinfo->reflock); ++ + if (!refcnt) { + glusterd_volinfo_delete(volinfo); + return NULL; +@@ -707,7 +702,6 @@ glusterd_volinfo_new(glusterd_volinfo_t **volinfo) + glusterd_snapdsvc_build(&new_volinfo->snapd.svc); + glusterd_tierdsvc_build(&new_volinfo->tierd.svc); + glusterd_gfproxydsvc_build(&new_volinfo->gfproxyd.svc); +- glusterd_shdsvc_build(&new_volinfo->shd.svc); + + pthread_mutex_init(&new_volinfo->reflock, NULL); + *volinfo = glusterd_volinfo_ref(new_volinfo); +@@ -1073,11 +1067,11 @@ glusterd_volinfo_delete(glusterd_volinfo_t *volinfo) + gf_store_handle_destroy(volinfo->snapd.handle); + + glusterd_auth_cleanup(volinfo); +- glusterd_shd_svcproc_cleanup(&volinfo->shd); + + pthread_mutex_destroy(&volinfo->reflock); + GF_FREE(volinfo); + ret = 0; ++ + out: + gf_msg_debug(THIS->name, 0, "Returning %d", ret); + return ret; +@@ -3929,7 +3923,6 @@ glusterd_spawn_daemons(void *opaque) + ret = glusterd_snapdsvc_restart(); + ret = glusterd_tierdsvc_restart(); + ret = glusterd_gfproxydsvc_restart(); +- ret = glusterd_shdsvc_restart(); + return ret; + } + +@@ -4880,9 +4873,6 @@ glusterd_delete_stale_volume(glusterd_volinfo_t *stale_volinfo, + svc = &(stale_volinfo->snapd.svc); + (void)svc->manager(svc, stale_volinfo, PROC_START_NO_WAIT); + } +- svc = &(stale_volinfo->shd.svc); +- (void)svc->manager(svc, stale_volinfo, PROC_START_NO_WAIT); +- + (void)glusterd_volinfo_remove(stale_volinfo); + + return 0; +@@ -4997,15 +4987,6 @@ glusterd_import_friend_volume(dict_t *peer_data, int count) + glusterd_volinfo_unref(old_volinfo); + } + +- ret = glusterd_store_volinfo(new_volinfo, GLUSTERD_VOLINFO_VER_AC_NONE); +- if (ret) { +- gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_VOLINFO_STORE_FAIL, +- "Failed to store " +- "volinfo for volume %s", +- new_volinfo->volname); +- goto out; +- } +- + if (glusterd_is_volume_started(new_volinfo)) { + (void)glusterd_start_bricks(new_volinfo); + if (glusterd_is_snapd_enabled(new_volinfo)) { +@@ -5014,10 +4995,15 @@ glusterd_import_friend_volume(dict_t *peer_data, int count) + gf_event(EVENT_SVC_MANAGER_FAILED, "svc_name=%s", svc->name); + } + } +- svc = &(new_volinfo->shd.svc); +- if (svc->manager(svc, new_volinfo, PROC_START_NO_WAIT)) { +- gf_event(EVENT_SVC_MANAGER_FAILED, "svc_name=%s", svc->name); +- } ++ } ++ ++ ret = glusterd_store_volinfo(new_volinfo, GLUSTERD_VOLINFO_VER_AC_NONE); ++ if (ret) { ++ gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_VOLINFO_STORE_FAIL, ++ "Failed to store " ++ "volinfo for volume %s", ++ new_volinfo->volname); ++ goto out; + } + + ret = glusterd_create_volfiles_and_notify_services(new_volinfo); +@@ -5521,7 +5507,9 @@ glusterd_add_node_to_dict(char *server, dict_t *dict, int count, + glusterd_svc_build_pidfile_path(server, priv->rundir, pidfile, + sizeof(pidfile)); + +- if (strcmp(server, priv->nfs_svc.name) == 0) ++ if (strcmp(server, priv->shd_svc.name) == 0) ++ svc = &(priv->shd_svc); ++ else if (strcmp(server, priv->nfs_svc.name) == 0) + svc = &(priv->nfs_svc); + else if (strcmp(server, priv->quotad_svc.name) == 0) + svc = &(priv->quotad_svc); +@@ -5552,6 +5540,9 @@ glusterd_add_node_to_dict(char *server, dict_t *dict, int count, + if (!strcmp(server, priv->nfs_svc.name)) + ret = dict_set_nstrn(dict, key, keylen, "NFS Server", + SLEN("NFS Server")); ++ else if (!strcmp(server, priv->shd_svc.name)) ++ ret = dict_set_nstrn(dict, key, keylen, "Self-heal Daemon", ++ SLEN("Self-heal Daemon")); + else if (!strcmp(server, priv->quotad_svc.name)) + ret = dict_set_nstrn(dict, key, keylen, "Quota Daemon", + SLEN("Quota Daemon")); +@@ -9115,21 +9106,6 @@ glusterd_friend_remove_cleanup_vols(uuid_t uuid) + "to stop snapd daemon service"); + } + } +- +- if (glusterd_is_shd_compatible_volume(volinfo)) { +- /* +- * Sending stop request for all volumes. So it is fine +- * to send stop for mux shd +- */ +- svc = &(volinfo->shd.svc); +- ret = svc->stop(svc, SIGTERM); +- if (ret) { +- gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_SVC_STOP_FAIL, +- "Failed " +- "to stop shd daemon service"); +- } +- } +- + if (volinfo->type == GF_CLUSTER_TYPE_TIER) { + svc = &(volinfo->tierd.svc); + ret = svc->stop(svc, SIGTERM); +@@ -9155,7 +9131,7 @@ glusterd_friend_remove_cleanup_vols(uuid_t uuid) + } + + /* Reconfigure all daemon services upon peer detach */ +- ret = glusterd_svcs_reconfigure(NULL); ++ ret = glusterd_svcs_reconfigure(); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_SVC_STOP_FAIL, + "Failed to reconfigure all daemon services."); +@@ -14746,74 +14722,3 @@ glusterd_is_profile_on(glusterd_volinfo_t *volinfo) + return _gf_true; + return _gf_false; + } +- +-int32_t +-glusterd_add_shd_to_dict(glusterd_volinfo_t *volinfo, dict_t *dict, +- int32_t count) +-{ +- int ret = -1; +- int32_t pid = -1; +- int32_t brick_online = -1; +- char key[64] = {0}; +- int keylen; +- char *pidfile = NULL; +- xlator_t *this = NULL; +- char *uuid_str = NULL; +- +- this = THIS; +- GF_VALIDATE_OR_GOTO(THIS->name, this, out); +- +- GF_VALIDATE_OR_GOTO(this->name, volinfo, out); +- GF_VALIDATE_OR_GOTO(this->name, dict, out); +- +- keylen = snprintf(key, sizeof(key), "brick%d.hostname", count); +- ret = dict_set_nstrn(dict, key, keylen, "Self-heal Daemon", +- SLEN("Self-heal Daemon")); +- if (ret) +- goto out; +- +- keylen = snprintf(key, sizeof(key), "brick%d.path", count); +- uuid_str = gf_strdup(uuid_utoa(MY_UUID)); +- if (!uuid_str) { +- ret = -1; +- goto out; +- } +- ret = dict_set_dynstrn(dict, key, keylen, uuid_str); +- if (ret) +- goto out; +- uuid_str = NULL; +- +- /* shd doesn't have a port. but the cli needs a port key with +- * a zero value to parse. +- * */ +- +- keylen = snprintf(key, sizeof(key), "brick%d.port", count); +- ret = dict_set_int32n(dict, key, keylen, 0); +- if (ret) +- goto out; +- +- pidfile = volinfo->shd.svc.proc.pidfile; +- +- brick_online = gf_is_service_running(pidfile, &pid); +- +- /* If shd is not running, then don't print the pid */ +- if (!brick_online) +- pid = -1; +- keylen = snprintf(key, sizeof(key), "brick%d.pid", count); +- ret = dict_set_int32n(dict, key, keylen, pid); +- if (ret) +- goto out; +- +- keylen = snprintf(key, sizeof(key), "brick%d.status", count); +- ret = dict_set_int32n(dict, key, keylen, brick_online); +- +-out: +- if (uuid_str) +- GF_FREE(uuid_str); +- if (ret) +- gf_msg(this ? this->name : "glusterd", GF_LOG_ERROR, 0, +- GD_MSG_DICT_SET_FAILED, +- "Returning %d. adding values to dict failed", ret); +- +- return ret; +-} +diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.h b/xlators/mgmt/glusterd/src/glusterd-utils.h +index 5c6a453..ead16b2 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-utils.h ++++ b/xlators/mgmt/glusterd/src/glusterd-utils.h +@@ -881,8 +881,4 @@ glusterd_is_profile_on(glusterd_volinfo_t *volinfo); + + char * + search_brick_path_from_proc(pid_t brick_pid, char *brickpath); +- +-int32_t +-glusterd_add_shd_to_dict(glusterd_volinfo_t *volinfo, dict_t *dict, +- int32_t count); + #endif +diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.c b/xlators/mgmt/glusterd/src/glusterd-volgen.c +index 8b58d40..5e0214e 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-volgen.c ++++ b/xlators/mgmt/glusterd/src/glusterd-volgen.c +@@ -36,7 +36,6 @@ + #include "glusterd-svc-mgmt.h" + #include "glusterd-svc-helper.h" + #include "glusterd-snapd-svc-helper.h" +-#include "glusterd-shd-svc-helper.h" + #include "glusterd-gfproxyd-svc-helper.h" + + struct gd_validate_reconf_opts { +@@ -4865,7 +4864,7 @@ volgen_get_shd_key(int type) + static int + volgen_set_shd_key_enable(dict_t *set_dict, const int type) + { +- int ret = 0; ++ int ret = -1; + + switch (type) { + case GF_CLUSTER_TYPE_REPLICATE: +@@ -5156,15 +5155,24 @@ out: + static int + build_shd_volume_graph(xlator_t *this, volgen_graph_t *graph, + glusterd_volinfo_t *volinfo, dict_t *mod_dict, +- dict_t *set_dict, gf_boolean_t graph_check) ++ dict_t *set_dict, gf_boolean_t graph_check, ++ gf_boolean_t *valid_config) + { + volgen_graph_t cgraph = {0}; + int ret = 0; + int clusters = -1; + ++ if (!graph_check && (volinfo->status != GLUSTERD_STATUS_STARTED)) ++ goto out; ++ + if (!glusterd_is_shd_compatible_volume(volinfo)) + goto out; + ++ /* Shd graph is valid only when there is at least one ++ * replica/disperse volume is present ++ */ ++ *valid_config = _gf_true; ++ + ret = prepare_shd_volume_options(volinfo, mod_dict, set_dict); + if (ret) + goto out; +@@ -5194,16 +5202,19 @@ out: + } + + int +-build_shd_graph(glusterd_volinfo_t *volinfo, volgen_graph_t *graph, +- dict_t *mod_dict) ++build_shd_graph(volgen_graph_t *graph, dict_t *mod_dict) + { ++ glusterd_volinfo_t *voliter = NULL; + xlator_t *this = NULL; ++ glusterd_conf_t *priv = NULL; + dict_t *set_dict = NULL; + int ret = 0; ++ gf_boolean_t valid_config = _gf_false; + xlator_t *iostxl = NULL; + gf_boolean_t graph_check = _gf_false; + + this = THIS; ++ priv = this->private; + + set_dict = dict_new(); + if (!set_dict) { +@@ -5213,18 +5224,26 @@ build_shd_graph(glusterd_volinfo_t *volinfo, volgen_graph_t *graph, + + if (mod_dict) + graph_check = dict_get_str_boolean(mod_dict, "graph-check", 0); +- iostxl = volgen_graph_add_as(graph, "debug/io-stats", volinfo->volname); ++ iostxl = volgen_graph_add_as(graph, "debug/io-stats", "glustershd"); + if (!iostxl) { + ret = -1; + goto out; + } + +- ret = build_shd_volume_graph(this, graph, volinfo, mod_dict, set_dict, +- graph_check); ++ cds_list_for_each_entry(voliter, &priv->volumes, vol_list) ++ { ++ ret = build_shd_volume_graph(this, graph, voliter, mod_dict, set_dict, ++ graph_check, &valid_config); ++ ret = dict_reset(set_dict); ++ if (ret) ++ goto out; ++ } + + out: + if (set_dict) + dict_unref(set_dict); ++ if (!valid_config) ++ ret = -EINVAL; + return ret; + } + +@@ -6541,10 +6560,6 @@ glusterd_create_volfiles(glusterd_volinfo_t *volinfo) + if (ret) + gf_log(this->name, GF_LOG_ERROR, "Could not generate gfproxy volfiles"); + +- ret = glusterd_shdsvc_create_volfile(volinfo); +- if (ret) +- gf_log(this->name, GF_LOG_ERROR, "Could not generate shd volfiles"); +- + dict_del_sizen(volinfo->dict, "skip-CLIOT"); + + out: +@@ -6625,7 +6640,7 @@ validate_shdopts(glusterd_volinfo_t *volinfo, dict_t *val_dict, + ret = dict_set_int32_sizen(val_dict, "graph-check", 1); + if (ret) + goto out; +- ret = build_shd_graph(volinfo, &graph, val_dict); ++ ret = build_shd_graph(&graph, val_dict); + if (!ret) + ret = graph_reconf_validateopt(&graph.graph, op_errstr); + +@@ -7002,22 +7017,3 @@ gd_is_boolean_option(char *key) + + return _gf_false; + } +- +-int +-glusterd_shdsvc_generate_volfile(glusterd_volinfo_t *volinfo, char *filename, +- dict_t *mode_dict) +-{ +- int ret = -1; +- volgen_graph_t graph = { +- 0, +- }; +- +- graph.type = GF_SHD; +- ret = build_shd_graph(volinfo, &graph, mode_dict); +- if (!ret) +- ret = volgen_write_volfile(&graph, filename); +- +- volgen_graph_free(&graph); +- +- return ret; +-} +diff --git a/xlators/mgmt/glusterd/src/glusterd-volgen.h b/xlators/mgmt/glusterd/src/glusterd-volgen.h +index 897d8fa..f9fc068 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-volgen.h ++++ b/xlators/mgmt/glusterd/src/glusterd-volgen.h +@@ -66,7 +66,6 @@ typedef enum { + GF_REBALANCED = 1, + GF_QUOTAD, + GF_SNAPD, +- GF_SHD, + } glusterd_graph_type_t; + + struct volgen_graph { +@@ -78,8 +77,6 @@ typedef struct volgen_graph volgen_graph_t; + + typedef int (*glusterd_graph_builder_t)(volgen_graph_t *graph, + dict_t *mod_dict); +-typedef int (*glusterd_vol_graph_builder_t)(glusterd_volinfo_t *, +- char *filename, dict_t *mod_dict); + + #define COMPLETE_OPTION(key, completion, ret) \ + do { \ +@@ -204,8 +201,7 @@ void + glusterd_get_shd_filepath(char *filename); + + int +-build_shd_graph(glusterd_volinfo_t *volinfo, volgen_graph_t *graph, +- dict_t *mod_dict); ++build_shd_graph(volgen_graph_t *graph, dict_t *mod_dict); + + int + build_nfs_graph(volgen_graph_t *graph, dict_t *mod_dict); +@@ -317,9 +313,4 @@ glusterd_generate_gfproxyd_volfile(glusterd_volinfo_t *volinfo); + + int + glusterd_build_gfproxyd_volfile(glusterd_volinfo_t *volinfo, char *filename); +- +-int +-glusterd_shdsvc_generate_volfile(glusterd_volinfo_t *volinfo, char *filename, +- dict_t *mode_dict); +- + #endif +diff --git a/xlators/mgmt/glusterd/src/glusterd-volume-ops.c b/xlators/mgmt/glusterd/src/glusterd-volume-ops.c +index 4c3ad50..1ea8ba6 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-volume-ops.c ++++ b/xlators/mgmt/glusterd/src/glusterd-volume-ops.c +@@ -1940,7 +1940,7 @@ static int + glusterd_handle_heal_cmd(xlator_t *this, glusterd_volinfo_t *volinfo, + dict_t *dict, char **op_errstr) + { +- glusterd_svc_t *svc = NULL; ++ glusterd_conf_t *priv = NULL; + gf_xl_afr_op_t heal_op = GF_SHD_OP_INVALID; + int ret = 0; + char msg[2408] = { +@@ -1950,6 +1950,7 @@ glusterd_handle_heal_cmd(xlator_t *this, glusterd_volinfo_t *volinfo, + "Self-heal daemon is not running. " + "Check self-heal daemon log file."; + ++ priv = this->private; + ret = dict_get_int32n(dict, "heal-op", SLEN("heal-op"), + (int32_t *)&heal_op); + if (ret) { +@@ -1958,7 +1959,6 @@ glusterd_handle_heal_cmd(xlator_t *this, glusterd_volinfo_t *volinfo, + goto out; + } + +- svc = &(volinfo->shd.svc); + switch (heal_op) { + case GF_SHD_OP_INVALID: + case GF_SHD_OP_HEAL_ENABLE: /* This op should be handled in volume-set*/ +@@ -1988,7 +1988,7 @@ glusterd_handle_heal_cmd(xlator_t *this, glusterd_volinfo_t *volinfo, + goto out; + } + +- if (!svc->online) { ++ if (!priv->shd_svc.online) { + ret = -1; + *op_errstr = gf_strdup(offline_msg); + goto out; +@@ -2009,7 +2009,7 @@ glusterd_handle_heal_cmd(xlator_t *this, glusterd_volinfo_t *volinfo, + goto out; + } + +- if (!svc->online) { ++ if (!priv->shd_svc.online) { + ret = -1; + *op_errstr = gf_strdup(offline_msg); + goto out; +diff --git a/xlators/mgmt/glusterd/src/glusterd.c b/xlators/mgmt/glusterd/src/glusterd.c +index c0973cb..d360312 100644 +--- a/xlators/mgmt/glusterd/src/glusterd.c ++++ b/xlators/mgmt/glusterd/src/glusterd.c +@@ -1537,6 +1537,14 @@ init(xlator_t *this) + exit(1); + } + ++ ret = glusterd_init_var_run_dirs(this, rundir, GLUSTERD_GLUSTERSHD_RUN_DIR); ++ if (ret) { ++ gf_msg(this->name, GF_LOG_CRITICAL, 0, GD_MSG_CREATE_DIR_FAILED, ++ "Unable to create " ++ "glustershd running directory"); ++ exit(1); ++ } ++ + ret = glusterd_init_var_run_dirs(this, rundir, GLUSTERD_NFS_RUN_DIR); + if (ret) { + gf_msg(this->name, GF_LOG_CRITICAL, 0, GD_MSG_CREATE_DIR_FAILED, +@@ -1811,9 +1819,6 @@ init(xlator_t *this) + CDS_INIT_LIST_HEAD(&conf->snapshots); + CDS_INIT_LIST_HEAD(&conf->missed_snaps_list); + CDS_INIT_LIST_HEAD(&conf->brick_procs); +- CDS_INIT_LIST_HEAD(&conf->shd_procs); +- pthread_mutex_init(&conf->attach_lock, NULL); +- pthread_mutex_init(&conf->volume_lock, NULL); + + pthread_mutex_init(&conf->mutex, NULL); + conf->rpc = rpc; +@@ -1894,6 +1899,7 @@ init(xlator_t *this) + glusterd_mgmt_v3_lock_timer_init(); + glusterd_txn_opinfo_dict_init(); + ++ glusterd_shdsvc_build(&conf->shd_svc); + glusterd_nfssvc_build(&conf->nfs_svc); + glusterd_quotadsvc_build(&conf->quotad_svc); + glusterd_bitdsvc_build(&conf->bitd_svc); +diff --git a/xlators/mgmt/glusterd/src/glusterd.h b/xlators/mgmt/glusterd/src/glusterd.h +index 0fbc9dd..2be005c 100644 +--- a/xlators/mgmt/glusterd/src/glusterd.h ++++ b/xlators/mgmt/glusterd/src/glusterd.h +@@ -28,7 +28,6 @@ + #include "glusterd-sm.h" + #include "glusterd-snapd-svc.h" + #include "glusterd-tierd-svc.h" +-#include "glusterd-shd-svc.h" + #include "glusterd-bitd-svc.h" + #include "glusterd1-xdr.h" + #include "protocol-common.h" +@@ -173,6 +172,7 @@ typedef struct { + char workdir[VALID_GLUSTERD_PATHMAX]; + char rundir[VALID_GLUSTERD_PATHMAX]; + rpcsvc_t *rpc; ++ glusterd_svc_t shd_svc; + glusterd_svc_t nfs_svc; + glusterd_svc_t bitd_svc; + glusterd_svc_t scrub_svc; +@@ -181,7 +181,6 @@ typedef struct { + struct cds_list_head volumes; + struct cds_list_head snapshots; /*List of snap volumes */ + struct cds_list_head brick_procs; /* List of brick processes */ +- struct cds_list_head shd_procs; /* List of shd processes */ + pthread_mutex_t xprt_lock; + struct list_head xprt_list; + pthread_mutex_t import_volumes; +@@ -222,11 +221,6 @@ typedef struct { + gf_atomic_t blockers; + uint32_t mgmt_v3_lock_timeout; + gf_boolean_t restart_bricks; +- pthread_mutex_t attach_lock; /* Lock can be per process or a common one */ +- pthread_mutex_t volume_lock; /* We release the big_lock from lot of places +- which might lead the modification of volinfo +- list. +- */ + gf_atomic_t thread_count; + } glusterd_conf_t; + +@@ -519,7 +513,6 @@ struct glusterd_volinfo_ { + + glusterd_snapdsvc_t snapd; + glusterd_tierdsvc_t tierd; +- glusterd_shdsvc_t shd; + glusterd_gfproxydsvc_t gfproxyd; + int32_t quota_xattr_version; + gf_boolean_t stage_deleted; /* volume has passed staging +@@ -646,6 +639,7 @@ typedef enum { + #define GLUSTERD_DEFAULT_SNAPS_BRICK_DIR "/gluster/snaps" + #define GLUSTERD_BITD_RUN_DIR "/bitd" + #define GLUSTERD_SCRUB_RUN_DIR "/scrub" ++#define GLUSTERD_GLUSTERSHD_RUN_DIR "/glustershd" + #define GLUSTERD_NFS_RUN_DIR "/nfs" + #define GLUSTERD_QUOTAD_RUN_DIR "/quotad" + #define GLUSTER_SHARED_STORAGE_BRICK_DIR GLUSTERD_DEFAULT_WORKDIR "/ss_brick" +@@ -701,26 +695,6 @@ typedef ssize_t (*gd_serialize_t)(struct iovec outmsg, void *args); + } \ + } while (0) + +-#define GLUSTERD_GET_SHD_RUNDIR(path, volinfo, priv) \ +- do { \ +- int32_t _shd_dir_len; \ +- _shd_dir_len = snprintf(path, PATH_MAX, "%s/shd/%s", priv->rundir, \ +- volinfo->volname); \ +- if ((_shd_dir_len < 0) || (_shd_dir_len >= PATH_MAX)) { \ +- path[0] = 0; \ +- } \ +- } while (0) +- +-#define GLUSTERD_GET_SHD_PID_FILE(path, volinfo, priv) \ +- do { \ +- int32_t _shd_pid_len; \ +- _shd_pid_len = snprintf(path, PATH_MAX, "%s/shd/%s-shd.pid", \ +- priv->rundir, volinfo->volname); \ +- if ((_shd_pid_len < 0) || (_shd_pid_len >= PATH_MAX)) { \ +- path[0] = 0; \ +- } \ +- } while (0) +- + #define GLUSTERD_GET_VOLUME_PID_DIR(path, volinfo, priv) \ + do { \ + int32_t _vol_pid_len; \ +diff --git a/xlators/protocol/client/src/client.c b/xlators/protocol/client/src/client.c +index 532ef35..e156d4d 100644 +--- a/xlators/protocol/client/src/client.c ++++ b/xlators/protocol/client/src/client.c +@@ -46,6 +46,7 @@ client_fini_complete(xlator_t *this) + GF_VALIDATE_OR_GOTO(this->name, this->private, out); + + clnt_conf_t *conf = this->private; ++ + if (!conf->destroy) + return 0; + +@@ -68,11 +69,6 @@ client_notify_dispatch_uniq(xlator_t *this, int32_t event, void *data, ...) + return 0; + + return client_notify_dispatch(this, event, data); +- +- /* Please avoid any code that access xlator object here +- * Because for a child down event, once we do the signal +- * we will start cleanup. +- */ + } + + int +@@ -109,11 +105,6 @@ client_notify_dispatch(xlator_t *this, int32_t event, void *data, ...) + } + pthread_mutex_unlock(&ctx->notify_lock); + +- /* Please avoid any code that access xlator object here +- * Because for a child down event, once we do the signal +- * we will start cleanup. +- */ +- + return ret; + } + +@@ -2287,7 +2278,6 @@ client_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event, + { + xlator_t *this = NULL; + clnt_conf_t *conf = NULL; +- gf_boolean_t is_parent_down = _gf_false; + int ret = 0; + + this = mydata; +@@ -2351,19 +2341,6 @@ client_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event, + if (conf->portmap_err_logged) + conf->disconnect_err_logged = 1; + } +- /* +- * Once we complete the child down notification, +- * There is a chance that the graph might get freed, +- * So it is not safe to access any xlator contens +- * So here we are checking whether the parent is down +- * or not. +- */ +- pthread_mutex_lock(&conf->lock); +- { +- is_parent_down = conf->parent_down; +- } +- pthread_mutex_unlock(&conf->lock); +- + /* If the CHILD_DOWN event goes to parent xlator + multiple times, the logic of parent xlator notify + may get screwed up.. (eg. CHILD_MODIFIED event in +@@ -2371,12 +2348,6 @@ client_rpc_notify(struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event, + to parent are genuine */ + ret = client_notify_dispatch_uniq(this, GF_EVENT_CHILD_DOWN, + NULL); +- if (is_parent_down) { +- /* If parent is down, then there should not be any +- * operation after a child down. +- */ +- goto out; +- } + if (ret) + gf_msg(this->name, GF_LOG_INFO, 0, + PC_MSG_CHILD_DOWN_NOTIFY_FAILED, +-- +1.8.3.1 + |