[mirror_corosync-qdevice.git] / qdevices / qdevice-net-heuristics.c

/*
 * Copyright (c) 2017-2020 Red Hat, Inc.
 *
 * All rights reserved.
 *
 * Author: Jan Friesse (jfriesse@redhat.com)
 *
 * This software licensed under BSD license, the text of which follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * - Neither the name of the Red Hat, Inc. nor the names of its
 *   contributors may be used to endorse or promote products derived from this
 *   software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "log.h"
#include "qdevice-net-algorithm.h"
#include "qdevice-net-cast-vote-timer.h"
#include "qdevice-net-heuristics.h"
#include "qdevice-net-send.h"
#include "qdevice-net-votequorum.h"

enum tlv_heuristics
qdevice_net_heuristics_exec_result_to_tlv(enum qdevice_heuristics_exec_result exec_result)
{
	enum tlv_heuristics res;

	switch (exec_result) {
	case QDEVICE_HEURISTICS_EXEC_RESULT_DISABLED: res = TLV_HEURISTICS_UNDEFINED; break;
	case QDEVICE_HEURISTICS_EXEC_RESULT_PASS: res = TLV_HEURISTICS_PASS; break;
	case QDEVICE_HEURISTICS_EXEC_RESULT_FAIL: res = TLV_HEURISTICS_FAIL; break;
	default:
		log(LOG_ERR, "qdevice_net_heuristics_exec_result_to_tlv: Unhandled "
		    "heuristics exec result %s",
		    qdevice_heuristics_exec_result_to_str(exec_result));
		exit(EXIT_FAILURE);
		break;
	}

	return (res);
}

static int
qdevice_net_regular_heuristics_exec_result_callback(void *heuristics_instance_ptr,
    uint32_t seq_number, enum qdevice_heuristics_exec_result exec_result)
{
	struct qdevice_heuristics_instance *heuristics_instance;
	struct qdevice_instance *instance;
	struct qdevice_net_instance *net_instance;
	int send_msg;
	enum tlv_vote vote;
	enum tlv_heuristics heuristics;

	heuristics_instance = (struct qdevice_heuristics_instance *)heuristics_instance_ptr;
	instance = heuristics_instance->qdevice_instance_ptr;
	net_instance = instance->model_data;

	if (qdevice_heuristics_result_notifier_list_set_active(&heuristics_instance->exec_result_notifier_list,
	    qdevice_net_regular_heuristics_exec_result_callback, 0) != 0) {
		log(LOG_ERR, "Can't deactivate net regular heuristics exec callback notifier");

		net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ACTIVATE_HEURISTICS_RESULT_NOTIFIER;
		net_instance->schedule_disconnect = 1;

		return (0);
	}

	heuristics = qdevice_net_heuristics_exec_result_to_tlv(exec_result);

	if (exec_result == QDEVICE_HEURISTICS_EXEC_RESULT_DISABLED) {
		/*
		 * Can happen when user disables heuristics during runtime
		 */
		return (0);
	}

	if (net_instance->latest_heuristics_result != heuristics) {
		log(heuristics == TLV_HEURISTICS_PASS ? LOG_NOTICE : LOG_ERR,
		    "Heuristics result changed from %s to %s",
		    tlv_heuristics_to_str(net_instance->latest_heuristics_result),
		    tlv_heuristics_to_str(heuristics));

		if (net_instance->state != QDEVICE_NET_INSTANCE_STATE_WAITING_VOTEQUORUM_CMAP_EVENTS) {
			/*
			 * Not connected to qnetd
			 */
			send_msg = 0;
		} else {
			send_msg = 1;
		}

		vote = TLV_VOTE_NO_CHANGE;

		if (qdevice_net_algorithm_heuristics_change(net_instance, &heuristics, &send_msg,
		    &vote) == -1) {
			log(LOG_ERR, "Algorithm returned error. Disconnecting.");

			net_instance->disconnect_reason =
			    QDEVICE_NET_DISCONNECT_REASON_ALGO_HEURISTICS_CHANGE_ERR;
			net_instance->schedule_disconnect = 1;

			return (0);
		} else {
			log(LOG_DEBUG, "Algorithm decided to %s message with heuristics result "
			    "%s and result vote is %s", (send_msg ? "send" : "not send"),
			    tlv_heuristics_to_str(heuristics), tlv_vote_to_str(vote));
		}

		if (send_msg) {
			if (heuristics == TLV_HEURISTICS_UNDEFINED) {
				log(LOG_ERR, "Inconsistent algorithm result. "
				    "It's not possible to send message with undefined heuristics. "
				    "Disconnecting.");

				net_instance->disconnect_reason =
				    QDEVICE_NET_DISCONNECT_REASON_ALGO_HEURISTICS_CHANGE_ERR;
				net_instance->schedule_disconnect = 1;

				return (0);
			}

			if (!net_instance->server_supports_heuristics) {
				log(LOG_ERR, "Server doesn't support heuristics. "
				    "Disconnecting.");

				net_instance->disconnect_reason =
				    QDEVICE_NET_DISCONNECT_REASON_SERVER_DOESNT_SUPPORT_REQUIRED_OPT;
				net_instance->schedule_disconnect = 1;

				return (0);
			}

			if (qdevice_net_send_heuristics_change(net_instance, heuristics) != 0) {
				net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ALLOCATE_MSG_BUFFER;
				net_instance->schedule_disconnect = 1;

				return (0);
			}
		}

		if (qdevice_net_cast_vote_timer_update(net_instance, vote) != 0) {
			log(LOG_CRIT, "qdevice_net_heuristics_exec_result_callback "
			    "Can't update cast vote timer");

			net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_SCHEDULE_VOTING_TIMER;
			net_instance->schedule_disconnect = 1;

			return (0);
		}
	}

	net_instance->latest_regular_heuristics_result = heuristics;
	net_instance->latest_heuristics_result = heuristics;

	if (qdevice_net_heuristics_schedule_timer(net_instance) != 0) {
		return (0);
	}

	return (0);
}

static int
qdevice_net_connect_heuristics_exec_result_callback(void *heuristics_instance_ptr,
    uint32_t seq_number, enum qdevice_heuristics_exec_result exec_result)
{
	struct qdevice_heuristics_instance *heuristics_instance;
	struct qdevice_instance *instance;
	struct qdevice_net_instance *net_instance;
	enum tlv_vote vote;
	enum tlv_heuristics heuristics;
	int send_config_node_list;
	int send_membership_node_list;
	int send_quorum_node_list;
	struct tlv_ring_id tlv_rid;
	enum tlv_quorate quorate;

	heuristics_instance = (struct qdevice_heuristics_instance *)heuristics_instance_ptr;
	instance = heuristics_instance->qdevice_instance_ptr;
	net_instance = instance->model_data;


	if (qdevice_heuristics_result_notifier_list_set_active(&heuristics_instance->exec_result_notifier_list,
	    qdevice_net_connect_heuristics_exec_result_callback, 0) != 0) {
		log(LOG_ERR, "Can't deactivate net connect heuristics exec callback notifier");

		net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ACTIVATE_HEURISTICS_RESULT_NOTIFIER;
		net_instance->schedule_disconnect = 1;

		return (0);
	}

	heuristics = qdevice_net_heuristics_exec_result_to_tlv(exec_result);

	send_config_node_list = 1;
	send_membership_node_list = 1;
	send_quorum_node_list = 1;
	vote = TLV_VOTE_WAIT_FOR_REPLY;

	if (qdevice_net_algorithm_connected(net_instance, &heuristics, &send_config_node_list,
	    &send_membership_node_list, &send_quorum_node_list, &vote) != 0) {
		log(LOG_DEBUG, "Algorithm returned error. Disconnecting.");
		net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_ALGO_CONNECTED_ERR;
		return (0);
	} else {
		log(LOG_DEBUG, "Algorithm decided to %s config node list, %s membership "
		    "node list, %s quorum node list, heuristics is %s and result vote is %s",
		    (send_config_node_list ? "send" : "not send"),
		    (send_membership_node_list ? "send" : "not send"),
		    (send_quorum_node_list ? "send" : "not send"),
		    tlv_heuristics_to_str(heuristics),
		    tlv_vote_to_str(vote));
	}

	/*
	 * Now we can finally really send node list, votequorum node list and update timer
	 */
	if (send_config_node_list) {
		if (qdevice_net_send_config_node_list(net_instance,
		    &instance->config_node_list,
		    instance->config_node_list_version_set,
		    instance->config_node_list_version, 1) != 0) {
			net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ALLOCATE_MSG_BUFFER;
			return (0);
		}
	}

	if (send_membership_node_list) {
		qdevice_net_votequorum_ring_id_to_tlv(&tlv_rid,
		    &instance->vq_node_list_ring_id);

		if (qdevice_net_send_membership_node_list(net_instance, &tlv_rid,
		    instance->vq_node_list_entries,
		    instance->vq_node_list,
		    heuristics) != 0) {
			net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ALLOCATE_MSG_BUFFER;
			return (0);
		}
	}

	if (send_quorum_node_list) {
		quorate = (instance->vq_quorum_quorate ?
		    TLV_QUORATE_QUORATE : TLV_QUORATE_INQUORATE);

		if (qdevice_net_send_quorum_node_list(net_instance,
		    quorate,
		    instance->vq_quorum_node_list_entries,
		    instance->vq_quorum_node_list) != 0) {
			net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ALLOCATE_MSG_BUFFER;
			return (0);
		}
	}

	if (qdevice_net_cast_vote_timer_update(net_instance, vote) != 0) {
		log(LOG_CRIT, "qdevice_net_msg_received_set_option_reply fatal error. "
		    " Can't update cast vote timer vote");
		net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_SCHEDULE_VOTING_TIMER;
	}

	net_instance->state = QDEVICE_NET_INSTANCE_STATE_WAITING_VOTEQUORUM_CMAP_EVENTS;
	net_instance->connected_since_time = time(NULL);

	net_instance->latest_connect_heuristics_result = heuristics;
	net_instance->latest_heuristics_result = heuristics;

	return (0);
}

static int
qdevice_net_heuristics_timer_callback(void *data1, void *data2)
{
	struct qdevice_net_instance *net_instance;
	struct qdevice_heuristics_instance *heuristics_instance;

	net_instance = (struct qdevice_net_instance *)data1;
	heuristics_instance = &net_instance->qdevice_instance_ptr->heuristics_instance;

	if (qdevice_heuristics_waiting_for_result(heuristics_instance)) {
		log(LOG_DEBUG, "Not executing regular heuristics because other heuristics is already running.");

		return (1);
	}

	net_instance->regular_heuristics_timer = NULL;

	log(LOG_DEBUG, "Executing regular heuristics.");

	if (qdevice_heuristics_result_notifier_list_set_active(&heuristics_instance->exec_result_notifier_list,
	    qdevice_net_regular_heuristics_exec_result_callback, 1) != 0) {
		log(LOG_ERR, "Can't activate net regular heuristics exec callback notifier");

		net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ACTIVATE_HEURISTICS_RESULT_NOTIFIER;
		net_instance->schedule_disconnect = 1;

		return (0);
	}

	if (qdevice_heuristics_exec(heuristics_instance,
	    net_instance->qdevice_instance_ptr->sync_in_progress) != 0) {
		log(LOG_ERR, "Can't execute regular heuristics.");

		net_instance->schedule_disconnect = 1;
		net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_START_HEURISTICS;

		return (0);
	}

	/*
	 * Do not schedule this callback again. It's going to be scheduled in the
	 * qdevice_net_heuristics_exec_result_callback
	 */
	return (0);
}

int
qdevice_net_heuristics_stop_timer(struct qdevice_net_instance *net_instance)
{
	struct qdevice_instance *instance;
	struct qdevice_heuristics_instance *heuristics_instance;

	instance = net_instance->qdevice_instance_ptr;
	heuristics_instance = &instance->heuristics_instance;

	if (net_instance->regular_heuristics_timer != NULL) {
		log(LOG_DEBUG, "Regular heuristics timer stopped");

		timer_list_delete(&net_instance->main_timer_list, net_instance->regular_heuristics_timer);
		net_instance->regular_heuristics_timer = NULL;

		if (qdevice_heuristics_result_notifier_list_set_active(&heuristics_instance->exec_result_notifier_list,
		    qdevice_net_regular_heuristics_exec_result_callback, 0) != 0) {
			log(LOG_ERR, "Can't deactivate net regular heuristics exec callback notifier");

			net_instance->disconnect_reason =
			    QDEVICE_NET_DISCONNECT_REASON_CANT_ACTIVATE_HEURISTICS_RESULT_NOTIFIER;
			net_instance->schedule_disconnect = 1;
			return (-1);
		}
	}

	return (0);
}

int
qdevice_net_heuristics_schedule_timer(struct qdevice_net_instance *net_instance)
{
	uint32_t interval;
	struct qdevice_instance *instance;
	struct qdevice_heuristics_instance *heuristics_instance;

	instance = net_instance->qdevice_instance_ptr;
	heuristics_instance = &instance->heuristics_instance;

        if (heuristics_instance->mode != QDEVICE_HEURISTICS_MODE_ENABLED) {
		log(LOG_DEBUG, "Not scheduling heuristics timer because mode is not enabled");

		if (qdevice_net_heuristics_stop_timer(net_instance) != 0) {
			return (-1);
		}

		return (0);
        }

	if (net_instance->regular_heuristics_timer != NULL) {
		log(LOG_DEBUG, "Not scheduling heuristics timer because it is already scheduled");

		return (0);
	}

	interval = heuristics_instance->interval;

	log(LOG_DEBUG, "Scheduling next regular heuristics in %"PRIu32"ms", interval);

	net_instance->regular_heuristics_timer = timer_list_add(&net_instance->main_timer_list,
		interval,
		qdevice_net_heuristics_timer_callback,
	        (void *)net_instance, NULL);

	if (net_instance->regular_heuristics_timer == NULL) {
		log(LOG_ERR, "Can't schedule regular heuristics.");

		net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_SCHEDULE_HEURISTICS_TIMER;
		net_instance->schedule_disconnect = 1;
		return (-1);
	}

	return (0);
}

