diff options
Diffstat (limited to 'xlators/mgmt/glusterd/src/glusterd-sm.c')
| -rw-r--r-- | xlators/mgmt/glusterd/src/glusterd-sm.c | 2185 |
1 files changed, 1397 insertions, 788 deletions
diff --git a/xlators/mgmt/glusterd/src/glusterd-sm.c b/xlators/mgmt/glusterd/src/glusterd-sm.c index dcac5ed6a75..bf2d81b644a 100644 --- a/xlators/mgmt/glusterd/src/glusterd-sm.c +++ b/xlators/mgmt/glusterd/src/glusterd-sm.c @@ -1,580 +1,933 @@ /* - Copyright (c) 2006-2010 Gluster, Inc. <http://www.gluster.com> - This file is part of GlusterFS. - - GlusterFS is free software; you can redistribute it and/or modify - it under the terms of the GNU Affero General Public License as published - by the Free Software Foundation; either version 3 of the License, - or (at your option) any later version. - - GlusterFS is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Affero General Public License for more details. - - You should have received a copy of the GNU Affero General Public License - along with this program. If not, see - <http://www.gnu.org/licenses/>. -*/ + Copyright (c) 2006-2012 Red Hat, Inc. <http://www.redhat.com> + This file is part of GlusterFS. + This file is licensed to you under your choice of the GNU Lesser + General Public License, version 3 or any later version (LGPLv3 or + later), or the GNU General Public License, version 2 (GPLv2), in all + cases as published by the Free Software Foundation. +*/ -#ifndef _CONFIG_H -#define _CONFIG_H -#include "config.h" -#endif #include <time.h> #include <sys/uio.h> #include <sys/resource.h> #include <libgen.h> -#include "uuid.h" +#include <glusterfs/compat-uuid.h> #include "fnmatch.h" -#include "xlator.h" +#include <glusterfs/xlator.h> #include "protocol-common.h" #include "glusterd.h" -#include "call-stub.h" -#include "defaults.h" -#include "list.h" -#include "dict.h" -#include "compat.h" -#include "compat-errno.h" -#include "statedump.h" +#include <glusterfs/call-stub.h> +#include <glusterfs/defaults.h> +#include <glusterfs/list.h> +#include "glusterd-messages.h" +#include <glusterfs/dict.h> +#include <glusterfs/compat.h> +#include <glusterfs/compat-errno.h> +#include <glusterfs/statedump.h> #include "glusterd-sm.h" #include "glusterd-op-sm.h" #include "glusterd-utils.h" #include "glusterd-store.h" +#include "glusterd-svc-helper.h" +#include "glusterd-snapshot-utils.h" +#include "glusterd-server-quorum.h" +#include "glusterd-gfproxyd-svc-helper.h" -static struct list_head gd_friend_sm_queue; - -static char *glusterd_friend_sm_state_names[] = { - "Establishing Connection", - "Probe Sent to Peer", - "Probe Received from Peer", - "Peer in Cluster", - "Accepted peer request", - "Sent and Received peer request", - "Peer Rejected", - "Peer detach in progress", - "Probe Received from peer", - "Connected to Peer", - "Peer is connected and Accepted", - "Invalid State" +char local_node_hostname[PATH_MAX] = { + 0, }; -static char *glusterd_friend_sm_event_names[] = { - "GD_FRIEND_EVENT_NONE", - "GD_FRIEND_EVENT_PROBE", - "GD_FRIEND_EVENT_INIT_FRIEND_REQ", - "GD_FRIEND_EVENT_RCVD_ACC", - "GD_FRIEND_EVENT_LOCAL_ACC", - "GD_FRIEND_EVENT_RCVD_RJT", - "GD_FRIEND_EVENT_LOCAL_RJT", - "GD_FRIEND_EVENT_RCVD_FRIEND_REQ", - "GD_FRIEND_EVENT_INIT_REMOVE_FRIEND", - "GD_FRIEND_EVENT_RCVD_REMOVE_FRIEND", - "GD_FRIEND_EVENT_REMOVE_FRIEND", - "GD_FRIEND_EVENT_CONNECTED", - "GD_FRIEND_EVENT_MAX" -}; +static struct cds_list_head gd_friend_sm_queue; + +static char *glusterd_friend_sm_state_names[] = { + "Establishing Connection", + "Probe Sent to Peer", + "Probe Received from Peer", + "Peer in Cluster", + "Accepted peer request", + "Sent and Received peer request", + "Peer Rejected", + "Peer detach in progress", + "Probe Received from peer", + "Connected to Peer", + "Peer is connected and Accepted", + "Invalid State"}; -char* -glusterd_friend_sm_state_name_get (int state) +static char *glusterd_friend_sm_event_names[] = { + "GD_FRIEND_EVENT_NONE", + "GD_FRIEND_EVENT_PROBE", + "GD_FRIEND_EVENT_INIT_FRIEND_REQ", + "GD_FRIEND_EVENT_RCVD_ACC", + "GD_FRIEND_EVENT_LOCAL_ACC", + "GD_FRIEND_EVENT_RCVD_RJT", + "GD_FRIEND_EVENT_LOCAL_RJT", + "GD_FRIEND_EVENT_RCVD_FRIEND_REQ", + "GD_FRIEND_EVENT_INIT_REMOVE_FRIEND", + "GD_FRIEND_EVENT_RCVD_REMOVE_FRIEND", + "GD_FRIEND_EVENT_REMOVE_FRIEND", + "GD_FRIEND_EVENT_CONNECTED", + "GD_FRIEND_EVENT_NEW_NAME", + "GD_FRIEND_EVENT_MAX"}; + +char * +glusterd_friend_sm_state_name_get(int state) { - if (state < 0 || state >= GD_FRIEND_STATE_MAX) - return glusterd_friend_sm_state_names[GD_FRIEND_STATE_MAX]; - return glusterd_friend_sm_state_names[state]; + if (state < 0 || state >= GD_FRIEND_STATE_MAX) + return glusterd_friend_sm_state_names[GD_FRIEND_STATE_MAX]; + return glusterd_friend_sm_state_names[state]; } -char* -glusterd_friend_sm_event_name_get (int event) +char * +glusterd_friend_sm_event_name_get(int event) { - if (event < 0 || event >= GD_FRIEND_EVENT_MAX) - return glusterd_friend_sm_event_names[GD_FRIEND_EVENT_MAX]; - return glusterd_friend_sm_event_names[event]; + if (event < 0 || event >= GD_FRIEND_EVENT_MAX) + return glusterd_friend_sm_event_names[GD_FRIEND_EVENT_MAX]; + return glusterd_friend_sm_event_names[event]; } void -glusterd_destroy_probe_ctx (glusterd_probe_ctx_t *ctx) +glusterd_destroy_probe_ctx(glusterd_probe_ctx_t *ctx) { - if (!ctx) - return; + if (!ctx) + return; - if (ctx->hostname) - GF_FREE (ctx->hostname); - GF_FREE (ctx); + GF_FREE(ctx->hostname); + GF_FREE(ctx); } void -glusterd_destroy_friend_req_ctx (glusterd_friend_req_ctx_t *ctx) +glusterd_destroy_friend_req_ctx(glusterd_friend_req_ctx_t *ctx) { - if (!ctx) - return; - - if (ctx->vols) - dict_unref (ctx->vols); - if (ctx->hostname) - GF_FREE (ctx->hostname); - GF_FREE (ctx); + if (!ctx) + return; + + if (ctx->vols) + dict_unref(ctx->vols); + GF_FREE(ctx->hostname); + GF_FREE(ctx); } void -glusterd_destroy_friend_update_ctx (glusterd_friend_update_ctx_t *ctx) +glusterd_destroy_friend_update_ctx(glusterd_friend_update_ctx_t *ctx) { - if (!ctx) - return; - if (ctx->hostname) - GF_FREE (ctx->hostname); - GF_FREE (ctx); + if (!ctx) + return; + GF_FREE(ctx->hostname); + GF_FREE(ctx); } int -glusterd_broadcast_friend_delete (char *hostname, uuid_t uuid) +glusterd_broadcast_friend_delete(char *hostname, uuid_t uuid) { - int ret = 0; - rpc_clnt_procedure_t *proc = NULL; - xlator_t *this = NULL; - glusterd_friend_update_ctx_t ctx = {{0},}; - glusterd_peerinfo_t *peerinfo = NULL; - glusterd_conf_t *priv = NULL; - dict_t *friends = NULL; - char key[100] = {0,}; - int32_t count = 0; - - this = THIS; - priv = this->private; - - GF_ASSERT (priv); - - ctx.hostname = hostname; - ctx.op = GD_FRIEND_UPDATE_DEL; - - friends = dict_new (); - if (!friends) - goto out; - - snprintf (key, sizeof (key), "op"); - ret = dict_set_int32 (friends, key, ctx.op); - if (ret) - goto out; - - snprintf (key, sizeof (key), "hostname"); - ret = dict_set_str (friends, key, hostname); - if (ret) - goto out; - - ret = dict_set_int32 (friends, "count", count); - if (ret) - goto out; - - list_for_each_entry (peerinfo, &priv->peers, uuid_list) { - if (!peerinfo->connected || !peerinfo->mgmt) - continue; - - ret = dict_set_static_ptr (friends, "peerinfo", peerinfo); - if (ret) { - gf_log ("", GF_LOG_ERROR, "failed to set peerinfo"); - goto out; - } - - proc = &peerinfo->mgmt->proctable[GLUSTERD_MGMT_FRIEND_UPDATE]; - if (proc->fn) { - ret = proc->fn (NULL, this, friends); - } + int ret = 0; + rpc_clnt_procedure_t *proc = NULL; + xlator_t *this = NULL; + glusterd_friend_update_ctx_t ctx = { + {0}, + }; + glusterd_peerinfo_t *peerinfo = NULL; + glusterd_conf_t *priv = NULL; + dict_t *friends = NULL; + char key[64] = { + 0, + }; + int keylen; + int32_t count = 0; + + this = THIS; + priv = this->private; + + GF_ASSERT(priv); + + ctx.hostname = hostname; + ctx.op = GD_FRIEND_UPDATE_DEL; + + friends = dict_new(); + if (!friends) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_CREATE_FAIL, NULL); + goto out; + } + + keylen = snprintf(key, sizeof(key), "op"); + ret = dict_set_int32n(friends, key, keylen, ctx.op); + if (ret) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_SET_FAILED, + "Key=%s", key, NULL); + goto out; + } + + keylen = snprintf(key, sizeof(key), "hostname"); + ret = dict_set_strn(friends, key, keylen, hostname); + if (ret) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_SET_FAILED, + "Key=%s", key, NULL); + goto out; + } + + ret = dict_set_int32n(friends, "count", SLEN("count"), count); + if (ret) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_SET_FAILED, + "Key=%s", key, NULL); + goto out; + } + + RCU_READ_LOCK; + cds_list_for_each_entry_rcu(peerinfo, &priv->peers, uuid_list) + { + if (!peerinfo->connected || !peerinfo->peer) + continue; + + /* Setting a direct reference to peerinfo in the dict is okay as + * it is only going to be used within this read critical section + * (in glusterd_rpc_friend_update) + */ + ret = dict_set_static_ptr(friends, "peerinfo", peerinfo); + if (ret) { + RCU_READ_UNLOCK; + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_DICT_SET_FAILED, + "failed to set peerinfo"); + goto out; } - gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret); + proc = &peerinfo->peer->proctable[GLUSTERD_FRIEND_UPDATE]; + if (proc->fn) { + ret = proc->fn(NULL, this, friends); + } + } + RCU_READ_UNLOCK; out: - if (friends) - dict_unref (friends); + if (friends) + dict_unref(friends); - return ret; + gf_msg_debug("glusterd", 0, "Returning with %d", ret); + return ret; } - static int -glusterd_ac_none (glusterd_friend_sm_event_t *event, void *ctx) +glusterd_ac_none(glusterd_friend_sm_event_t *event, void *ctx) { - int ret = 0; + int ret = 0; - gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret); + gf_msg_debug("glusterd", 0, "Returning with %d", ret); - return ret; + return ret; } static int -glusterd_ac_error (glusterd_friend_sm_event_t *event, void *ctx) +glusterd_ac_error(glusterd_friend_sm_event_t *event, void *ctx) { - int ret = 0; + int ret = 0; - gf_log ("", GF_LOG_ERROR, "Received event %d ", event->event); + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_AC_ERROR, "Received event %d ", + event->event); - return ret; + return ret; } static int -glusterd_ac_reverse_probe_begin (glusterd_friend_sm_event_t *event, void *ctx) +glusterd_ac_reverse_probe_begin(glusterd_friend_sm_event_t *event, void *ctx) { - int ret = 0; - glusterd_peerinfo_t *peerinfo = NULL; - glusterd_friend_sm_event_t *new_event = NULL; - glusterd_probe_ctx_t *new_ev_ctx = NULL; - - GF_ASSERT (event); - GF_ASSERT (ctx); - - peerinfo = event->peerinfo; - ret = glusterd_friend_sm_new_event - (GD_FRIEND_EVENT_PROBE, &new_event); - - if (ret) { - gf_log ("glusterd", GF_LOG_ERROR, "Unable to get new new_event"); - ret = -1; - goto out; - } - - new_ev_ctx = GF_CALLOC (1, sizeof(*new_ev_ctx), gf_gld_mt_probe_ctx_t); - - if (!new_ev_ctx) { - ret = -1; - goto out; - } - - new_ev_ctx->hostname = gf_strdup (peerinfo->hostname); - new_ev_ctx->port = peerinfo->port; - new_ev_ctx->req = NULL; - - new_event->peerinfo = peerinfo; - new_event->ctx = new_ev_ctx; - - ret = glusterd_friend_sm_inject_event (new_event); - - if (ret) { - gf_log ("glusterd", GF_LOG_ERROR, "Unable to inject new_event %d, " - "ret = %d", new_event->event, ret); - } + int ret = 0; + glusterd_peerinfo_t *peerinfo = NULL; + glusterd_friend_sm_event_t *new_event = NULL; + glusterd_probe_ctx_t *new_ev_ctx = NULL; + + GF_ASSERT(event); + GF_ASSERT(ctx); + + new_ev_ctx = GF_CALLOC(1, sizeof(*new_ev_ctx), gf_gld_mt_probe_ctx_t); + + RCU_READ_LOCK; + + peerinfo = glusterd_peerinfo_find(event->peerid, event->peername); + if (!peerinfo) { + RCU_READ_UNLOCK; + ret = -1; + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_PEER_NOT_FOUND, + "Could not find peer %s(%s)", event->peername, + uuid_utoa(event->peerid)); + goto out; + } + + ret = glusterd_friend_sm_new_event(GD_FRIEND_EVENT_PROBE, &new_event); + + if (ret) { + RCU_READ_UNLOCK; + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_EVENT_NEW_GET_FAIL, + "Unable to get new new_event"); + ret = -1; + goto out; + } + + if (!new_ev_ctx) { + RCU_READ_UNLOCK; + ret = -1; + goto out; + } + + new_ev_ctx->hostname = gf_strdup(peerinfo->hostname); + new_ev_ctx->port = peerinfo->port; + new_ev_ctx->req = NULL; + + new_event->peername = gf_strdup(peerinfo->hostname); + gf_uuid_copy(new_event->peerid, peerinfo->uuid); + new_event->ctx = new_ev_ctx; + + ret = glusterd_friend_sm_inject_event(new_event); + + RCU_READ_UNLOCK; + + if (ret) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_EVENT_INJECT_FAIL, + "Unable to inject new_event %d, " + "ret = %d", + new_event->event, ret); + } out: - if (ret) { - if (new_event) - GF_FREE (new_event); - if (new_ev_ctx->hostname) - GF_FREE (new_ev_ctx->hostname); - if (new_ev_ctx) - GF_FREE (new_ev_ctx); - } - gf_log ("", GF_LOG_DEBUG, "returning with %d", ret); - return ret; + if (ret) { + if (new_event) + GF_FREE(new_event->peername); + GF_FREE(new_event); + if (new_ev_ctx) + GF_FREE(new_ev_ctx->hostname); + GF_FREE(new_ev_ctx); + } + gf_msg_debug("glusterd", 0, "returning with %d", ret); + return ret; } static int -glusterd_ac_friend_add (glusterd_friend_sm_event_t *event, void *ctx) +glusterd_ac_friend_add(glusterd_friend_sm_event_t *event, void *ctx) { - int ret = 0; - glusterd_peerinfo_t *peerinfo = NULL; - rpc_clnt_procedure_t *proc = NULL; - call_frame_t *frame = NULL; - glusterd_conf_t *conf = NULL; - xlator_t *this = NULL; - - GF_ASSERT (event); - peerinfo = event->peerinfo; - - this = THIS; - conf = this->private; - - GF_ASSERT (conf); - - if (!peerinfo->mgmt) - goto out; - proc = &peerinfo->mgmt->proctable[GLUSTERD_MGMT_FRIEND_ADD]; - if (proc->fn) { - frame = create_frame (this, this->ctx->pool); - if (!frame) { - goto out; - } - frame->local = ctx; - ret = proc->fn (frame, this, event); + int ret = 0; + glusterd_peerinfo_t *peerinfo = NULL; + rpc_clnt_procedure_t *proc = NULL; + call_frame_t *frame = NULL; + glusterd_conf_t *conf = NULL; + xlator_t *this = NULL; + + GF_ASSERT(event); + + this = THIS; + conf = this->private; + + GF_ASSERT(conf); + + RCU_READ_LOCK; + + peerinfo = glusterd_peerinfo_find(event->peerid, event->peername); + if (!peerinfo) { + RCU_READ_UNLOCK; + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_PEER_NOT_FOUND, + "Could not find peer %s(%s)", event->peername, + uuid_utoa(event->peerid)); + goto out; + } + + if (!peerinfo->peer) { + RCU_READ_UNLOCK; + goto out; + } + proc = &peerinfo->peer->proctable[GLUSTERD_FRIEND_ADD]; + if (proc->fn) { + frame = create_frame(this, this->ctx->pool); + if (!frame) { + RCU_READ_UNLOCK; + goto out; } + frame->local = ctx; + ret = proc->fn(frame, this, event); + } + RCU_READ_UNLOCK; out: - gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret); + if (ret && frame) + STACK_DESTROY(frame->root); - return ret; + gf_msg_debug("glusterd", 0, "Returning with %d", ret); + return ret; } static int -glusterd_ac_friend_probe (glusterd_friend_sm_event_t *event, void *ctx) +glusterd_ac_friend_probe(glusterd_friend_sm_event_t *event, void *ctx) { - int ret = -1; - rpc_clnt_procedure_t *proc = NULL; - call_frame_t *frame = NULL; - glusterd_conf_t *conf = NULL; - xlator_t *this = NULL; - glusterd_probe_ctx_t *probe_ctx = NULL; - glusterd_peerinfo_t *peerinfo = NULL; - dict_t *dict = NULL; + int ret = -1; + rpc_clnt_procedure_t *proc = NULL; + call_frame_t *frame = NULL; + glusterd_conf_t *conf = NULL; + xlator_t *this = NULL; + glusterd_probe_ctx_t *probe_ctx = NULL; + glusterd_peerinfo_t *peerinfo = NULL; + dict_t *dict = NULL; + + GF_ASSERT(ctx); + + probe_ctx = ctx; + + this = THIS; + + GF_ASSERT(this); + + conf = this->private; + + GF_ASSERT(conf); + + RCU_READ_LOCK; + peerinfo = glusterd_peerinfo_find(NULL, probe_ctx->hostname); + if (peerinfo == NULL) { + // We should not reach this state ideally + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_PEER_NOT_FOUND, NULL); + ret = -1; + goto unlock; + } + + if (!peerinfo->peer) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_PEER_ADDRESS_GET_FAIL, + NULL); + goto unlock; + } + proc = &peerinfo->peer->proctable[GLUSTERD_PROBE_QUERY]; + if (proc->fn) { + frame = create_frame(this, this->ctx->pool); + if (!frame) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_FRAME_CREATE_FAIL, + NULL); + goto unlock; + } + frame->local = ctx; + dict = dict_new(); + if (!dict) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_CREATE_FAIL, + NULL); + goto unlock; + } + ret = dict_set_strn(dict, "hostname", SLEN("hostname"), + probe_ctx->hostname); + if (ret) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_SET_FAILED, + "Key=hostname", NULL); + goto unlock; + } - GF_ASSERT (ctx); + ret = dict_set_int32n(dict, "port", SLEN("port"), probe_ctx->port); + if (ret) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_SET_FAILED, + "Key=port", NULL); + goto unlock; + } - probe_ctx = ctx; + /* The peerinfo reference being set here is going to be used + * only within this critical section, in glusterd_rpc_probe + * (ie. proc->fn). + */ + ret = dict_set_static_ptr(dict, "peerinfo", peerinfo); + if (ret) { + RCU_READ_UNLOCK; + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_DICT_SET_FAILED, + "failed to set peerinfo"); + goto out; + } - this = THIS; + ret = proc->fn(frame, this, dict); + if (ret) + goto unlock; + } +unlock: + RCU_READ_UNLOCK; +out: - GF_ASSERT (this); + if (dict) + dict_unref(dict); + gf_msg_debug("glusterd", 0, "Returning with %d", ret); - conf = this->private; + if (ret && frame) + STACK_DESTROY(frame->root); - GF_ASSERT (conf); + return ret; +} - ret = glusterd_friend_find (NULL, probe_ctx->hostname, &peerinfo); - if (ret) { - //We should not reach this state ideally - GF_ASSERT (0); - goto out; +static int +glusterd_ac_send_friend_remove_req(glusterd_friend_sm_event_t *event, + void *data) +{ + int ret = 0; + glusterd_peerinfo_t *peerinfo = NULL; + rpc_clnt_procedure_t *proc = NULL; + call_frame_t *frame = NULL; + glusterd_conf_t *conf = NULL; + xlator_t *this = NULL; + glusterd_friend_sm_event_type_t event_type = GD_FRIEND_EVENT_NONE; + glusterd_probe_ctx_t *ctx = NULL; + glusterd_friend_sm_event_t *new_event = NULL; + + GF_ASSERT(event); + + this = THIS; + conf = this->private; + + GF_ASSERT(conf); + + RCU_READ_LOCK; + + peerinfo = glusterd_peerinfo_find(event->peerid, event->peername); + if (!peerinfo) { + RCU_READ_UNLOCK; + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_PEER_NOT_FOUND, + "Could not find peer %s(%s)", event->peername, + uuid_utoa(event->peerid)); + goto out; + } + ctx = event->ctx; + + if (!peerinfo->connected) { + event_type = GD_FRIEND_EVENT_REMOVE_FRIEND; + + ret = glusterd_friend_sm_new_event(event_type, &new_event); + + if (!ret) { + new_event->peername = peerinfo->hostname; + gf_uuid_copy(new_event->peerid, peerinfo->uuid); + ret = glusterd_friend_sm_inject_event(new_event); + } else { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_EVENT_NEW_GET_FAIL, + "Unable to get event"); } - if (!peerinfo->mgmt) - goto out; - proc = &peerinfo->mgmt->proctable[GLUSTERD_MGMT_PROBE_QUERY]; - if (proc->fn) { - frame = create_frame (this, this->ctx->pool); - if (!frame) { - goto out; - } - frame->local = ctx; - dict = dict_new (); - if (!dict) - goto out; - ret = dict_set_str (dict, "hostname", probe_ctx->hostname); - if (ret) - goto out; - - ret = dict_set_int32 (dict, "port", probe_ctx->port); - if (ret) - goto out; - - ret = dict_set_static_ptr (dict, "peerinfo", peerinfo); - if (ret) { - gf_log ("", GF_LOG_ERROR, "failed to set peerinfo"); - goto out; - } - - ret = proc->fn (frame, this, dict); - if (ret) - goto out; - + if (ctx) { + ret = glusterd_xfer_cli_deprobe_resp(ctx->req, ret, 0, NULL, + ctx->hostname, ctx->dict); + glusterd_broadcast_friend_delete(ctx->hostname, NULL); + glusterd_destroy_probe_ctx(ctx); } + goto unlock; + } + + if (!peerinfo->peer) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_PEER_ADDRESS_GET_FAIL, + NULL); + goto unlock; + } + proc = &peerinfo->peer->proctable[GLUSTERD_FRIEND_REMOVE]; + if (proc->fn) { + frame = create_frame(this, this->ctx->pool); + if (!frame) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_FRAME_CREATE_FAIL, + NULL); + goto unlock; + } + frame->local = data; + ret = proc->fn(frame, this, event); + } - +unlock: + RCU_READ_UNLOCK; out: - if (dict) - dict_unref (dict); - gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret); - - return ret; -} -static int -glusterd_ac_send_friend_remove_req (glusterd_friend_sm_event_t *event, - void *data) -{ - int ret = 0; - glusterd_peerinfo_t *peerinfo = NULL; - rpc_clnt_procedure_t *proc = NULL; - call_frame_t *frame = NULL; - glusterd_conf_t *conf = NULL; - xlator_t *this = NULL; - glusterd_friend_sm_event_type_t event_type = GD_FRIEND_EVENT_NONE; - glusterd_probe_ctx_t *ctx = NULL; - glusterd_friend_sm_event_t *new_event = NULL; + gf_msg_debug("glusterd", 0, "Returning with %d", ret); - GF_ASSERT (event); - peerinfo = event->peerinfo; + if (ret && frame) + STACK_DESTROY(frame->root); - this = THIS; - conf = this->private; + return ret; +} - GF_ASSERT (conf); +static gf_boolean_t +glusterd_should_update_peer(glusterd_peerinfo_t *peerinfo, + glusterd_peerinfo_t *cur_peerinfo) +{ + if ((peerinfo == cur_peerinfo) || + (peerinfo->state.state == GD_FRIEND_STATE_BEFRIENDED)) + return _gf_true; - ctx = event->ctx; + return _gf_false; +} - if (!peerinfo->connected) { - event_type = GD_FRIEND_EVENT_REMOVE_FRIEND; +static int +glusterd_ac_send_friend_update(glusterd_friend_sm_event_t *event, void *ctx) +{ + int ret = 0; + glusterd_peerinfo_t *cur_peerinfo = NULL; + glusterd_peerinfo_t *peerinfo = NULL; + rpc_clnt_procedure_t *proc = NULL; + xlator_t *this = NULL; + glusterd_friend_update_ctx_t ev_ctx = {{0}}; + glusterd_conf_t *priv = NULL; + dict_t *friends = NULL; + char key[64] = { + 0, + }; + int keylen; + int32_t count = 0; + + GF_ASSERT(event); + + this = THIS; + priv = this->private; + + GF_ASSERT(priv); + + keylen = snprintf(key, sizeof(key), "op"); + friends = dict_new(); + + RCU_READ_LOCK; + + cur_peerinfo = glusterd_peerinfo_find(event->peerid, event->peername); + if (!cur_peerinfo) { + RCU_READ_UNLOCK; + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_PEER_NOT_FOUND, + "Could not find peer %s(%s)", event->peername, + uuid_utoa(event->peerid)); + goto out; + } + + if (!friends) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_CREATE_FAIL, NULL); + goto unlock; + } + + ev_ctx.op = GD_FRIEND_UPDATE_ADD; + ret = dict_set_int32n(friends, key, keylen, ev_ctx.op); + if (ret) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_SET_FAILED, + "Key=%s", key, NULL); + goto unlock; + } + + cds_list_for_each_entry_rcu(peerinfo, &priv->peers, uuid_list) + { + if (!glusterd_should_update_peer(peerinfo, cur_peerinfo)) + continue; + + count++; + + snprintf(key, sizeof(key), "friend%d", count); + ret = gd_add_friend_to_dict(peerinfo, friends, key); + if (ret) + goto unlock; + } - ret = glusterd_friend_sm_new_event (event_type, &new_event); + ret = dict_set_int32n(friends, "count", SLEN("count"), count); + if (ret) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_SET_FAILED, + "Key=count", NULL); + goto unlock; + } - if (!ret) { - new_event->peerinfo = peerinfo; - ret = glusterd_friend_sm_inject_event (new_event); - } else { - gf_log ("glusterd", GF_LOG_ERROR, - "Unable to get event"); - } + cds_list_for_each_entry_rcu(peerinfo, &priv->peers, uuid_list) + { + if (!peerinfo->connected || !peerinfo->peer) + continue; - if (ctx) - ret = glusterd_xfer_cli_deprobe_resp (ctx->req, ret, 0, - ctx->hostname); - glusterd_friend_sm (); - glusterd_op_sm (); + if (!glusterd_should_update_peer(peerinfo, cur_peerinfo)) + continue; - if (ctx) { - glusterd_broadcast_friend_delete (ctx->hostname, NULL); - glusterd_destroy_probe_ctx (ctx); - } - goto out; + ret = dict_set_static_ptr(friends, "peerinfo", peerinfo); + if (ret) { + RCU_READ_UNLOCK; + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_DICT_SET_FAILED, + "failed to set peerinfo"); + goto out; } - if (!peerinfo->mgmt) - goto out; - proc = &peerinfo->mgmt->proctable[GLUSTERD_MGMT_FRIEND_REMOVE]; + proc = &peerinfo->peer->proctable[GLUSTERD_FRIEND_UPDATE]; if (proc->fn) { - frame = create_frame (this, this->ctx->pool); - if (!frame) { - goto out; - } - frame->local = data; - ret = proc->fn (frame, this, event); + ret = proc->fn(NULL, this, friends); } + } +unlock: + RCU_READ_UNLOCK; out: - gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret); - return ret; + if (friends) + dict_unref(friends); + + gf_msg_debug("glusterd", 0, "Returning with %d", ret); + return ret; } +/* ac_update_friend only sends friend update to the friend that caused this + * event to happen + */ static int -glusterd_ac_send_friend_update (glusterd_friend_sm_event_t *event, void *ctx) +glusterd_ac_update_friend(glusterd_friend_sm_event_t *event, void *ctx) { - int ret = 0; - glusterd_peerinfo_t *peerinfo = NULL; - rpc_clnt_procedure_t *proc = NULL; - xlator_t *this = NULL; - glusterd_friend_update_ctx_t ev_ctx = {{0}}; - glusterd_conf_t *priv = NULL; - dict_t *friends = NULL; - char key[100] = {0,}; - char *dup_buf = NULL; - int32_t count = 0; - - GF_ASSERT (event); - peerinfo = event->peerinfo; - - this = THIS; - priv = this->private; - - GF_ASSERT (priv); - - ev_ctx.op = GD_FRIEND_UPDATE_ADD; - - friends = dict_new (); - if (!friends) - goto out; - - snprintf (key, sizeof (key), "op"); - ret = dict_set_int32 (friends, key, ev_ctx.op); + int ret = 0; + glusterd_peerinfo_t *cur_peerinfo = NULL; + glusterd_peerinfo_t *peerinfo = NULL; + rpc_clnt_procedure_t *proc = NULL; + xlator_t *this = NULL; + glusterd_friend_update_ctx_t ev_ctx = {{0}}; + glusterd_conf_t *priv = NULL; + dict_t *friends = NULL; + char key[64] = { + 0, + }; + int keylen; + int32_t count = 0; + + GF_ASSERT(event); + + this = THIS; + priv = this->private; + + GF_ASSERT(priv); + + friends = dict_new(); + keylen = snprintf(key, sizeof(key), "op"); + + RCU_READ_LOCK; + + cur_peerinfo = glusterd_peerinfo_find(event->peerid, event->peername); + if (!cur_peerinfo) { + RCU_READ_UNLOCK; + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_PEER_NOT_FOUND, + "Could not find peer %s(%s)", event->peername, + uuid_utoa(event->peerid)); + goto out; + } + + /* Bail out early if peer is not connected. + * We cannot send requests to the peer until we have established our + * client connection to it. + */ + if (!cur_peerinfo->connected || !cur_peerinfo->peer) { + ret = 0; + goto unlock; + } + + if (!friends) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_CREATE_FAIL, NULL); + goto out; + } + + ev_ctx.op = GD_FRIEND_UPDATE_ADD; + ret = dict_set_int32n(friends, key, keylen, ev_ctx.op); + if (ret) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_SET_FAILED, + "Key=%s", key, NULL); + goto unlock; + } + + cds_list_for_each_entry_rcu(peerinfo, &priv->peers, uuid_list) + { + if (!glusterd_should_update_peer(peerinfo, cur_peerinfo)) + continue; + + count++; + + snprintf(key, sizeof(key), "friend%d", count); + ret = gd_add_friend_to_dict(peerinfo, friends, key); if (ret) - goto out; + goto unlock; + } + + ret = dict_set_int32n(friends, "count", SLEN("count"), count); + if (ret) { + gf_smsg(this->name, GF_LOG_ERROR, errno, GD_MSG_DICT_SET_FAILED, + "Key=count", NULL); + goto unlock; + } + + ret = dict_set_static_ptr(friends, "peerinfo", cur_peerinfo); + if (ret) { + RCU_READ_UNLOCK; + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_DICT_SET_FAILED, + "failed to set peerinfo"); + goto out; + } + + proc = &cur_peerinfo->peer->proctable[GLUSTERD_FRIEND_UPDATE]; + if (proc->fn) + ret = proc->fn(NULL, this, friends); + + gf_msg_debug(this->name, 0, "Returning with %d", ret); + +unlock: + RCU_READ_UNLOCK; +out: - list_for_each_entry (peerinfo, &priv->peers, uuid_list) { - count++; - snprintf (key, sizeof (key), "friend%d.uuid", count); - dup_buf = gf_strdup (uuid_utoa (peerinfo->uuid)); - ret = dict_set_dynstr (friends, key, dup_buf); - if (ret) - goto out; - snprintf (key, sizeof (key), "friend%d.hostname", count); - ret = dict_set_str (friends, key, peerinfo->hostname); - if (ret) - goto out; - gf_log ("", GF_LOG_INFO, "Added uuid: %s, host: %s", - dup_buf, peerinfo->hostname); - } + if (friends) + dict_unref(friends); - ret = dict_set_int32 (friends, "count", count); - if (ret) - goto out; + return ret; +} - list_for_each_entry (peerinfo, &priv->peers, uuid_list) { - if (!peerinfo->connected || !peerinfo->mgmt) - continue; +/* Clean up stale volumes on the peer being detached. The volumes which have + * bricks on other peers are stale with respect to the detached peer. + */ +static void +glusterd_peer_detach_cleanup(glusterd_conf_t *priv) +{ + int ret = -1; + glusterd_volinfo_t *volinfo = NULL; + glusterd_volinfo_t *tmp_volinfo = NULL; + glusterd_svc_t *svc = NULL; + + GF_ASSERT(priv); + + cds_list_for_each_entry_safe(volinfo, tmp_volinfo, &priv->volumes, vol_list) + { + /* The peer detach checks make sure that, at this point in the + * detach process, there are only volumes contained completely + * within or completely outside the detached peer. + * The only stale volumes at this point are the ones + * completely outside the peer and can be safely deleted. + */ + if (!glusterd_friend_contains_vol_bricks(volinfo, MY_UUID)) { + gf_msg(THIS->name, GF_LOG_INFO, 0, GD_MSG_STALE_VOL_DELETE_INFO, + "Deleting stale volume %s", volinfo->volname); + + /*Stop snapd daemon service if snapd daemon is running*/ + if (!volinfo->is_snap_volume) { + svc = &(volinfo->snapd.svc); + ret = svc->stop(svc, SIGTERM); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_SVC_STOP_FAIL, + "Failed " + "to stop snapd daemon service"); + } + } - ret = dict_set_static_ptr (friends, "peerinfo", peerinfo); + if (glusterd_is_shd_compatible_volume(volinfo)) { + svc = &(volinfo->shd.svc); + ret = svc->stop(svc, SIGTERM); if (ret) { - gf_log ("", GF_LOG_ERROR, "failed to set peerinfo"); - goto out; + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_SVC_STOP_FAIL, + "Failed " + "to stop shd daemon service"); } + } - proc = &peerinfo->mgmt->proctable[GLUSTERD_MGMT_FRIEND_UPDATE]; - if (proc->fn) { - ret = proc->fn (NULL, this, friends); + if (glusterd_is_gfproxyd_enabled(volinfo)) { + svc = &(volinfo->gfproxyd.svc); + ret = svc->stop(svc, SIGTERM); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_SVC_STOP_FAIL, + "Failed " + "to stop gfproxyd daemon service"); } + } + + ret = glusterd_cleanup_snaps_for_volume(volinfo); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_VOL_DELETE_FAIL, + "Error deleting snapshots for volume %s", + volinfo->volname); + } + + ret = glusterd_delete_volume(volinfo); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, + GD_MSG_STALE_VOL_REMOVE_FAIL, + "Error deleting stale volume"); + } } - - gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret); - -out: - if (friends) - dict_unref (friends); - - return ret; + } + + /*Reconfigure all daemon services upon peer detach*/ + ret = glusterd_svcs_reconfigure(NULL); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_SVC_STOP_FAIL, + "Failed to reconfigure all daemon services."); + } } - static int -glusterd_ac_handle_friend_remove_req (glusterd_friend_sm_event_t *event, - void *ctx) +glusterd_ac_handle_friend_remove_req(glusterd_friend_sm_event_t *event, + void *ctx) { - int ret = 0; - glusterd_peerinfo_t *peerinfo = NULL; - glusterd_friend_req_ctx_t *ev_ctx = NULL; - glusterd_friend_sm_event_t *new_event = NULL; - glusterd_conf_t *priv = NULL; - - GF_ASSERT (ctx); - ev_ctx = ctx; - peerinfo = event->peerinfo; - GF_ASSERT (peerinfo); - - priv = THIS->private; - GF_ASSERT (priv); - - ret = glusterd_xfer_friend_remove_resp (ev_ctx->req, ev_ctx->hostname, - ev_ctx->port); - - list_for_each_entry (peerinfo, &priv->peers, uuid_list) { - - ret = glusterd_friend_sm_new_event (GD_FRIEND_EVENT_REMOVE_FRIEND, - &new_event); - if (ret) - goto out; + int ret = 0; + glusterd_peerinfo_t *peerinfo = NULL; + glusterd_friend_req_ctx_t *ev_ctx = NULL; + glusterd_friend_sm_event_t *new_event = NULL; + glusterd_conf_t *priv = NULL; + + GF_ASSERT(ctx); + ev_ctx = ctx; + + priv = THIS->private; + GF_ASSERT(priv); + + ret = glusterd_xfer_friend_remove_resp(ev_ctx->req, ev_ctx->hostname, + ev_ctx->port); + + RCU_READ_LOCK; + cds_list_for_each_entry_rcu(peerinfo, &priv->peers, uuid_list) + { + ret = glusterd_friend_sm_new_event(GD_FRIEND_EVENT_REMOVE_FRIEND, + &new_event); + if (ret) { + RCU_READ_UNLOCK; + goto out; + } - new_event->peerinfo = peerinfo; + new_event->peername = gf_strdup(peerinfo->hostname); + gf_uuid_copy(new_event->peerid, peerinfo->uuid); - ret = glusterd_friend_sm_inject_event (new_event); - if (ret) - goto out; + ret = glusterd_friend_sm_inject_event(new_event); + if (ret) { + RCU_READ_UNLOCK; + goto out; } + new_event = NULL; + } + RCU_READ_UNLOCK; + + glusterd_peer_detach_cleanup(priv); out: - gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret); + if (new_event) + GF_FREE(new_event->peername); + GF_FREE(new_event); - return ret; + gf_msg_debug(THIS->name, 0, "Returning with %d", ret); + return ret; } static int -glusterd_ac_friend_remove (glusterd_friend_sm_event_t *event, void *ctx) +glusterd_ac_friend_remove(glusterd_friend_sm_event_t *event, void *ctx) { - int ret = -1; - - ret = glusterd_friend_cleanup (event->peerinfo); - - if (ret) { - gf_log ("", GF_LOG_ERROR, "Cleanup returned: %d", ret); - } - - return 0; + int ret = -1; + glusterd_peerinfo_t *peerinfo = NULL; + + GF_ASSERT(event); + + RCU_READ_LOCK; + + peerinfo = glusterd_peerinfo_find(event->peerid, event->peername); + if (!peerinfo) { + RCU_READ_UNLOCK; + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_PEER_NOT_FOUND, + "Could not find peer %s(%s)", event->peername, + uuid_utoa(event->peerid)); + goto out; + } + ret = glusterd_friend_remove_cleanup_vols(peerinfo->uuid); + RCU_READ_UNLOCK; + if (ret) + gf_msg(THIS->name, GF_LOG_WARNING, 0, GD_MSG_VOL_CLEANUP_FAIL, + "Volumes cleanup failed"); + + /* Exiting read critical section as glusterd_peerinfo_cleanup calls + * synchronize_rcu before freeing the peerinfo + */ + + ret = glusterd_peerinfo_cleanup(peerinfo); + if (ret) { + gf_msg(THIS->name, GF_LOG_ERROR, 0, GD_MSG_PEER_DETACH_CLEANUP_FAIL, + "Cleanup returned: %d", ret); + } +out: + return 0; } /*static int @@ -588,426 +941,682 @@ glusterd_ac_none (void *ctx) }*/ static int -glusterd_ac_handle_friend_add_req (glusterd_friend_sm_event_t *event, void *ctx) +glusterd_ac_handle_friend_add_req(glusterd_friend_sm_event_t *event, void *ctx) { - int ret = 0; - uuid_t uuid; - glusterd_peerinfo_t *peerinfo = NULL; - glusterd_friend_req_ctx_t *ev_ctx = NULL; - glusterd_friend_update_ctx_t *new_ev_ctx = NULL; - glusterd_friend_sm_event_t *new_event = NULL; - glusterd_friend_sm_event_type_t event_type = GD_FRIEND_EVENT_NONE; - int status = 0; - int32_t op_ret = -1; - int32_t op_errno = 0; - - GF_ASSERT (ctx); - ev_ctx = ctx; - uuid_copy (uuid, ev_ctx->uuid); - peerinfo = event->peerinfo; - GF_ASSERT (peerinfo); - uuid_copy (peerinfo->uuid, ev_ctx->uuid); - - //Build comparison logic here. - ret = glusterd_compare_friend_data (ev_ctx->vols, &status); - if (ret) - goto out; + int ret = 0; + uuid_t uuid; + glusterd_peerinfo_t *peerinfo = NULL; + glusterd_friend_req_ctx_t *ev_ctx = NULL; + glusterd_friend_update_ctx_t *new_ev_ctx = NULL; + glusterd_friend_sm_event_t *new_event = NULL; + glusterd_friend_sm_event_type_t event_type = GD_FRIEND_EVENT_NONE; + glusterd_conf_t *conf = NULL; + int status = 0; + int32_t op_ret = -1; + int32_t op_errno = 0; + xlator_t *this = NULL; + char *hostname = NULL; + + this = THIS; + GF_ASSERT(this); + + GF_ASSERT(ctx); + ev_ctx = ctx; + gf_uuid_copy(uuid, ev_ctx->uuid); + + RCU_READ_LOCK; + peerinfo = glusterd_peerinfo_find(event->peerid, event->peername); + if (!peerinfo) { + RCU_READ_UNLOCK; + ret = -1; + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_PEER_NOT_FOUND, + "Could not find peer %s(%s)", event->peername, + uuid_utoa(event->peerid)); + goto out; + } + + /* TODO: How do you do an atomic copy of uuid_t */ + /* TODO: Updating within a read-critical section is also invalid + * Update properly with updater synchronization + */ + gf_uuid_copy(peerinfo->uuid, ev_ctx->uuid); + + RCU_READ_UNLOCK; + + conf = this->private; + GF_ASSERT(conf); + + /* Passing the peername from the event. glusterd_compare_friend_data + * updates volumes and will use synchronize_rcu. If we were to pass + * peerinfo->hostname, we would have to do it under a read critical + * section which would lead to a deadlock + */ + + // Build comparison logic here. + pthread_mutex_lock(&conf->import_volumes); + { + ret = glusterd_compare_friend_data(ev_ctx->vols, &status, + event->peername); + if (ret) { + pthread_mutex_unlock(&conf->import_volumes); + goto out; + } if (GLUSTERD_VOL_COMP_RJT != status) { - event_type = GD_FRIEND_EVENT_LOCAL_ACC; - op_ret = 0; + event_type = GD_FRIEND_EVENT_LOCAL_ACC; + op_ret = 0; } else { - event_type = GD_FRIEND_EVENT_LOCAL_RJT; - op_errno = GF_PROBE_VOLUME_CONFLICT; - op_ret = -1; - } - - ret = glusterd_friend_sm_new_event (event_type, &new_event); - - if (ret) { - gf_log ("", GF_LOG_ERROR, "Out of Memory"); + event_type = GD_FRIEND_EVENT_LOCAL_RJT; + op_errno = GF_PROBE_VOLUME_CONFLICT; + op_ret = -1; } - new_event->peerinfo = peerinfo; - - new_ev_ctx = GF_CALLOC (1, sizeof (*new_ev_ctx), - gf_gld_mt_friend_update_ctx_t); - if (!new_ev_ctx) { - ret = -1; - goto out; + /* Compare missed_snapshot list with the peer * + * if volume comparison is successful */ + if ((op_ret == 0) && (conf->op_version >= GD_OP_VERSION_3_6_0)) { + ret = glusterd_import_friend_missed_snap_list(ev_ctx->vols); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, + GD_MSG_MISSED_SNAP_LIST_STORE_FAIL, + "Failed to import peer's " + "missed_snaps_list."); + event_type = GD_FRIEND_EVENT_LOCAL_RJT; + op_errno = GF_PROBE_MISSED_SNAP_CONFLICT; + op_ret = -1; + } + + /* glusterd_compare_friend_snapshots and functions only require + * a peers hostname and uuid. It also does updates, which + * require use of synchronize_rcu. So we pass the hostname and + * id from the event instead of the peerinfo object to prevent + * deadlocks as above. + */ + ret = glusterd_compare_friend_snapshots( + ev_ctx->vols, event->peername, event->peerid); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, + GD_MSG_SNAP_COMPARE_CONFLICT, + "Conflict in comparing peer's snapshots"); + event_type = GD_FRIEND_EVENT_LOCAL_RJT; + op_errno = GF_PROBE_SNAP_CONFLICT; + op_ret = -1; + } } - - uuid_copy (new_ev_ctx->uuid, ev_ctx->uuid); - new_ev_ctx->hostname = gf_strdup (ev_ctx->hostname); - new_ev_ctx->op = GD_FRIEND_UPDATE_ADD; - - new_event->ctx = new_ev_ctx; - - glusterd_friend_sm_inject_event (new_event); - - ret = glusterd_xfer_friend_add_resp (ev_ctx->req, ev_ctx->hostname, - ev_ctx->port, op_ret, op_errno); + } + pthread_mutex_unlock(&conf->import_volumes); + ret = glusterd_friend_sm_new_event(event_type, &new_event); + + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, ENOMEM, GD_MSG_NO_MEMORY, + "Out of Memory"); + goto out; + } + + new_event->peername = gf_strdup(event->peername); + gf_uuid_copy(new_event->peerid, event->peerid); + + new_ev_ctx = GF_CALLOC(1, sizeof(*new_ev_ctx), + gf_gld_mt_friend_update_ctx_t); + if (!new_ev_ctx) { + ret = -1; + goto out; + } + + gf_uuid_copy(new_ev_ctx->uuid, ev_ctx->uuid); + new_ev_ctx->hostname = gf_strdup(ev_ctx->hostname); + new_ev_ctx->op = GD_FRIEND_UPDATE_ADD; + + new_event->ctx = new_ev_ctx; + + ret = dict_get_strn(ev_ctx->vols, "hostname_in_cluster", + SLEN("hostname_in_cluster"), &hostname); + if (ret || !hostname) { + gf_msg_debug(this->name, 0, "Unable to fetch local hostname from peer"); + } else if (snprintf(local_node_hostname, sizeof(local_node_hostname), "%s", + hostname) >= sizeof(local_node_hostname)) { + gf_msg_debug(this->name, 0, "local_node_hostname truncated"); + ret = -1; + goto out; + } + + glusterd_friend_sm_inject_event(new_event); + new_event = NULL; + + ret = glusterd_xfer_friend_add_resp(ev_ctx->req, ev_ctx->hostname, + event->peername, ev_ctx->port, op_ret, + op_errno); out: - gf_log ("", GF_LOG_DEBUG, "Returning with %d", ret); + if (new_event) + GF_FREE(new_event->peername); + GF_FREE(new_event); - return ret; + gf_msg_debug("glusterd", 0, "Returning with %d", ret); + return ret; } static int -glusterd_friend_sm_transition_state (glusterd_peerinfo_t *peerinfo, - glusterd_sm_t *state, - glusterd_friend_sm_event_type_t event_type) +glusterd_friend_sm_transition_state(uuid_t peerid, char *peername, + glusterd_sm_t *state, + glusterd_friend_sm_event_type_t event_type) { + int ret = -1; + glusterd_peerinfo_t *peerinfo = NULL; - GF_ASSERT (state); - GF_ASSERT (peerinfo); + GF_ASSERT(state); + GF_ASSERT(peername); - (void) glusterd_sm_tr_log_transition_add (&peerinfo->sm_log, - peerinfo->state.state, - state[event_type].next_state, - event_type); + RCU_READ_LOCK; + peerinfo = glusterd_peerinfo_find(peerid, peername); + if (!peerinfo) { + gf_smsg(THIS->name, GF_LOG_ERROR, errno, GD_MSG_PEER_NOT_FOUND, NULL); + goto out; + } - peerinfo->state.state = state[event_type].next_state; - return 0; -} + (void)glusterd_sm_tr_log_transition_add( + &peerinfo->sm_log, peerinfo->state.state, state[event_type].next_state, + event_type); + uatomic_set(&peerinfo->state.state, state[event_type].next_state); -glusterd_sm_t glusterd_state_default [] = { - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_probe},//EV_PROBE - {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_friend_add}, //EV_INIT_FRIEND_REQ - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, //EVENT_RCVD_ACC - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, //EVENT_RCVD_LOCAL_ACC - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, //EVENT_RCVD_RJT - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, //EVENT_RCVD_LOCAL_RJT - {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_handle_friend_add_req}, //EVENT_RCV_FRIEND_REQ - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_send_friend_remove_req}, //EV_INIT_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, //EVENT_RCVD_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_remove}, //EVENT_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_probe}, //EVENT_CONNECTED - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, //EVENT_MAX -}; + ret = 0; +out: + RCU_READ_UNLOCK; + return ret; +} -glusterd_sm_t glusterd_state_probe_rcvd [] = { - {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, - {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, //EV_PROBE - {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, //EV_INIT_FRIEND_REQ - {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, //EVENT_RCVD_ACC - {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, //EVENT_RCVD_LOCAL_ACC - {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, //EVENT_RCVD_RJT - {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, //EVENT_RCVD_LOCAL_RJT - {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_handle_friend_add_req}, //EVENT_RCV_FRIEND_REQ - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_send_friend_remove_req}, //EV_INIT_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, //EVENT_RCVD_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_remove}, //EVENT_REMOVE_FRIEND - {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, //EVENT_CONNECTED - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, //EVENT_MAX +glusterd_sm_t glusterd_state_default[] = { + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_probe}, // EV_PROBE + {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_friend_add}, // EV_INIT_FRIEND_REQ + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, // EVENT_RCVD_ACC + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, // EVENT_RCVD_LOCAL_ACC + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, // EVENT_RCVD_RJT + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, // EVENT_RCVD_LOCAL_RJT + {GD_FRIEND_STATE_REQ_RCVD, + glusterd_ac_handle_friend_add_req}, // EVENT_RCV_FRIEND_REQ + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_send_friend_remove_req}, // EV_INIT_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, // EVENT_RCVD_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_friend_remove}, // EVENT_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_probe}, // EVENT_CONNECTED + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, // EVENT_NEW_NAME + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, // EVENT_MAX }; -glusterd_sm_t glusterd_state_connected_rcvd [] = { - {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, - {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, //EV_PROBE - {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, //EV_INIT_FRIEND_REQ - {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, //EVENT_RCVD_ACC - {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_reverse_probe_begin}, //EVENT_RCVD_LOCAL_ACC - {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, //EVENT_RCVD_RJT - {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, //EVENT_RCVD_LOCAL_RJT - {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_handle_friend_add_req}, //EVENT_RCV_FRIEND_REQ - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_send_friend_remove_req}, //EV_INIT_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, //EVENT_RCVD_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_remove}, //EVENT_REMOVE_FRIEND - {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, //EVENT_CONNECTED - {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, //EVENT_MAX +glusterd_sm_t glusterd_state_probe_rcvd[] = { + {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, + {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, // EV_PROBE + {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, // EV_INIT_FRIEND_REQ + {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, // EVENT_RCVD_ACC + {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, // EVENT_RCVD_LOCAL_ACC + {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, // EVENT_RCVD_RJT + {GD_FRIEND_STATE_PROBE_RCVD, glusterd_ac_none}, // EVENT_RCVD_LOCAL_RJT + {GD_FRIEND_STATE_REQ_RCVD, + glusterd_ac_handle_friend_add_req}, // EVENT_RCV_FRIEND_REQ + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_send_friend_remove_req}, // EV_INIT_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, // EVENT_RCVD_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_friend_remove}, // EVENT_REMOVE_FRIEND + {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, // EVENT_CONNECTED + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, // EVENT_NEW_NAME + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, // EVENT_MAX }; -glusterd_sm_t glusterd_state_connected_accepted [] = { - {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, - {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_friend_probe}, //EV_PROBE - {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_friend_add}, //EV_INIT_FRIEND_REQ - {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, //EVENT_RCVD_ACC - {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, //EVENT_RCVD_LOCAL_ACC - {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, //EVENT_RCVD_RJT - {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, //EVENT_RCVD_LOCAL_RJT - {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, //EVENT_RCV_FRIEND_REQ - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_send_friend_remove_req}, //EV_INIT_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, //EVENT_RCVD_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_remove}, //EVENT_REMOVE_FRIEND - {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, //EVENT_CONNECTED - {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, //EVENT_MAX +glusterd_sm_t glusterd_state_connected_rcvd[] = { + {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, + {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, // EV_PROBE + {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, // EV_INIT_FRIEND_REQ + {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, // EVENT_RCVD_ACC + {GD_FRIEND_STATE_CONNECTED_ACCEPTED, + glusterd_ac_reverse_probe_begin}, // EVENT_RCVD_LOCAL_ACC + {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, // EVENT_RCVD_RJT + {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, // EVENT_RCVD_LOCAL_RJT + {GD_FRIEND_STATE_CONNECTED_RCVD, + glusterd_ac_handle_friend_add_req}, // EVENT_RCV_FRIEND_REQ + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_send_friend_remove_req}, // EV_INIT_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, // EVENT_RCVD_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_friend_remove}, // EVENT_REMOVE_FRIEND + {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, // EVENT_CONNECTED + {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, // EVENT_NEW_NAME + {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, // EVENT_MAX }; -glusterd_sm_t glusterd_state_req_sent [] = { - {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, //EVENT_NONE, - {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, //EVENT_PROBE, - {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, //EVENT_INIT_FRIEND_REQ, - {GD_FRIEND_STATE_REQ_ACCEPTED, glusterd_ac_none}, //EVENT_RCVD_ACC - {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, //EVENT_RCVD_LOCAL_ACC - {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, //EVENT_RCVD_RJT - {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, //EVENT_RCVD_LOCAL_RJT - {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_handle_friend_add_req}, //EVENT_RCV_FRIEND_REQ - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_send_friend_remove_req}, //EVENT_INIT_REMOVE_FRIEND, - {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, //EVENT_RCVD_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_remove}, //EVENT_REMOVE_FRIEND - {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none},//EVENT_CONNECTED - {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none},//EVENT_MAX +glusterd_sm_t glusterd_state_connected_accepted[] = { + {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, + {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_friend_probe}, // EV_PROBE + {GD_FRIEND_STATE_REQ_SENT_RCVD, + glusterd_ac_friend_add}, // EV_INIT_FRIEND_REQ + {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, // EVENT_RCVD_ACC + {GD_FRIEND_STATE_CONNECTED_ACCEPTED, + glusterd_ac_none}, // EVENT_RCVD_LOCAL_ACC + {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, // EVENT_RCVD_RJT + {GD_FRIEND_STATE_CONNECTED_ACCEPTED, + glusterd_ac_none}, // EVENT_RCVD_LOCAL_RJT + {GD_FRIEND_STATE_CONNECTED_ACCEPTED, + glusterd_ac_none}, // EVENT_RCV_FRIEND_REQ + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_send_friend_remove_req}, // EV_INIT_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, glusterd_ac_none}, // EVENT_RCVD_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_friend_remove}, // EVENT_REMOVE_FRIEND + {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, // EVENT_CONNECTED + {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, // EVENT_NEW_NAME + {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_none}, // EVENT_MAX }; -glusterd_sm_t glusterd_state_req_rcvd [] = { - {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none}, //EVENT_NONE, - {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none}, //EVENT_PROBE, - {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, //EVENT_INIT_FRIEND_REQ, - {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none}, //EVENT_RCVD_ACC - {GD_FRIEND_STATE_REQ_ACCEPTED, glusterd_ac_none}, //EVENT_RCVD_LOCAL_ACC - {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none}, //EVENT_RCVD_RJT - {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, //EVENT_RCVD_LOCAL_RJT - {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none}, //EVENT_RCV_FRIEND_REQ - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_send_friend_remove_req}, //EVENT_INIT_REMOVE_FRIEND, - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_handle_friend_remove_req}, //EVENT_RCVD_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_remove}, //EVENT_REMOVE_FRIEND - {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none},//EVENT_CONNECTED - {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none},//EVENT_MAX +glusterd_sm_t glusterd_state_req_sent[] = { + {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, // EVENT_NONE, + {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, // EVENT_PROBE, + {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, // EVENT_INIT_FRIEND_REQ, + {GD_FRIEND_STATE_REQ_ACCEPTED, glusterd_ac_none}, // EVENT_RCVD_ACC + {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, // EVENT_RCVD_LOCAL_ACC + {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, // EVENT_RCVD_RJT + {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, // EVENT_RCVD_LOCAL_RJT + {GD_FRIEND_STATE_REQ_SENT_RCVD, + glusterd_ac_handle_friend_add_req}, // EVENT_RCV_FRIEND_REQ + {GD_FRIEND_STATE_UNFRIEND_SENT, + glusterd_ac_send_friend_remove_req}, // EVENT_INIT_REMOVE_FRIEND, + {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, // EVENT_RCVD_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_friend_remove}, // EVENT_REMOVE_FRIEND + {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, // EVENT_CONNECTED + {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, // EVENT_NEW_NAME + {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, // EVENT_MAX }; -glusterd_sm_t glusterd_state_befriended [] = { - {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_none}, //EVENT_NONE, - {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_none}, //EVENT_PROBE, - {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_none}, //EVENT_INIT_FRIEND_REQ, - {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_none}, //EVENT_RCVD_ACC - {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_send_friend_update}, //EVENT_RCVD_LOCAL_ACC - {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, //EVENT_RCVD_RJT - {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, //EVENT_RCVD_LOCAL_RJT - {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_handle_friend_add_req}, //EVENT_RCV_FRIEND_REQ - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_send_friend_remove_req}, //EVENT_INIT_REMOVE_FRIEND, - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_handle_friend_remove_req}, //EVENT_RCVD_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_remove}, //EVENT_REMOVE_FRIEND - {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_friend_add},//EVENT_CONNECTED - {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_none},//EVENT_MAX +glusterd_sm_t glusterd_state_req_rcvd[] = { + {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none}, // EVENT_NONE, + {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none}, // EVENT_PROBE, + {GD_FRIEND_STATE_REQ_SENT_RCVD, + glusterd_ac_none}, // EVENT_INIT_FRIEND_REQ, + {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none}, // EVENT_RCVD_ACC + {GD_FRIEND_STATE_REQ_ACCEPTED, glusterd_ac_none}, // EVENT_RCVD_LOCAL_ACC + {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none}, // EVENT_RCVD_RJT + {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, // EVENT_RCVD_LOCAL_RJT + {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none}, // EVENT_RCV_FRIEND_REQ + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_send_friend_remove_req}, // EVENT_INIT_REMOVE_FRIEND, + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_handle_friend_remove_req}, // EVENT_RCVD_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_friend_remove}, // EVENT_REMOVE_FRIEND + {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, // EVENT_CONNECTED + {GD_FRIEND_STATE_CONNECTED_RCVD, glusterd_ac_none}, // EVENT_NEW_NAME + {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none}, // EVENT_MAX }; -glusterd_sm_t glusterd_state_req_sent_rcvd [] = { - {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, //EVENT_NONE, - {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, //EVENT_PROBE, - {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, //EVENT_INIT_FRIEND_REQ, - {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_send_friend_update}, //EVENT_RCVD_ACC - {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, //EVENT_RCVD_LOCAL_ACC - {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, //EVENT_RCVD_RJT - {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, //EVENT_RCVD_LOCAL_RJT - {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, //EVENT_RCV_FRIEND_REQ - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_send_friend_remove_req}, //EVENT_INIT_REMOVE_FRIEND, - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_handle_friend_remove_req}, //EVENT_RCVD_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_remove}, //EVENT_REMOVE_FRIEND - {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none},//EVENT_CONNECTED - {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none},//EVENT_MAX +glusterd_sm_t glusterd_state_befriended[] = { + {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_none}, // EVENT_NONE, + {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_none}, // EVENT_PROBE, + {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_none}, // EVENT_INIT_FRIEND_REQ, + {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_update_friend}, // EVENT_RCVD_ACC + {GD_FRIEND_STATE_BEFRIENDED, + glusterd_ac_update_friend}, // EVENT_RCVD_LOCAL_ACC + {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, // EVENT_RCVD_RJT + {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, // EVENT_RCVD_LOCAL_RJT + {GD_FRIEND_STATE_BEFRIENDED, + glusterd_ac_handle_friend_add_req}, // EVENT_RCV_FRIEND_REQ + {GD_FRIEND_STATE_UNFRIEND_SENT, + glusterd_ac_send_friend_remove_req}, // EVENT_INIT_REMOVE_FRIEND, + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_handle_friend_remove_req}, // EVENT_RCVD_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_friend_remove}, // EVENT_REMOVE_FRIEND + {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_friend_add}, // EVENT_CONNECTED + {GD_FRIEND_STATE_BEFRIENDED, + glusterd_ac_send_friend_update}, // EVENT_NEW_NAME + {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_none}, // EVENT_MAX }; -glusterd_sm_t glusterd_state_rejected [] = { - {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, //EVENT_NONE, - {GD_FRIEND_STATE_REJECTED, glusterd_ac_friend_probe}, //EVENT_PROBE, - {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_friend_add}, //EVENT_INIT_FRIEND_REQ, - {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_none}, //EVENT_RCVD_ACC - {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_none}, //EVENT_RCVD_LOCAL_ACC - {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, //EVENT_RCVD_RJT - {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, //EVENT_RCVD_LOCAL_RJT - {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_handle_friend_add_req}, //EVENT_RCV_FRIEND_REQ - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_send_friend_remove_req}, //EVENT_INIT_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_handle_friend_remove_req}, //EVENT_RCVD_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_remove}, //EVENT_REMOVE_FRIEND - {GD_FRIEND_STATE_REJECTED, glusterd_ac_friend_add},//EVENT_CONNECTED - {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none},//EVENT_MAX +glusterd_sm_t glusterd_state_req_sent_rcvd[] = { + {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, // EVENT_NONE, + {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, // EVENT_PROBE, + {GD_FRIEND_STATE_REQ_SENT_RCVD, + glusterd_ac_none}, // EVENT_INIT_FRIEND_REQ, + {GD_FRIEND_STATE_BEFRIENDED, + glusterd_ac_send_friend_update}, // EVENT_RCVD_ACC + {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, // EVENT_RCVD_LOCAL_ACC + {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, // EVENT_RCVD_RJT + {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, // EVENT_RCVD_LOCAL_RJT + {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, // EVENT_RCV_FRIEND_REQ + {GD_FRIEND_STATE_UNFRIEND_SENT, + glusterd_ac_send_friend_remove_req}, // EVENT_INIT_REMOVE_FRIEND, + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_handle_friend_remove_req}, // EVENT_RCVD_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_friend_remove}, // EVENT_REMOVE_FRIEND + {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, // EVENT_CONNECTED + {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, // EVENT_NEW_NAME + {GD_FRIEND_STATE_REQ_SENT_RCVD, glusterd_ac_none}, // EVENT_MAX }; -glusterd_sm_t glusterd_state_req_accepted [] = { - {GD_FRIEND_STATE_REQ_ACCEPTED, glusterd_ac_none}, //EVENT_NONE, - {GD_FRIEND_STATE_REQ_ACCEPTED, glusterd_ac_none}, //EVENT_PROBE, - {GD_FRIEND_STATE_REQ_ACCEPTED, glusterd_ac_none}, //EVENT_INIT_FRIEND_REQ, - {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_send_friend_update}, //EVENT_RCVD_ACC - {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_send_friend_update}, //EVENT_RCVD_LOCAL_ACC - {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, //EVENT_RCVD_RJT - {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, //EVENT_RCVD_LOCAL_RJT - {GD_FRIEND_STATE_REQ_ACCEPTED, glusterd_ac_handle_friend_add_req}, //EVENT_RCV_FRIEND_REQ - {GD_FRIEND_STATE_REQ_ACCEPTED, glusterd_ac_send_friend_remove_req}, //EVENT_INIT_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_handle_friend_remove_req}, //EVENT_RCVD_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_remove}, //EVENT_REMOVE_FRIEND - {GD_FRIEND_STATE_CONNECTED_ACCEPTED, glusterd_ac_reverse_probe_begin},//EVENT_CONNECTED - {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none},//EVENT_MAX +glusterd_sm_t glusterd_state_rejected[] = { + {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, // EVENT_NONE, + {GD_FRIEND_STATE_REJECTED, glusterd_ac_friend_probe}, // EVENT_PROBE, + {GD_FRIEND_STATE_REQ_SENT, + glusterd_ac_friend_add}, // EVENT_INIT_FRIEND_REQ, + {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_none}, // EVENT_RCVD_ACC + {GD_FRIEND_STATE_BEFRIENDED, glusterd_ac_none}, // EVENT_RCVD_LOCAL_ACC + {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, // EVENT_RCVD_RJT + {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, // EVENT_RCVD_LOCAL_RJT + {GD_FRIEND_STATE_REQ_RCVD, + glusterd_ac_handle_friend_add_req}, // EVENT_RCV_FRIEND_REQ + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_send_friend_remove_req}, // EVENT_INIT_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_handle_friend_remove_req}, // EVENT_RCVD_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_friend_remove}, // EVENT_REMOVE_FRIEND + {GD_FRIEND_STATE_REJECTED, glusterd_ac_friend_add}, // EVENT_CONNECTED + {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, // EVENT_NEW_NAME + {GD_FRIEND_STATE_REQ_RCVD, glusterd_ac_none}, // EVENT_MAX }; -glusterd_sm_t glusterd_state_unfriend_sent [] = { - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none}, //EVENT_NONE, - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_error}, //EVENT_PROBE, - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none}, //EVENT_INIT_FRIEND_REQ, - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none}, //EVENT_RCVD_ACC - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none}, //EVENT_RCVD_LOCAL_ACC - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_error}, //EVENT_RCVD_RJT - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_error}, //EVENT_RCVD_LOCAL_RJT - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_error}, //EVENT_RCV_FRIEND_REQ - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none}, //EVENT_INIT_REMOVE_FRIEND - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none}, //EVENT_RCVD_REMOVE_FRIEND - {GD_FRIEND_STATE_DEFAULT, glusterd_ac_friend_remove}, //EVENT_REMOVE_FRIEND - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none},//EVENT_CONNECTED - {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none},//EVENT_MAX +glusterd_sm_t glusterd_state_req_accepted[] = { + {GD_FRIEND_STATE_REQ_ACCEPTED, glusterd_ac_none}, // EVENT_NONE, + {GD_FRIEND_STATE_REQ_ACCEPTED, glusterd_ac_none}, // EVENT_PROBE, + {GD_FRIEND_STATE_REQ_ACCEPTED, glusterd_ac_none}, // EVENT_INIT_FRIEND_REQ, + {GD_FRIEND_STATE_BEFRIENDED, + glusterd_ac_send_friend_update}, // EVENT_RCVD_ACC + {GD_FRIEND_STATE_BEFRIENDED, + glusterd_ac_send_friend_update}, // EVENT_RCVD_LOCAL_ACC + {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, // EVENT_RCVD_RJT + {GD_FRIEND_STATE_REJECTED, glusterd_ac_none}, // EVENT_RCVD_LOCAL_RJT + {GD_FRIEND_STATE_REQ_ACCEPTED, + glusterd_ac_handle_friend_add_req}, // EVENT_RCV_FRIEND_REQ + {GD_FRIEND_STATE_REQ_ACCEPTED, + glusterd_ac_send_friend_remove_req}, // EVENT_INIT_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_handle_friend_remove_req}, // EVENT_RCVD_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_friend_remove}, // EVENT_REMOVE_FRIEND + {GD_FRIEND_STATE_CONNECTED_ACCEPTED, + glusterd_ac_reverse_probe_begin}, // EVENT_CONNECTED + {GD_FRIEND_STATE_REQ_ACCEPTED, glusterd_ac_none}, // EVENT_NEW_NAME + {GD_FRIEND_STATE_REQ_SENT, glusterd_ac_none}, // EVENT_MAX }; -glusterd_sm_t *glusterd_friend_state_table [] = { - glusterd_state_default, - glusterd_state_req_sent, - glusterd_state_req_rcvd, - glusterd_state_befriended, - glusterd_state_req_accepted, - glusterd_state_req_sent_rcvd, - glusterd_state_rejected, - glusterd_state_unfriend_sent, - glusterd_state_probe_rcvd, - glusterd_state_connected_rcvd, - glusterd_state_connected_accepted +glusterd_sm_t glusterd_state_unfriend_sent[] = { + {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none}, // EVENT_NONE, + {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_error}, // EVENT_PROBE, + {GD_FRIEND_STATE_UNFRIEND_SENT, + glusterd_ac_none}, // EVENT_INIT_FRIEND_REQ, + {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none}, // EVENT_RCVD_ACC + {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none}, // EVENT_RCVD_LOCAL_ACC + {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_error}, // EVENT_RCVD_RJT + {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_error}, // EVENT_RCVD_LOCAL_RJT + {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_error}, // EVENT_RCV_FRIEND_REQ + {GD_FRIEND_STATE_UNFRIEND_SENT, + glusterd_ac_none}, // EVENT_INIT_REMOVE_FRIEND + {GD_FRIEND_STATE_UNFRIEND_SENT, + glusterd_ac_none}, // EVENT_RCVD_REMOVE_FRIEND + {GD_FRIEND_STATE_DEFAULT, + glusterd_ac_friend_remove}, // EVENT_REMOVE_FRIEND + {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none}, // EVENT_CONNECTED + {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none}, // EVENT_NEW_NAME + {GD_FRIEND_STATE_UNFRIEND_SENT, glusterd_ac_none}, // EVENT_MAX }; +glusterd_sm_t *glusterd_friend_state_table[] = { + glusterd_state_default, glusterd_state_req_sent, + glusterd_state_req_rcvd, glusterd_state_befriended, + glusterd_state_req_accepted, glusterd_state_req_sent_rcvd, + glusterd_state_rejected, glusterd_state_unfriend_sent, + glusterd_state_probe_rcvd, glusterd_state_connected_rcvd, + glusterd_state_connected_accepted}; + int -glusterd_friend_sm_new_event (glusterd_friend_sm_event_type_t event_type, - glusterd_friend_sm_event_t **new_event) +glusterd_friend_sm_new_event(glusterd_friend_sm_event_type_t event_type, + glusterd_friend_sm_event_t **new_event) { - glusterd_friend_sm_event_t *event = NULL; + glusterd_friend_sm_event_t *event = NULL; - GF_ASSERT (new_event); - GF_ASSERT (GD_FRIEND_EVENT_NONE <= event_type && - GD_FRIEND_EVENT_MAX > event_type); + GF_ASSERT(new_event); + GF_ASSERT(GD_FRIEND_EVENT_NONE <= event_type && + GD_FRIEND_EVENT_MAX > event_type); - event = GF_CALLOC (1, sizeof (*event), gf_gld_mt_friend_sm_event_t); + event = GF_CALLOC(1, sizeof(*event), gf_gld_mt_friend_sm_event_t); - if (!event) - return -1; + if (!event) + return -1; - *new_event = event; - event->event = event_type; - INIT_LIST_HEAD (&event->list); + *new_event = event; + event->event = event_type; + CDS_INIT_LIST_HEAD(&event->list); - return 0; + return 0; } int -glusterd_friend_sm_inject_event (glusterd_friend_sm_event_t *event) +glusterd_friend_sm_inject_event(glusterd_friend_sm_event_t *event) { - GF_ASSERT (event); - gf_log ("glusterd", GF_LOG_DEBUG, "Enqueuing event: '%s'", - glusterd_friend_sm_event_name_get (event->event)); - list_add_tail (&event->list, &gd_friend_sm_queue); + GF_ASSERT(event); + gf_msg_debug("glusterd", 0, "Enqueue event: '%s'", + glusterd_friend_sm_event_name_get(event->event)); + cds_list_add_tail(&event->list, &gd_friend_sm_queue); - return 0; + return 0; } void -glusterd_destroy_friend_event_context (glusterd_friend_sm_event_t *event) +glusterd_destroy_friend_event_context(glusterd_friend_sm_event_t *event) { - if (!event) - return; + if (!event) + return; - switch (event->event) { + switch (event->event) { case GD_FRIEND_EVENT_RCVD_FRIEND_REQ: case GD_FRIEND_EVENT_RCVD_REMOVE_FRIEND: - glusterd_destroy_friend_req_ctx (event->ctx); - break; + glusterd_destroy_friend_req_ctx(event->ctx); + break; case GD_FRIEND_EVENT_LOCAL_ACC: case GD_FRIEND_EVENT_LOCAL_RJT: case GD_FRIEND_EVENT_RCVD_ACC: case GD_FRIEND_EVENT_RCVD_RJT: - glusterd_destroy_friend_update_ctx (event->ctx); - break; + glusterd_destroy_friend_update_ctx(event->ctx); + break; default: - break; - } + break; + } +} + +gf_boolean_t +gd_does_peer_affect_quorum(glusterd_friend_sm_state_t old_state, + glusterd_friend_sm_event_type_t event_type, + glusterd_peerinfo_t *peerinfo) +{ + gf_boolean_t affects = _gf_false; + + // When glusterd comes up with friends in BEFRIENDED state in store, + // wait until compare-data happens. + if ((old_state == GD_FRIEND_STATE_BEFRIENDED) && + (event_type != GD_FRIEND_EVENT_RCVD_ACC) && + (event_type != GD_FRIEND_EVENT_LOCAL_ACC)) + goto out; + if ((peerinfo->state.state == GD_FRIEND_STATE_BEFRIENDED) && + peerinfo->connected) { + affects = _gf_true; + } +out: + return affects; } int -glusterd_friend_sm () +glusterd_friend_sm() { - glusterd_friend_sm_event_t *event = NULL; - glusterd_friend_sm_event_t *tmp = NULL; - int ret = -1; - glusterd_friend_sm_ac_fn handler = NULL; - glusterd_sm_t *state = NULL; - glusterd_peerinfo_t *peerinfo = NULL; - glusterd_friend_sm_event_type_t event_type = 0; - gf_boolean_t is_await_conn = _gf_false; - - while (!list_empty (&gd_friend_sm_queue)) { - list_for_each_entry_safe (event, tmp, &gd_friend_sm_queue, list) { - - list_del_init (&event->list); - event_type = event->event; - peerinfo = event->peerinfo; - if (!peerinfo) { - gf_log ("glusterd", GF_LOG_CRITICAL, "Received" - " event %s with empty peer info", - glusterd_friend_sm_event_name_get (event_type)); - - GF_FREE (event); - continue; - } - gf_log ("", GF_LOG_DEBUG, "Dequeued event of type: '%s'", - glusterd_friend_sm_event_name_get (event_type)); - - - state = glusterd_friend_state_table[peerinfo->state.state]; - - GF_ASSERT (state); - - handler = state[event_type].handler; - GF_ASSERT (handler); - - ret = handler (event, event->ctx); - if (ret == GLUSTERD_CONNECTION_AWAITED) { - is_await_conn = _gf_true; - ret = 0; - } - - if (ret) { - gf_log ("glusterd", GF_LOG_ERROR, "handler returned: " - "%d", ret); - glusterd_destroy_friend_event_context (event); - GF_FREE (event); - continue; - } - - if ((GD_FRIEND_EVENT_REMOVE_FRIEND == event_type) || - (GD_FRIEND_EVENT_INIT_REMOVE_FRIEND == event_type)){ - glusterd_destroy_friend_event_context (event); - GF_FREE (event); - continue; - } - - ret = glusterd_friend_sm_transition_state (peerinfo, - state, event_type); - - if (ret) { - gf_log ("glusterd", GF_LOG_ERROR, "Unable to transition" - " state from '%s' to '%s' for event '%s'", - glusterd_friend_sm_state_name_get(peerinfo->state.state), - glusterd_friend_sm_state_name_get(state[event_type].next_state), - glusterd_friend_sm_event_name_get(event_type)); - goto out; - } - - ret = glusterd_store_peerinfo (peerinfo); - - glusterd_destroy_friend_event_context (event); - GF_FREE (event); - if (is_await_conn) - break; + glusterd_friend_sm_event_t *event = NULL; + glusterd_friend_sm_event_t *tmp = NULL; + int ret = -1; + glusterd_friend_sm_ac_fn handler = NULL; + glusterd_sm_t *state = NULL; + glusterd_peerinfo_t *peerinfo = NULL; + glusterd_friend_sm_event_type_t event_type = 0; + gf_boolean_t is_await_conn = _gf_false; + gf_boolean_t quorum_action = _gf_false; + glusterd_friend_sm_state_t old_state = GD_FRIEND_STATE_DEFAULT; + xlator_t *this = NULL; + glusterd_conf_t *priv = NULL; + + this = THIS; + GF_ASSERT(this); + priv = this->private; + GF_ASSERT(priv); + + while (!cds_list_empty(&gd_friend_sm_queue)) { + cds_list_for_each_entry_safe(event, tmp, &gd_friend_sm_queue, list) + { + cds_list_del_init(&event->list); + event_type = event->event; + + RCU_READ_LOCK; + + peerinfo = glusterd_peerinfo_find(event->peerid, event->peername); + if (!peerinfo) { + RCU_READ_UNLOCK; + gf_msg("glusterd", GF_LOG_CRITICAL, 0, GD_MSG_PEER_NOT_FOUND, + "Received" + " event %s with empty peer info", + glusterd_friend_sm_event_name_get(event_type)); + + GF_FREE(event); + continue; + } + old_state = peerinfo->state.state; + RCU_READ_UNLOCK; + gf_msg_debug("glusterd", 0, "Dequeued event of type: '%s'", + glusterd_friend_sm_event_name_get(event_type)); + + /* Giving up read-critical section here as we only need + * the current state to call the handler. + * + * We cannot continue into the handler in a read + * critical section as there are handlers who do + * updates, and could cause deadlocks. + */ + + state = glusterd_friend_state_table[old_state]; + + GF_ASSERT(state); + + handler = state[event_type].handler; + GF_ASSERT(handler); + + ret = handler(event, event->ctx); + if (ret == GLUSTERD_CONNECTION_AWAITED) { + is_await_conn = _gf_true; + ret = 0; + } + + if (ret) { + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_HANDLER_RETURNED, + "handler returned: " + "%d", + ret); + glusterd_destroy_friend_event_context(event); + GF_FREE(event); + continue; + } + + if ((GD_FRIEND_EVENT_REMOVE_FRIEND == event_type) || + (GD_FRIEND_EVENT_INIT_REMOVE_FRIEND == event_type)) { + glusterd_destroy_friend_event_context(event); + GF_FREE(event); + continue; + } + + ret = glusterd_friend_sm_transition_state( + event->peerid, event->peername, state, event_type); + + if (ret) { + gf_msg("glusterd", GF_LOG_ERROR, 0, + GD_MSG_EVENT_STATE_TRANSITION_FAIL, + "Unable to transition" + " state from '%s' to '%s' for event '%s'", + glusterd_friend_sm_state_name_get(old_state), + glusterd_friend_sm_state_name_get( + state[event_type].next_state), + glusterd_friend_sm_event_name_get(event_type)); + goto out; + } + + peerinfo = NULL; + /* We need to obtain peerinfo reference once again as we + * had exited the read critical section above. + */ + RCU_READ_LOCK; + peerinfo = glusterd_peerinfo_find(event->peerid, event->peername); + if (!peerinfo) { + RCU_READ_UNLOCK; + /* A peer can only be deleted as a effect of + * this state machine, and two such state + * machines can never run at the same time. + * So if we cannot find the peerinfo here, + * something has gone terribly wrong. + */ + ret = -1; + gf_msg("glusterd", GF_LOG_ERROR, 0, GD_MSG_PEER_NOT_FOUND, + "Cannot find peer %s(%s)", event->peername, + uuid_utoa(event->peerid)); + goto out; + } + if (gd_does_peer_affect_quorum(old_state, event_type, peerinfo)) { + peerinfo->quorum_contrib = QUORUM_UP; + if (peerinfo->quorum_action) { + peerinfo->quorum_action = _gf_false; + quorum_action = _gf_true; } - if (is_await_conn) - break; + } + + ret = glusterd_store_peerinfo(peerinfo); + RCU_READ_UNLOCK; + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_PEERINFO_CREATE_FAIL, + "Failed to store peerinfo"); + } + + glusterd_destroy_friend_event_context(event); + GF_FREE(event); + if (is_await_conn) + break; } + if (is_await_conn) + break; + } - ret = 0; + ret = 0; out: - return ret; + if (quorum_action) { + /* When glusterd is restarted, it needs to wait until the 'friends' view + * of the volumes settle, before it starts any of the internal daemons. + * + * Every friend that was part of the cluster, would send its + * cluster-view, 'our' way. For every friend, who belongs to + * a partition which has a different cluster-view from our + * partition, we may update our cluster-view. For subsequent + * friends from that partition would agree with us, if the first + * friend wasn't rejected. For every first friend, whom we agreed with, + * we would need to start internal daemons/bricks belonging to the + * new volumes. + * glusterd_spawn_daemons calls functions that are idempotent. ie, + * the functions spawn process(es) only if they are not started yet. + * + * */ + synclock_unlock(&priv->big_lock); + glusterd_launch_synctask(glusterd_spawn_daemons, NULL); + synclock_lock(&priv->big_lock); + glusterd_do_quorum_action(); + } + return ret; } - int -glusterd_friend_sm_init () +glusterd_friend_sm_init() { - INIT_LIST_HEAD (&gd_friend_sm_queue); - return 0; + CDS_INIT_LIST_HEAD(&gd_friend_sm_queue); + return 0; } |