cm.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_CM_H__
#define __MOTR_CM_CM_H__

#include "lib/tlist.h"         /* struct m0_tlink */
#include "lib/types.h"         /* uint8_t */

#include "reqh/reqh_service.h" /* struct m0_reqh_service_type */
#include "sm/sm.h"             /* struct m0_sm */
#include "fop/fom.h"           /* struct m0_fom */
#include "fop/fom_simple.h"

#include "cm/sw.h"
#include "cm/ag.h"
#include "cm/pump.h"
#include "cm/ag_store.h"
#include "ha/msg.h"

/* Import */
struct m0_fop;
struct m0_net_buffer_pool;
struct m0_layout;

enum m0_cm_state {
        M0_CMS_INIT,
        M0_CMS_IDLE,
        M0_CMS_PREPARE,
        M0_CMS_READY,
        M0_CMS_ACTIVE,
        M0_CMS_FAIL,
        M0_CMS_STOP,
        M0_CMS_FINI,
        M0_CMS_NR
};

enum {
        CM_RPC_TIMEOUT              = 20, /* seconds */
        CM_MAX_NR_RPC_IN_FLIGHT     = 100,
};

struct m0_cm_type {
        struct m0_reqh_service_type   ct_stype;
        struct m0_tlink               ct_linkage;
        uint64_t                      ct_fom_id;
        struct m0_fom_type            ct_fomt;
        struct m0_fom_type            ct_swu_fomt;
        struct m0_fom_type            ct_pump_fomt;
        struct m0_fom_type            ct_ag_store_fomt;
        uint64_t                      ct_magix;
};

struct m0_cm_ast_run {
        struct m0_thread car_th;
        bool             car_run;
};

struct m0_cm {
        struct m0_sm                     cm_mach;

        uint64_t                         cm_id;

        m0_time_t                        cm_epoch;

        struct m0_sm_group               cm_sm_group;

        const struct m0_cm_ops          *cm_ops;

        struct m0_reqh_service           cm_service;

        const struct m0_cm_type         *cm_type;

        struct m0_tl                     cm_aggr_grps_in;

        uint64_t                         cm_aggr_grps_in_nr;

        struct m0_cm_ag_id               cm_sw_last_updated_hi;

        struct m0_cm_ag_id               cm_last_out_hi;

        struct m0_cm_ag_id               cm_last_processed_out;

        struct m0_tl                     cm_aggr_grps_out;

        uint64_t                         cm_aggr_grps_out_nr;

        struct m0_chan                   cm_wait;
        struct m0_mutex                  cm_wait_mutex;

        struct m0_chan                   cm_complete;

        struct m0_chan                   cm_proxy_init_wait;

        struct m0_tl                     cm_proxies;

        struct m0_tl                     cm_failed_proxies;

        uint64_t                         cm_proxy_nr;

        struct m0_bitmap                 cm_proxy_update_map;
        uint64_t                         cm_nr_proxy_updated;
        uint64_t                         cm_proxy_active_nr;

        struct m0_cm_cp_pump             cm_cp_pump;

        struct m0_cm_sw_update           cm_sw_update;

        struct m0_cm_ag_store            cm_ag_store;

        struct m0_cm_ast_run             cm_asts_run;

        bool                             cm_done;

        bool                             cm_reset;

        bool                             cm_quiesce;

        bool                             cm_abort;
};

struct m0_cm_ops {
        int (*cmo_setup)(struct m0_cm *cm);

        int (*cmo_prepare)(struct m0_cm *cm);

        int (*cmo_start)(struct m0_cm *cm);

        void (*cmo_stop)(struct m0_cm *cm);

        int (*cmo_ag_alloc)(struct m0_cm *cm, const struct m0_cm_ag_id *id,
                            bool has_incoming, struct m0_cm_aggr_group **out);

        struct m0_cm_cp *(*cmo_cp_alloc)(struct m0_cm *cm);

        int (*cmo_data_next)(struct m0_cm *cm, struct m0_cm_cp *cp);

        int (*cmo_ag_next)(struct m0_cm *cm,
                           const struct m0_cm_ag_id *id_curr,
                           struct m0_cm_ag_id *id_next);

        int (*cmo_get_space_for)(struct m0_cm *cm, const struct m0_cm_ag_id *id,
                                 size_t *count);

        int (*cmo_sw_onwire_fop_setup)(struct m0_cm *cm, struct m0_fop *fop,
                                       void (*fop_release)(struct m0_ref *),
                                       uint64_t proxy_id, const char *local_ep,
                                       const struct m0_cm_sw *sw,
                                       const struct m0_cm_sw *out_interval);
        bool (*cmo_is_peer)(struct m0_cm *cm, struct m0_reqh_service_ctx *ctx);

        void (*cmo_ha_msg)(struct m0_cm *cm,
                           struct m0_ha_msg *msg, int rc);

