proxy.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2012-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_CM_PROXY_H__
#define __MOTR_CM_PROXY_H__

#include "lib/chan.h"

#include "fop/fom_simple.h"
#include "rpc/conn.h"
#include "rpc/session.h"
#include "sm/sm.h"
#include "conf/obj.h"

#include "cm/sw.h"
#include "cm/ag.h"

struct m0_cm_cp;

enum m0_proxy_state {
        M0_PX_INIT,     /* 0 */
        M0_PX_READY,    /* 1 */
        M0_PX_ACTIVE,   /* 2 */
        M0_PX_COMPLETE, /* 3 */
        M0_PX_STOP,     /* 4 */
        M0_PX_FAILED    /* 5 */
};

struct m0_cm_proxy {
        uint64_t                px_id;

        m0_time_t               px_epoch;

        struct m0_cm_sw         px_sw;

        struct m0_cm_sw         px_last_sw_onwire_sent;

        struct m0_cm_sw         px_out_interval;

        struct m0_cm_ag_id      px_last_out_sent;

        struct m0_sm_ast        px_sw_onwire_ast;

        struct m0_sm_ast        px_fail_ast;

        struct m0_sm_ast        px_online_ast;

        enum m0_proxy_state     px_status;

        bool                    px_is_done;

        uint64_t                px_nr_updates_posted;

        int                     px_update_rc;

        uint32_t                px_updates_pending;

        struct m0_cm           *px_cm;

        struct m0_tl            px_pending_cps;

        struct m0_mutex         px_mutex;

        struct m0_rpc_conn     *px_conn;

        struct m0_rpc_session  *px_session;

        const char             *px_endpoint;

        struct m0_tlink        px_linkage;

        struct m0_tlink        px_fail_linkage;

        struct m0_clink        px_ha_link;

        bool                   px_send_final_update;

        uint64_t               px_magic;
};

struct m0_cm_proxy_in_count {
        uint32_t  p_nr;
        uint32_t *p_count;
};

struct m0_cm_proxy_sw_onwire {
        struct m0_fop       pso_fop;
        struct m0_cm_proxy *pso_proxy;
};

M0_INTERNAL int m0_cm_proxy_init(struct m0_cm_proxy *pxy, uint64_t px_id,
                                 struct m0_cm_ag_id *lo, struct m0_cm_ag_id *hi,
                                 const char *endpoint);

M0_INTERNAL void m0_cm_proxy_add(struct m0_cm *cm, struct m0_cm_proxy *pxy);

M0_INTERNAL void m0_cm_proxy_del(struct m0_cm *cm, struct m0_cm_proxy *pxy);

M0_INTERNAL struct m0_cm_proxy *m0_cm_proxy_locate(struct m0_cm *cm,
                                                   const char *ep);

M0_INTERNAL int m0_cm_proxy_update(struct m0_cm_proxy *pxy,
                                   struct m0_cm_sw *in_interval,
                                   struct m0_cm_sw *out_interval,
                                   uint32_t px_status,
                                   m0_time_t px_epoch);

M0_INTERNAL int m0_cm_proxy_remote_update(struct m0_cm_proxy *proxy,
                                          struct m0_cm_sw *in_interval,
                                          struct m0_cm_sw *out_interval);

M0_INTERNAL void m0_cm_proxy_cp_add(struct m0_cm_proxy *pxy,
                                    struct m0_cm_cp *cp);

M0_INTERNAL uint64_t m0_cm_proxy_nr(struct m0_cm *cm);

M0_INTERNAL bool m0_cm_proxy_agid_is_in_sw(struct m0_cm_proxy *pxy,
                                           struct m0_cm_ag_id *id);

M0_INTERNAL void m0_cm_proxy_fini(struct m0_cm_proxy *pxy);

M0_INTERNAL bool m0_cm_proxy_is_done(const struct m0_cm_proxy *pxy);
M0_INTERNAL void m0_cm_proxy_pending_cps_wakeup(struct m0_cm *cm);

M0_INTERNAL void m0_cm_proxy_event_handle_register(struct m0_cm_proxy *pxy,
                                                   struct m0_conf_obj *svc_obj);

M0_INTERNAL bool m0_cm_proxy_is_locked(struct m0_cm_proxy *pxy);
M0_INTERNAL void m0_cm_proxy_lock(struct m0_cm_proxy *pxy);
M0_INTERNAL void m0_cm_proxy_unlock(struct m0_cm_proxy *pxy);

M0_INTERNAL bool m0_cm_proxies_ready(const struct m0_cm *cm);

M0_INTERNAL int m0_cm_proxy_in_count_alloc(struct m0_cm_proxy_in_count *pcount,
                                           uint32_t nr_proxies);
M0_INTERNAL void m0_cm_proxy_in_count_free(struct m0_cm_proxy_in_count *pcount);

M0_INTERNAL bool m0_cm_proxy_is_updated(struct m0_cm_proxy *proxy,
                                        struct m0_cm_sw *in_interval);

M0_INTERNAL void m0_cm_proxies_sent_reset(struct m0_cm *cm);

M0_TL_DESCR_DECLARE(proxy, M0_EXTERN);
M0_TL_DECLARE(proxy, M0_INTERNAL, struct m0_cm_proxy);

M0_TL_DESCR_DECLARE(proxy_fail, M0_EXTERN);
M0_TL_DECLARE(proxy_fail, M0_INTERNAL, struct m0_cm_proxy);

M0_TL_DESCR_DECLARE(proxy_cp, M0_EXTERN);
M0_TL_DECLARE(proxy_cp, M0_INTERNAL, struct m0_cm_cp);

/* __MOTR_CM_PROXY_H__ */

#endif

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */