link.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2016-2020 Seagate Technology LLC and/or its Affiliates
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * For any questions about this software or licensing,
 * please email opensource@seagate.com or cortx-questions@seagate.com.
 *
 */


#pragma once

#ifndef __MOTR_HA_LINK_H__
#define __MOTR_HA_LINK_H__

#include "lib/chan.h"           /* m0_chan */
#include "lib/types.h"          /* bool */
#include "lib/tlist.h"          /* m0_tlink */
#include "lib/semaphore.h"      /* m0_semaphore */
#include "lib/time.h"           /* m0_time_t */

#include "sm/sm.h"              /* m0_sm */
#include "fop/fom.h"            /* m0_fom */
#include "fop/fop.h"            /* m0_fop */
#include "rpc/link.h"           /* m0_rpc_link */

#include "ha/link_fops.h"       /* m0_ha_link_params */
#include "ha/lq.h"              /* m0_ha_lq */


struct m0_reqh;
struct m0_reqh_service;
struct m0_rpc_machine;
struct m0_locality;
struct m0_ha_link_msg_fop;
struct m0_ha_msg;
struct m0_rpc_session;

enum m0_ha_link_state {
        M0_HA_LINK_STATE_INIT,
        M0_HA_LINK_STATE_FINI,
        M0_HA_LINK_STATE_START,
        M0_HA_LINK_STATE_STOP,
        M0_HA_LINK_STATE_IDLE,
        M0_HA_LINK_STATE_RECV,
        M0_HA_LINK_STATE_DELIVERY,
        M0_HA_LINK_STATE_RPC_FAILED,
        M0_HA_LINK_STATE_LINK_FAILED,
        M0_HA_LINK_STATE_LINK_REUSED,
        M0_HA_LINK_STATE_DISCONNECTING,
        M0_HA_LINK_STATE_NR,
};

struct m0_ha_link_conn_cfg {
        struct m0_ha_link_params  hlcc_params;
        struct m0_fid             hlcc_rpc_service_fid;
        const char               *hlcc_rpc_endpoint;
        uint64_t                  hlcc_max_rpcs_in_flight;
        m0_time_t                 hlcc_connect_timeout;
        m0_time_t                 hlcc_disconnect_timeout;
        m0_time_t                 hlcc_resend_interval;
        m0_time_t                 hlcc_reconnect_interval;
        uint64_t                  hlcc_nr_sent_max;
};

struct m0_ha_link_cfg {
        struct m0_reqh         *hlc_reqh;
        struct m0_reqh_service *hlc_reqh_service;
        struct m0_rpc_machine  *hlc_rpc_machine;
        struct m0_ha_lq_cfg     hlq_q_cfg_in;
        struct m0_ha_lq_cfg     hlq_q_cfg_out;
};

struct m0_ha_link {
        struct m0_ha_link_cfg       hln_cfg;
        struct m0_ha_link_conn_cfg  hln_conn_cfg;
        struct m0_ha_link_conn_cfg  hln_conn_reconnect_cfg;
        struct m0_rpc_link          hln_rpc_link;
        struct m0_tlink             hln_service_link;
        uint64_t                    hln_service_magic;
        struct m0_mutex             hln_lock;
        struct m0_sm_group          hln_sm_group;
        struct m0_sm                hln_sm;
        struct m0_ha_lq             hln_q_in;
        struct m0_ha_lq             hln_q_out;
        struct m0_fom               hln_fom;
        struct m0_locality         *hln_fom_locality;
        bool                        hln_fom_is_stopping;
        bool                        hln_fom_enable_wakeup;
        struct m0_semaphore         hln_start_wait;
        struct m0_semaphore         hln_stop_cond;
        struct m0_chan              hln_stop_chan;
        struct m0_mutex             hln_stop_chan_lock;
        bool                        hln_waking_up;
        struct m0_sm_ast            hln_waking_ast;
        struct m0_ha_msg           *hln_msg_to_send;
        bool                        hln_confirmed_update;
        struct m0_fop               hln_outgoing_fop;
        struct m0_ha_link_msg_fop   hln_req_fop_data;
        uint64_t                    hln_req_fop_seq;
        bool                        hln_replied;
        bool                        hln_released;
        struct m0_clink             hln_rpc_wait;
        bool                        hln_rpc_event_occurred;
        bool                        hln_reconnect;
        bool                        hln_reconnect_cfg_is_set;
        bool                        hln_reconnect_wait;
        struct m0_sm_timer          hln_reconnect_wait_timer;
        int                         hln_rpc_rc;
        int                         hln_reply_rc;
        bool                        hln_no_new_delivered;
        uint64_t                    hln_tag_broadcast_recv;
        uint64_t                    hln_tag_broadcast_delivery;
        struct m0_mutex             hln_quiesce_chan_lock;
        struct m0_chan              hln_quiesce_chan;
        struct m0_clink             hln_quiesce_wait;
        bool                        hln_quiesced;
        bool                        hln_cb_disconnecting;
        bool                        hln_cb_reused;