        void (*cmo_fini)(struct m0_cm *cm);
};

M0_INTERNAL int m0_cm_type_register(struct m0_cm_type *cmt);
M0_INTERNAL void m0_cm_type_deregister(struct m0_cm_type *cmt);

M0_INTERNAL void m0_cm_lock(struct m0_cm *cm);
M0_INTERNAL int m0_cm_trylock(struct m0_cm *cm);

M0_INTERNAL void m0_cm_unlock(struct m0_cm *cm);

M0_INTERNAL bool m0_cm_is_locked(const struct m0_cm *cm);

M0_INTERNAL int m0_cm_module_init(void);
M0_INTERNAL void m0_cm_module_fini(void);

M0_INTERNAL int m0_cm_init(struct m0_cm *cm, struct m0_cm_type *cm_type,
                           const struct m0_cm_ops *cm_ops);

M0_INTERNAL void m0_cm_fini(struct m0_cm *cm);

M0_INTERNAL int m0_cm_setup(struct m0_cm *cm);

M0_INTERNAL int m0_cm_prepare(struct m0_cm *cm);
M0_INTERNAL int m0_cm_ready(struct m0_cm *cm);

M0_INTERNAL bool m0_cm_is_ready(struct m0_cm *cm);
M0_INTERNAL bool m0_cm_is_active(struct m0_cm *cm);

M0_INTERNAL int m0_cm_start(struct m0_cm *cm);

M0_INTERNAL int m0_cm_stop(struct m0_cm *cm);

M0_INTERNAL int m0_cm_configure(struct m0_cm *cm, struct m0_fop *fop);

M0_INTERNAL int m0_ha_cm_err_send(struct m0_cm *cm, int rc);

M0_INTERNAL void m0_cm_fail(struct m0_cm *cm, int rc);

#define M0_CM_TYPE_DECLARE(cmtype, id, ops, name, typecode)     \
M0_INTERNAL struct m0_cm_type cmtype ## _cmt = {                                \
        .ct_fom_id = (id),                                      \
        .ct_stype = {                                           \
                .rst_name    = (name),                          \
                .rst_ops     = (ops),                           \
                .rst_level   = M0_RS_LEVEL_NORMAL,              \
                .rst_typecode = (typecode)                      \
        }                                                       \
}

M0_INTERNAL bool m0_cm_invariant(const struct m0_cm *cm);

M0_INTERNAL void m0_cm_state_set(struct m0_cm *cm, enum m0_cm_state state);
M0_INTERNAL enum m0_cm_state m0_cm_state_get(const struct m0_cm *cm);

M0_INTERNAL void m0_cm_continue(struct m0_cm *cm);

M0_INTERNAL int m0_cm_data_next(struct m0_cm *cm, struct m0_cm_cp *cp);

M0_INTERNAL bool m0_cm_has_more_data(const struct m0_cm *cm);

M0_INTERNAL struct m0_net_buffer *m0_cm_buffer_get(struct m0_net_buffer_pool
                                                   *bp, uint64_t colour);

M0_INTERNAL void m0_cm_buffer_put(struct m0_net_buffer_pool *bp,
                                  struct m0_net_buffer *buf,
                                  uint64_t colour);

M0_INTERNAL struct m0_cm *m0_cmsvc2cm(struct m0_reqh_service *cmsvc);

M0_INTERNAL int m0_cm_proxies_fini(struct m0_cm *cm);

M0_INTERNAL struct m0_rpc_machine *m0_cm_rpc_machine_find(struct m0_reqh *reqh);

M0_INTERNAL int m0_cm_ast_run_thread_init(struct m0_cm *cm);
M0_INTERNAL void m0_cm_ast_run_thread_fini(struct m0_cm *cm);
M0_INTERNAL void m0_cm_notify(struct m0_cm *cm);
M0_INTERNAL void m0_cm_wait(struct m0_cm *cm, struct m0_fom *fom);
M0_INTERNAL void m0_cm_wait_cancel(struct m0_cm *cm, struct m0_fom *fom);
M0_INTERNAL int m0_cm_complete(struct m0_cm *cm);
M0_INTERNAL void m0_cm_complete_notify(struct m0_cm *cm);
M0_INTERNAL void m0_cm_proxies_init_wait(struct m0_cm *cm, struct m0_fom *fom);
M0_INTERNAL void m0_cm_frozen_ag_cleanup(struct m0_cm *cm, struct m0_cm_proxy *proxy);
M0_INTERNAL void m0_cm_proxy_failed_cleanup(struct m0_cm *cm);
M0_INTERNAL void m0_cm_abort(struct m0_cm *cm, int rc);
M0_INTERNAL bool m0_cm_is_dirty(struct m0_cm *cm);
M0_INTERNAL bool m0_cm_proxies_updated(struct m0_cm *cm);

/* __MOTR_CM_CM_H__ */

#endif

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