int
qdevice_net_heuristics_init(struct qdevice_net_instance *net_instance)
{

	if (qdevice_heuristics_result_notifier_list_add(
	    &net_instance->qdevice_instance_ptr->heuristics_instance.exec_result_notifier_list,
	    qdevice_net_regular_heuristics_exec_result_callback) == NULL) {
		log(LOG_ERR, "Can't add net regular heuristics exec callback into notifier");

		return (-1);
	}

	if (qdevice_heuristics_result_notifier_list_add(
	    &net_instance->qdevice_instance_ptr->heuristics_instance.exec_result_notifier_list,
	    qdevice_net_connect_heuristics_exec_result_callback) == NULL) {
		log(LOG_ERR, "Can't add net connect heuristics exec callback into notifier");

		return (-1);
	}

	return (0);
}

int
qdevice_net_heuristics_exec_after_connect(struct qdevice_net_instance *net_instance)
{
	struct qdevice_instance *instance;
	struct qdevice_heuristics_instance *heuristics_instance;

	instance = net_instance->qdevice_instance_ptr;
	heuristics_instance = &instance->heuristics_instance;

	log(LOG_DEBUG, "Executing after-connect heuristics.");

	if (qdevice_heuristics_result_notifier_list_set_active(&heuristics_instance->exec_result_notifier_list,
	    qdevice_net_connect_heuristics_exec_result_callback, 1) != 0) {
		log(LOG_ERR, "Can't activate net connect heuristics exec callback notifier");

		net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ACTIVATE_HEURISTICS_RESULT_NOTIFIER;
		net_instance->schedule_disconnect = 1;

		return (-1);
	}

	if (qdevice_heuristics_exec(heuristics_instance,
	    instance->sync_in_progress) != 0) {
		log(LOG_ERR, "Can't execute connect heuristics.");

		net_instance->schedule_disconnect = 1;
		net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_START_HEURISTICS;

		return (-1);
	}

	return (0);
}
Commit	Line	Data
9a1955a7	1	/*
406b689d	2	* Copyright (c) 2017-2020 Red Hat, Inc.
9a1955a7 JF	3	*
	4	* All rights reserved.
	5	*
	6	* Author: Jan Friesse (jfriesse@redhat.com)
	7	*
	8	* This software licensed under BSD license, the text of which follows:
	9	*
	10	* Redistribution and use in source and binary forms, with or without
	11	* modification, are permitted provided that the following conditions are met:
	12	*
	13	* - Redistributions of source code must retain the above copyright notice,
	14	* this list of conditions and the following disclaimer.
	15	* - Redistributions in binary form must reproduce the above copyright notice,
	16	* this list of conditions and the following disclaimer in the documentation
	17	* and/or other materials provided with the distribution.
	18	* - Neither the name of the Red Hat, Inc. nor the names of its
	19	* contributors may be used to endorse or promote products derived from this
	20	* software without specific prior written permission.
	21	*
	22	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	23	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	24	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	25	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	26	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	27	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	28	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	29	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	30	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	31	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
	32	* THE POSSIBILITY OF SUCH DAMAGE.
	33	*/
	34