        /* Exponential backoff algorithm state. Protected by ::hln_lock */
        int                         hln_backoff_rc;
        uint64_t                    hln_backoff_nr;

        /* These fields are owned by m0_ha_link_service */
        uint64_t                    hln_service_ref_counter;
        struct m0_uint128           hln_service_link_id;
        struct m0_uint128           hln_service_connection_id;
        struct m0_chan             *hln_service_release_chan;
        bool                        hln_service_quiescing;
        bool                        hln_service_released;
};

M0_INTERNAL int  m0_ha_link_init (struct m0_ha_link     *hl,
                                  struct m0_ha_link_cfg *hl_cfg);
M0_INTERNAL void m0_ha_link_fini (struct m0_ha_link *hl);
M0_INTERNAL void m0_ha_link_start(struct m0_ha_link          *hl,
                                  struct m0_ha_link_conn_cfg *hl_conn_cfg);
M0_INTERNAL void m0_ha_link_stop(struct m0_ha_link *hl, struct m0_clink *clink);

M0_INTERNAL void m0_ha_link_reconnect_begin(struct m0_ha_link        *hl,
                                            struct m0_ha_link_params *lp);
M0_INTERNAL void
m0_ha_link_reconnect_end(struct m0_ha_link                *hl,
                         const struct m0_ha_link_conn_cfg *hl_conn_cfg);
M0_INTERNAL void m0_ha_link_reconnect_cancel(struct m0_ha_link *hl);
M0_INTERNAL void
m0_ha_link_reconnect_params(const struct m0_ha_link_params *lp_alive,
                            struct m0_ha_link_params       *lp_alive_new,
                            struct m0_ha_link_params       *lp_dead_new,
                            const struct m0_uint128        *id_alive,
                            const struct m0_uint128        *id_dead,
                            const struct m0_uint128        *id_connection);

M0_INTERNAL struct m0_chan *m0_ha_link_chan(struct m0_ha_link *hl);
M0_INTERNAL enum m0_ha_link_state m0_ha_link_state_get(struct m0_ha_link *hl);
M0_INTERNAL const char *m0_ha_link_state_name(enum m0_ha_link_state state);

M0_INTERNAL void m0_ha_link_send(struct m0_ha_link      *hl,
                                 const struct m0_ha_msg *msg,
                                 uint64_t               *tag);
M0_INTERNAL struct m0_ha_msg *m0_ha_link_recv(struct m0_ha_link *hl,
                                              uint64_t          *tag);

M0_INTERNAL void m0_ha_link_delivered(struct m0_ha_link *hl,
                                      struct m0_ha_msg  *msg);
M0_INTERNAL bool m0_ha_link_msg_is_delivered(struct m0_ha_link *hl,
                                             uint64_t           tag);
M0_INTERNAL uint64_t m0_ha_link_delivered_consume(struct m0_ha_link *hl);
M0_INTERNAL uint64_t m0_ha_link_not_delivered_consume(struct m0_ha_link *hl);

M0_INTERNAL void m0_ha_link_wait_delivery(struct m0_ha_link *hl,
                                          uint64_t           tag);
M0_INTERNAL void m0_ha_link_wait_arrival(struct m0_ha_link *hl);
M0_INTERNAL void m0_ha_link_wait_confirmation(struct m0_ha_link *hl,
                                              uint64_t           tag);

M0_INTERNAL void m0_ha_link_flush(struct m0_ha_link *hl);
M0_INTERNAL void m0_ha_link_quiesce(struct m0_ha_link *hl);

M0_INTERNAL void m0_ha_link_cb_disconnecting(struct m0_ha_link *hl);
M0_INTERNAL void m0_ha_link_cb_reused(struct m0_ha_link *hl);

M0_INTERNAL struct m0_rpc_session *
m0_ha_link_rpc_session(struct m0_ha_link *hl);

M0_INTERNAL void m0_ha_link_rpc_endpoint(struct m0_ha_link *hl,
                                         char              *buf,
                                         m0_bcount_t        buf_len);

M0_INTERNAL int  m0_ha_link_mod_init(void);
M0_INTERNAL void m0_ha_link_mod_fini(void);

/* XXX move to internal */
extern const struct m0_fom_type_ops m0_ha_link_incoming_fom_type_ops;
extern const struct m0_fom_type_ops m0_ha_link_outgoing_fom_type_ops;

#endif /* __MOTR_HA_LINK_H__ */

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */
/*
 * vim: tabstop=8 shiftwidth=8 noexpandtab textwidth=80 nowrap
 */