entrypoint_fops.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_ENTRYPOINT_FOPS_H__
#define __MOTR_HA_ENTRYPOINT_FOPS_H__

#include "xcode/xcode_attr.h"   /* M0_XCA_RECORD */

#include "lib/types.h"          /* int32_t */
#include "lib/buf.h"            /* m0_buf */
#include "fid/fid.h"            /* m0_fid */
#include "ha/link_fops.h"       /* m0_ha_link_parameters */
#include "ha/cookie.h"          /* m0_ha_cookie */

/*
 * The following includes are needed only for entrypoint_fops_xc.h compilation.
 */
#include "lib/buf_xc.h"         /* m0_buf_xc */
#include "lib/types_xc.h"       /* m0_uint128_xc */
#include "fid/fid_xc.h"         /* m0_fid_xc */
#include "ha/link_fops_xc.h"    /* m0_ha_link_parameters_xc */
#include "ha/cookie_xc.h"       /* m0_ha_cookie_xc_xc */

enum m0_ha_entrypoint_control {
        M0_HA_ENTRYPOINT_CONSUME,      
        M0_HA_ENTRYPOINT_QUIT,         
        M0_HA_ENTRYPOINT_QUERY,        
#if 0   /*
         * XXX: Possible way to introduce explicit delay. The entry implies the
         * value to be transformed to M0_HA_ENTRYPOINT_QUERY immediately in the
         * interface API m0_halon_interface_entrypoint_reply() along with
         * setting delay value correspondingly.
         */
        M0_HA_ENTRYPOINT_QUERY_1SEC,   
        /*
         * Other ways to introduce the delay between HA client queries:
         * - add explicit delay_ns parameter to the Halon interface API
         *   m0_halon_interface_entrypoint_reply(), or
         * - synthesize delay value on HA client side based on some policy
         *   (predefined constant, or algorithmic, or statistics-based), or
         * - transform control values like M0_HA_ENTRYPOINT_QUERY_1SEC to
         *   M0_HA_ENTRYPOINT_QUERY and delay on HA client side.
         */
#endif
};

struct m0_ha_entrypoint_rep_fop {
        uint32_t                 hbp_quorum;
        struct m0_fid_arr        hbp_confd_fids;
        struct m0_bufs           hbp_confd_eps;
        struct m0_fid            hbp_active_rm_fid;
        struct m0_buf            hbp_active_rm_ep;

        uint32_t                 hbp_control;

        /* link parameters */
        struct m0_ha_link_params hbp_link_params;
        uint64_t                 hbp_link_do_reconnect;

        /*
         * If it is set then the link has been disconnected some time ago.
         * There is no way to re-establish the link and the process that has
         * sent the entrypoint request has to be restarted.
         */
        uint32_t                 hbp_disconnected_previously;

        /* A cookie to check if entrypoint server is still the same */
        struct m0_ha_cookie_xc   hbp_cookie_actual;
} M0_XCA_RECORD M0_XCA_DOMAIN(rpc);

struct m0_ha_entrypoint_req_fop {
        int32_t                  erf_first_request;
        uint64_t                 erf_generation;
        struct m0_fid            erf_process_fid;
        struct m0_ha_link_params erf_link_params;
        struct m0_buf            erf_git_rev_id;
        uint64_t                 erf_pid;
        struct m0_ha_cookie_xc   erf_cookie_expected;
} M0_XCA_RECORD M0_XCA_DOMAIN(rpc);

struct m0_ha_entrypoint_req {
        bool                      heq_first_request;
        uint64_t                  heq_generation;
        char                     *heq_rpc_endpoint;
        struct m0_fid             heq_process_fid;
        struct m0_ha_link_params  heq_link_params;
        /* m0_build_info::bi_git_rev_id */
        const char               *heq_git_rev_id;
        uint64_t                  heq_pid;
        struct m0_ha_cookie       heq_cookie_expected;
};

struct m0_ha_entrypoint_rep {
        uint32_t                        hae_quorum;
        struct m0_fid_arr               hae_confd_fids;
        const char                    **hae_confd_eps;
        struct m0_fid                   hae_active_rm_fid;
        char                           *hae_active_rm_ep;
        enum m0_ha_entrypoint_control   hae_control;
        /* link parameters */
        struct m0_ha_link_params        hae_link_params;
        bool                            hae_link_do_reconnect;
        bool                            hae_disconnected_previously;
        struct m0_ha_cookie             hae_cookie_actual;
};

extern struct m0_fop_type m0_ha_entrypoint_req_fopt;
extern struct m0_fop_type m0_ha_entrypoint_rep_fopt;

M0_INTERNAL void m0_ha_entrypoint_fops_init(void);
M0_INTERNAL void m0_ha_entrypoint_fops_fini(void);


M0_INTERNAL int
m0_ha_entrypoint_req2fop(const struct m0_ha_entrypoint_req *req,
                         struct m0_ha_entrypoint_req_fop   *req_fop);
M0_INTERNAL int
m0_ha_entrypoint_fop2req(const struct m0_ha_entrypoint_req_fop *req_fop,
                         const char                            *rpc_endpoint,
                         struct m0_ha_entrypoint_req           *req);

M0_INTERNAL int
m0_ha_entrypoint_fop2rep(const struct m0_ha_entrypoint_rep_fop *rep_fop,
                         struct m0_ha_entrypoint_rep           *rep);
M0_INTERNAL int
m0_ha_entrypoint_rep2fop(const struct m0_ha_entrypoint_rep *rep,
                         struct m0_ha_entrypoint_rep_fop   *rep_fop);

M0_INTERNAL void m0_ha_entrypoint_rep_free(struct m0_ha_entrypoint_rep *rep);
M0_INTERNAL void m0_ha_entrypoint_req_free(struct m0_ha_entrypoint_req *req);
M0_INTERNAL int  m0_ha_entrypoint_rep_copy(struct m0_ha_entrypoint_rep *to,
                                           struct m0_ha_entrypoint_rep *from);

#endif /* __MOTR_HA_ENTRYPOINT_FOPS_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
 */