313d42d1	35	#include "log.h"
9a1955a7 JF	36	#include "qdevice-net-algorithm.h"
	37	#include "qdevice-net-cast-vote-timer.h"
	38	#include "qdevice-net-heuristics.h"
	39	#include "qdevice-net-send.h"
	40	#include "qdevice-net-votequorum.h"
	41
	42	enum tlv_heuristics
	43	qdevice_net_heuristics_exec_result_to_tlv(enum qdevice_heuristics_exec_result exec_result)
	44	{
	45	enum tlv_heuristics res;
	46
	47	switch (exec_result) {
	48	case QDEVICE_HEURISTICS_EXEC_RESULT_DISABLED: res = TLV_HEURISTICS_UNDEFINED; break;
	49	case QDEVICE_HEURISTICS_EXEC_RESULT_PASS: res = TLV_HEURISTICS_PASS; break;
	50	case QDEVICE_HEURISTICS_EXEC_RESULT_FAIL: res = TLV_HEURISTICS_FAIL; break;
	51	default:
c8d19612	52	log(LOG_ERR, "qdevice_net_heuristics_exec_result_to_tlv: Unhandled "
9a1955a7 JF	53	"heuristics exec result %s",
9a1955a7 JF	54	qdevice_heuristics_exec_result_to_str(exec_result));
406b689d	55	exit(EXIT_FAILURE);
9a1955a7 JF	56	break;
	57	}
	58
	59	return (res);
	60	}
	61
	62	static int
	63	qdevice_net_regular_heuristics_exec_result_callback(void *heuristics_instance_ptr,
	64	uint32_t seq_number, enum qdevice_heuristics_exec_result exec_result)
	65	{
	66	struct qdevice_heuristics_instance *heuristics_instance;
	67	struct qdevice_instance *instance;
	68	struct qdevice_net_instance *net_instance;
	69	int send_msg;
	70	enum tlv_vote vote;
	71	enum tlv_heuristics heuristics;
	72
	73	heuristics_instance = (struct qdevice_heuristics_instance *)heuristics_instance_ptr;
	74	instance = heuristics_instance->qdevice_instance_ptr;
	75	net_instance = instance->model_data;
	76
	77	if (qdevice_heuristics_result_notifier_list_set_active(&heuristics_instance->exec_result_notifier_list,
	78	qdevice_net_regular_heuristics_exec_result_callback, 0) != 0) {
c8d19612	79	log(LOG_ERR, "Can't deactivate net regular heuristics exec callback notifier");
9a1955a7 JF	80
	81	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ACTIVATE_HEURISTICS_RESULT_NOTIFIER;
	82	net_instance->schedule_disconnect = 1;
	83
	84	return (0);
	85	}
	86
	87	heuristics = qdevice_net_heuristics_exec_result_to_tlv(exec_result);
	88
	89	if (exec_result == QDEVICE_HEURISTICS_EXEC_RESULT_DISABLED) {
	90	/*
	91	* Can happen when user disables heuristics during runtime
	92	*/
	93	return (0);
	94	}
	95
	96	if (net_instance->latest_heuristics_result != heuristics) {
5cb2ff57	97	log(heuristics == TLV_HEURISTICS_PASS ? LOG_NOTICE : LOG_ERR,
5cb2ff57	98	"Heuristics result changed from %s to %s",
9a1955a7 JF	99	tlv_heuristics_to_str(net_instance->latest_heuristics_result),
	100	tlv_heuristics_to_str(heuristics));
	101
	102	if (net_instance->state != QDEVICE_NET_INSTANCE_STATE_WAITING_VOTEQUORUM_CMAP_EVENTS) {
	103	/*
	104	* Not connected to qnetd
	105	*/
	106	send_msg = 0;
	107	} else {
	108	send_msg = 1;
	109	}
	110
	111	vote = TLV_VOTE_NO_CHANGE;
	112
	113	if (qdevice_net_algorithm_heuristics_change(net_instance, &heuristics, &send_msg,
	114	&vote) == -1) {
c8d19612	115	log(LOG_ERR, "Algorithm returned error. Disconnecting.");
9a1955a7 JF	116
	117	net_instance->disconnect_reason =
	118	QDEVICE_NET_DISCONNECT_REASON_ALGO_HEURISTICS_CHANGE_ERR;
	119	net_instance->schedule_disconnect = 1;
	120
	121	return (0);
	122	} else {
c8d19612	123	log(LOG_DEBUG, "Algorithm decided to %s message with heuristics result "
9a1955a7 JF	124	"%s and result vote is %s", (send_msg ? "send" : "not send"),
	125	tlv_heuristics_to_str(heuristics), tlv_vote_to_str(vote));
	126	}
	127
	128	if (send_msg) {
	129	if (heuristics == TLV_HEURISTICS_UNDEFINED) {
c8d19612	130	log(LOG_ERR, "Inconsistent algorithm result. "
9a1955a7 JF	131	"It's not possible to send message with undefined heuristics. "
	132	"Disconnecting.");
	133
	134	net_instance->disconnect_reason =
	135	QDEVICE_NET_DISCONNECT_REASON_ALGO_HEURISTICS_CHANGE_ERR;
	136	net_instance->schedule_disconnect = 1;
	137
	138	return (0);
	139	}
	140
	141	if (!net_instance->server_supports_heuristics) {
c8d19612	142	log(LOG_ERR, "Server doesn't support heuristics. "
9a1955a7 JF	143	"Disconnecting.");
	144
	145	net_instance->disconnect_reason =
	146	QDEVICE_NET_DISCONNECT_REASON_SERVER_DOESNT_SUPPORT_REQUIRED_OPT;
	147	net_instance->schedule_disconnect = 1;
	148
	149	return (0);
	150	}
	151
	152	if (qdevice_net_send_heuristics_change(net_instance, heuristics) != 0) {
	153	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ALLOCATE_MSG_BUFFER;
	154	net_instance->schedule_disconnect = 1;
	155
	156	return (0);
	157	}
	158	}
	159
	160	if (qdevice_net_cast_vote_timer_update(net_instance, vote) != 0) {
c8d19612	161	log(LOG_CRIT, "qdevice_net_heuristics_exec_result_callback "
9a1955a7 JF	162	"Can't update cast vote timer");
	163
	164	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_SCHEDULE_VOTING_TIMER;
	165	net_instance->schedule_disconnect = 1;
	166
	167	return (0);
	168	}
	169	}
	170
	171	net_instance->latest_regular_heuristics_result = heuristics;
	172	net_instance->latest_heuristics_result = heuristics;
	173
	174	if (qdevice_net_heuristics_schedule_timer(net_instance) != 0) {
	175	return (0);
	176	}
	177
	178	return (0);
	179	}
	180
	181	static int
	182	qdevice_net_connect_heuristics_exec_result_callback(void *heuristics_instance_ptr,
	183	uint32_t seq_number, enum qdevice_heuristics_exec_result exec_result)
	184	{
	185	struct qdevice_heuristics_instance *heuristics_instance;
	186	struct qdevice_instance *instance;
	187	struct qdevice_net_instance *net_instance;
	188	enum tlv_vote vote;
	189	enum tlv_heuristics heuristics;
	190	int send_config_node_list;
	191	int send_membership_node_list;
	192	int send_quorum_node_list;
	193	struct tlv_ring_id tlv_rid;
	194	enum tlv_quorate quorate;
	195
	196	heuristics_instance = (struct qdevice_heuristics_instance *)heuristics_instance_ptr;
	197	instance = heuristics_instance->qdevice_instance_ptr;
	198	net_instance = instance->model_data;
	199
	200
	201	if (qdevice_heuristics_result_notifier_list_set_active(&heuristics_instance->exec_result_notifier_list,
	202	qdevice_net_connect_heuristics_exec_result_callback, 0) != 0) {
c8d19612	203	log(LOG_ERR, "Can't deactivate net connect heuristics exec callback notifier");
9a1955a7 JF	204
	205	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ACTIVATE_HEURISTICS_RESULT_NOTIFIER;
	206	net_instance->schedule_disconnect = 1;
	207
	208	return (0);
	209	}
	210
	211	heuristics = qdevice_net_heuristics_exec_result_to_tlv(exec_result);
	212
	213	send_config_node_list = 1;
	214	send_membership_node_list = 1;
	215	send_quorum_node_list = 1;
	216	vote = TLV_VOTE_WAIT_FOR_REPLY;
	217
	218	if (qdevice_net_algorithm_connected(net_instance, &heuristics, &send_config_node_list,
	219	&send_membership_node_list, &send_quorum_node_list, &vote) != 0) {
c8d19612	220	log(LOG_DEBUG, "Algorithm returned error. Disconnecting.");
9a1955a7 JF	221	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_ALGO_CONNECTED_ERR;
	222	return (0);
	223	} else {
c8d19612	224	log(LOG_DEBUG, "Algorithm decided to %s config node list, %s membership "
9a1955a7 JF	225	"node list, %s quorum node list, heuristics is %s and result vote is %s",
	226	(send_config_node_list ? "send" : "not send"),
	227	(send_membership_node_list ? "send" : "not send"),
	228	(send_quorum_node_list ? "send" : "not send"),
	229	tlv_heuristics_to_str(heuristics),
	230	tlv_vote_to_str(vote));
	231	}
	232
	233	/*
	234	* Now we can finally really send node list, votequorum node list and update timer
	235	*/
	236	if (send_config_node_list) {
	237	if (qdevice_net_send_config_node_list(net_instance,
	238	&instance->config_node_list,
	239	instance->config_node_list_version_set,
	240	instance->config_node_list_version, 1) != 0) {
	241	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ALLOCATE_MSG_BUFFER;
	242	return (0);
	243	}
	244	}
	245
	246	if (send_membership_node_list) {
	247	qdevice_net_votequorum_ring_id_to_tlv(&tlv_rid,
	248	&instance->vq_node_list_ring_id);
	249
	250	if (qdevice_net_send_membership_node_list(net_instance, &tlv_rid,
	251	instance->vq_node_list_entries,
	252	instance->vq_node_list,
	253	heuristics) != 0) {
	254	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ALLOCATE_MSG_BUFFER;
	255	return (0);
	256	}
	257	}
	258
	259	if (send_quorum_node_list) {
	260	quorate = (instance->vq_quorum_quorate ?
	261	TLV_QUORATE_QUORATE : TLV_QUORATE_INQUORATE);
	262
	263	if (qdevice_net_send_quorum_node_list(net_instance,
	264	quorate,
	265	instance->vq_quorum_node_list_entries,
	266	instance->vq_quorum_node_list) != 0) {
	267	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ALLOCATE_MSG_BUFFER;
	268	return (0);
	269	}
	270	}
	271
	272	if (qdevice_net_cast_vote_timer_update(net_instance, vote) != 0) {
c8d19612	273	log(LOG_CRIT, "qdevice_net_msg_received_set_option_reply fatal error. "
9a1955a7 JF	274	" Can't update cast vote timer vote");
	275	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_SCHEDULE_VOTING_TIMER;
	276	}
	277
	278	net_instance->state = QDEVICE_NET_INSTANCE_STATE_WAITING_VOTEQUORUM_CMAP_EVENTS;
	279	net_instance->connected_since_time = time(NULL);
	280
	281	net_instance->latest_connect_heuristics_result = heuristics;
	282	net_instance->latest_heuristics_result = heuristics;
	283
	284	return (0);
	285	}
	286
	287	static int
	288	qdevice_net_heuristics_timer_callback(void data1, void data2)
	289	{
	290	struct qdevice_net_instance *net_instance;
	291	struct qdevice_heuristics_instance *heuristics_instance;
	292
	293	net_instance = (struct qdevice_net_instance *)data1;
	294	heuristics_instance = &net_instance->qdevice_instance_ptr->heuristics_instance;
	295
	296	if (qdevice_heuristics_waiting_for_result(heuristics_instance)) {
c8d19612	297	log(LOG_DEBUG, "Not executing regular heuristics because other heuristics is already running.");
9a1955a7 JF	298
	299	return (1);
	300	}
	301
	302	net_instance->regular_heuristics_timer = NULL;
	303
c8d19612	304	log(LOG_DEBUG, "Executing regular heuristics.");
9a1955a7 JF	305
	306	if (qdevice_heuristics_result_notifier_list_set_active(&heuristics_instance->exec_result_notifier_list,
	307	qdevice_net_regular_heuristics_exec_result_callback, 1) != 0) {
c8d19612	308	log(LOG_ERR, "Can't activate net regular heuristics exec callback notifier");
9a1955a7 JF	309
	310	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ACTIVATE_HEURISTICS_RESULT_NOTIFIER;
	311	net_instance->schedule_disconnect = 1;
	312
	313	return (0);
	314	}
	315
	316	if (qdevice_heuristics_exec(heuristics_instance,
	317	net_instance->qdevice_instance_ptr->sync_in_progress) != 0) {
c8d19612	318	log(LOG_ERR, "Can't execute regular heuristics.");
9a1955a7 JF	319
	320	net_instance->schedule_disconnect = 1;
	321	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_START_HEURISTICS;
	322
	323	return (0);
	324	}
	325
	326	/*
	327	* Do not schedule this callback again. It's going to be scheduled in the
	328	* qdevice_net_heuristics_exec_result_callback
	329	*/
	330	return (0);
	331	}
	332
	333	int
	334	qdevice_net_heuristics_stop_timer(struct qdevice_net_instance *net_instance)
	335	{
	336	struct qdevice_instance *instance;
	337	struct qdevice_heuristics_instance *heuristics_instance;
	338
	339	instance = net_instance->qdevice_instance_ptr;
	340	heuristics_instance = &instance->heuristics_instance;
	341
	342	if (net_instance->regular_heuristics_timer != NULL) {
c8d19612	343	log(LOG_DEBUG, "Regular heuristics timer stopped");
9a1955a7 JF	344
	345	timer_list_delete(&net_instance->main_timer_list, net_instance->regular_heuristics_timer);
	346	net_instance->regular_heuristics_timer = NULL;
	347
	348	if (qdevice_heuristics_result_notifier_list_set_active(&heuristics_instance->exec_result_notifier_list,
	349	qdevice_net_regular_heuristics_exec_result_callback, 0) != 0) {
c8d19612	350	log(LOG_ERR, "Can't deactivate net regular heuristics exec callback notifier");
9a1955a7 JF	351
	352	net_instance->disconnect_reason =
	353	QDEVICE_NET_DISCONNECT_REASON_CANT_ACTIVATE_HEURISTICS_RESULT_NOTIFIER;
	354	net_instance->schedule_disconnect = 1;
	355	return (-1);
	356	}
	357	}
	358
	359	return (0);
	360	}
	361
	362	int
	363	qdevice_net_heuristics_schedule_timer(struct qdevice_net_instance *net_instance)
	364	{
	365	uint32_t interval;
	366	struct qdevice_instance *instance;
	367	struct qdevice_heuristics_instance *heuristics_instance;
	368
	369	instance = net_instance->qdevice_instance_ptr;
	370	heuristics_instance = &instance->heuristics_instance;
	371
	372	if (heuristics_instance->mode != QDEVICE_HEURISTICS_MODE_ENABLED) {
c8d19612	373	log(LOG_DEBUG, "Not scheduling heuristics timer because mode is not enabled");
9a1955a7 JF	374
	375	if (qdevice_net_heuristics_stop_timer(net_instance) != 0) {
	376	return (-1);
	377	}
	378
	379	return (0);
	380	}
	381
	382	if (net_instance->regular_heuristics_timer != NULL) {
c8d19612	383	log(LOG_DEBUG, "Not scheduling heuristics timer because it is already scheduled");
9a1955a7 JF	384
	385	return (0);
	386	}
	387
	388	interval = heuristics_instance->interval;
	389
c8d19612	390	log(LOG_DEBUG, "Scheduling next regular heuristics in %"PRIu32"ms", interval);
9a1955a7 JF	391
	392	net_instance->regular_heuristics_timer = timer_list_add(&net_instance->main_timer_list,
	393	interval,
	394	qdevice_net_heuristics_timer_callback,
	395	(void *)net_instance, NULL);
	396
	397	if (net_instance->regular_heuristics_timer == NULL) {
c8d19612	398	log(LOG_ERR, "Can't schedule regular heuristics.");
9a1955a7 JF	399
	400	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_SCHEDULE_HEURISTICS_TIMER;
	401	net_instance->schedule_disconnect = 1;
	402	return (-1);
	403	}
	404
	405	return (0);
	406	}
	407
	408	int
	409	qdevice_net_heuristics_init(struct qdevice_net_instance *net_instance)
	410	{
	411
	412	if (qdevice_heuristics_result_notifier_list_add(
	413	&net_instance->qdevice_instance_ptr->heuristics_instance.exec_result_notifier_list,
	414	qdevice_net_regular_heuristics_exec_result_callback) == NULL) {
c8d19612	415	log(LOG_ERR, "Can't add net regular heuristics exec callback into notifier");
9a1955a7 JF	416
	417	return (-1);
	418	}
	419
	420	if (qdevice_heuristics_result_notifier_list_add(
	421	&net_instance->qdevice_instance_ptr->heuristics_instance.exec_result_notifier_list,
	422	qdevice_net_connect_heuristics_exec_result_callback) == NULL) {
c8d19612	423	log(LOG_ERR, "Can't add net connect heuristics exec callback into notifier");
9a1955a7 JF	424
	425	return (-1);
	426	}
	427
	428	return (0);
	429	}
	430
	431	int
	432	qdevice_net_heuristics_exec_after_connect(struct qdevice_net_instance *net_instance)
	433	{
	434	struct qdevice_instance *instance;
	435	struct qdevice_heuristics_instance *heuristics_instance;
	436
	437	instance = net_instance->qdevice_instance_ptr;
	438	heuristics_instance = &instance->heuristics_instance;
	439
c8d19612	440	log(LOG_DEBUG, "Executing after-connect heuristics.");
9a1955a7 JF	441
	442	if (qdevice_heuristics_result_notifier_list_set_active(&heuristics_instance->exec_result_notifier_list,
	443	qdevice_net_connect_heuristics_exec_result_callback, 1) != 0) {
c8d19612	444	log(LOG_ERR, "Can't activate net connect heuristics exec callback notifier");
9a1955a7 JF	445
	446	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_ACTIVATE_HEURISTICS_RESULT_NOTIFIER;
	447	net_instance->schedule_disconnect = 1;
	448
	449	return (-1);
	450	}
	451
	452	if (qdevice_heuristics_exec(heuristics_instance,
	453	instance->sync_in_progress) != 0) {
c8d19612	454	log(LOG_ERR, "Can't execute connect heuristics.");
9a1955a7 JF	455
	456	net_instance->schedule_disconnect = 1;
	457	net_instance->disconnect_reason = QDEVICE_NET_DISCONNECT_REASON_CANT_START_HEURISTICS;
	458
	459	return (-1);
	460	}
	461
	462	return (0);
	463	}