reqh_service.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2013-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_REQH_REQH_SERVICE_H__
#define __MOTR_REQH_REQH_SERVICE_H__

#include "lib/atomic.h"
#include "lib/chan.h"
#include "lib/tlist.h"
#include "lib/bob.h"
#include "lib/mutex.h"
#include "lib/semaphore.h"
#include "lib/types.h"
#include "be/tx.h"       /* m0_be_tx_remid */
#include "conf/schema.h" /* m0_conf_service_type */
#include "fid/fid.h"
#include "rpc/link.h"    /* m0_rpc_link */
#include "sm/sm.h"

struct m0_fop;
struct m0_fom;
struct m0_conf_obj;
struct m0_rpc_session;

enum m0_reqh_service_state {
        M0_RST_INITIALISING,
        M0_RST_INITIALISED,
        M0_RST_STARTING,
        M0_RST_STARTED,
        M0_RST_STOPPING,
        M0_RST_STOPPED,
        M0_RST_FAILED
};

struct m0_reqh_service {
        struct m0_fid                      rs_service_fid;

        const struct m0_reqh_service_type *rs_type;

        unsigned                           rs_level;
        int                                rs_fom_key;
        struct m0_sm                       rs_sm;

        struct m0_mutex                    rs_mutex;

        const struct m0_reqh_service_ops  *rs_ops;

        struct m0_reqh                    *rs_reqh;

        struct m0_tlink                    rs_linkage;

        struct m0_reqh_context            *rs_reqh_ctx;

        struct m0_buf                     rs_ss_param;

        uint64_t                           rs_magix;
};

struct m0_reqh_service_start_async_ctx {
        struct m0_reqh_service *sac_service;
        struct m0_fom          *sac_fom;
        int                     sac_rc;
};

enum m0_service_health {
        M0_HEALTH_GOOD     = 0,
        M0_HEALTH_BAD      = 1,
        M0_HEALTH_INACTIVE = 2,
        M0_HEALTH_UNKNOWN  = 3,
};


struct m0_reqh_service_ops {
        int (*rso_start_async)(struct m0_reqh_service_start_async_ctx *asc);

        int (*rso_start)(struct m0_reqh_service *service);

        void (*rso_prepare_to_stop)(struct m0_reqh_service *service);

        void (*rso_stop)(struct m0_reqh_service *service);

        void (*rso_fini)(struct m0_reqh_service *service);

        int (*rso_fop_accept)(struct m0_reqh_service *service,
                              struct m0_fop *fop);
        enum m0_service_health (*rso_health)(struct m0_reqh_service *service);
};

struct m0_reqh_service_type_ops {
        int (*rsto_service_allocate)(struct m0_reqh_service **service,
                                     const struct m0_reqh_service_type *stype);
};

struct m0_reqh_service_type {
        const char                            *rst_name;

        const struct m0_reqh_service_type_ops *rst_ops;

        unsigned                               rst_key;
        unsigned                               rst_level;
        bool                                   rst_keep_alive;
        enum m0_conf_service_type              rst_typecode;

        struct m0_tlink                        rst_linkage;
        uint64_t                               rst_magix;
};

M0_INTERNAL int
m0_reqh_service_allocate(struct m0_reqh_service **service,
                         const struct m0_reqh_service_type *stype,
                         struct m0_reqh_context *rctx);

M0_INTERNAL struct m0_reqh_service_type *
m0_reqh_service_type_find(const char *sname);

M0_INTERNAL int m0_reqh_service_start_async(struct
                                            m0_reqh_service_start_async_ctx
                                            *asc);

M0_INTERNAL void m0_reqh_service_started(struct m0_reqh_service *service);

M0_INTERNAL void m0_reqh_service_failed(struct m0_reqh_service *service);

M0_INTERNAL int m0_reqh_service_start(struct m0_reqh_service *service);

M0_INTERNAL void m0_reqh_service_prepare_to_stop(struct m0_reqh_service
                                                 *service);

M0_INTERNAL void m0_reqh_service_stop(struct m0_reqh_service *service);

M0_INTERNAL void m0_reqh_service_init(struct m0_reqh_service *service,
                                      struct m0_reqh         *reqh,
                                      const struct m0_fid    *fid);

M0_INTERNAL void m0_reqh_service_fini(struct m0_reqh_service *service);

enum m0_reqh_service_level {
        /* General levels */
        M0_RS_LEVEL_UNKNOWN       =  0,
        M0_RS_LEVEL_EARLIEST      =  5,
        M0_RS_LEVEL_EARLY         = 10,
        M0_RS_LEVEL_BEFORE_NORMAL = 20,
        M0_RS_LEVEL_NORMAL        = 30,
        M0_RS_LEVEL_AFTER_NORMAL  = 40,
        M0_RS_LEVEL_LATE          = 50,

        /* Special levels */
        M0_BE_TX_SVC_LEVEL = M0_RS_LEVEL_EARLY,
        M0_SS_SVC_LEVEL            = M0_RS_LEVEL_BEFORE_NORMAL,
        M0_RM_SVC_LEVEL            = M0_RS_LEVEL_BEFORE_NORMAL + 1,
        M0_MD_SVC_LEVEL            = M0_RS_LEVEL_NORMAL,
        M0_HA_LINK_SVC_LEVEL       = M0_RS_LEVEL_BEFORE_NORMAL - 1,
        M0_FDMI_SVC_LEVEL          = M0_RS_LEVEL_BEFORE_NORMAL - 1,
        M0_HA_ENTRYPOINT_SVC_LEVEL = M0_RS_LEVEL_BEFORE_NORMAL - 1,
        M0_RPC_SVC_LEVEL           = M0_HA_LINK_SVC_LEVEL - 1,
};

int m0_reqh_service_type_register(struct m0_reqh_service_type *rstype);

void m0_reqh_service_type_unregister(struct m0_reqh_service_type *rstype);

M0_INTERNAL int m0_reqh_service_types_init(void);

M0_INTERNAL void m0_reqh_service_types_fini(void);

M0_INTERNAL bool m0_reqh_service_invariant(const struct m0_reqh_service
                                           *service);

M0_INTERNAL struct m0_reqh_service *
m0_reqh_service_find(const struct m0_reqh_service_type *st,
                     const struct m0_reqh              *reqh);

M0_INTERNAL struct m0_reqh_service *
m0_reqh_service_lookup(const struct m0_reqh *reqh, const struct m0_fid *fid);

M0_INTERNAL int m0_reqh_service_types_length(void);
M0_INTERNAL bool m0_reqh_service_is_registered(const char *sname);
M0_INTERNAL void m0_reqh_service_list_print(void);
M0_INTERNAL int m0_reqh_service_state_get(const struct m0_reqh_service *s);

M0_INTERNAL int m0_reqh_service_setup(struct m0_reqh_service     **out,
                                      struct m0_reqh_service_type *stype,
                                      struct m0_reqh              *reqh,
                                      struct m0_reqh_context      *rctx,
                                      const struct m0_fid         *fid);

M0_INTERNAL void m0_reqh_service_quit(struct m0_reqh_service *svc);

int
m0_reqh_service_async_start_simple(struct m0_reqh_service_start_async_ctx *asc);

struct m0_reqh_service_txid {
        struct m0_reqh_service_ctx *stx_service_ctx;

        struct m0_be_tx_remid       stx_tri;

        struct m0_tlink             stx_tlink;
        uint64_t                    stx_link_magic;
};

struct m0_reqh_service_ctx {
        struct m0_fid               sc_fid;
        struct m0_fid               sc_fid_process;

        struct m0_pools_common     *sc_pc;

        enum m0_conf_service_type   sc_type;

        struct m0_rpc_link          sc_rlink;
        struct m0_clink             sc_rlink_abort;
        struct m0_clink             sc_rlink_wait;
        struct m0_sm_ast            sc_rlink_ast;
        uint64_t                    sc_conn_flags;

        struct m0_sm                sc_sm;
        struct m0_sm_group          sc_sm_grp;

        struct m0_tlink             sc_link;

        struct m0_reqh_service_txid sc_max_pending_tx;
        struct m0_mutex             sc_max_pending_tx_lock;

        struct m0_conf_obj         *sc_service;
        struct m0_conf_obj         *sc_process;

        struct m0_clink             sc_svc_event;
        struct m0_clink             sc_process_event;

        uint64_t                    sc_magic;
};

M0_INTERNAL int m0_reqh_service_ctx_init(struct m0_reqh_service_ctx *ctx,
                                         struct m0_conf_obj *svc_obj,
                                         enum m0_conf_service_type stype,
                                         struct m0_rpc_machine *rmach,
                                         const char *addr,
                                         uint32_t max_rpc_nr_in_flight);

M0_INTERNAL void m0_reqh_service_ctx_fini(struct m0_reqh_service_ctx *ctx);

M0_INTERNAL int m0_reqh_service_ctx_create(struct m0_conf_obj *svc_obj,
                                           enum m0_conf_service_type stype,
                                           struct m0_rpc_machine *rmach,
                                           const char *addr,
                                           uint32_t max_rpc_nr_in_flight,
                                           struct m0_reqh_service_ctx **ctx);

M0_INTERNAL void
m0_reqh_service_ctx_destroy(struct m0_reqh_service_ctx *ctx);

M0_INTERNAL void m0_reqh_service_ctxs_shutdown_prepare(struct m0_reqh *reqh);

M0_INTERNAL void m0_reqh_service_connect(struct m0_reqh_service_ctx *ctx);

M0_INTERNAL bool
m0_reqh_service_ctx_is_connected(const struct m0_reqh_service_ctx *ctx);

M0_INTERNAL void m0_reqh_service_disconnect(struct m0_reqh_service_ctx *ctx);

M0_INTERNAL void
m0_reqh_service_cancel_reconnect(struct m0_reqh_service_ctx *ctx);

M0_INTERNAL void m0_reqh_service_connect_wait(struct m0_reqh_service_ctx *ctx);

M0_INTERNAL int
m0_reqh_service_disconnect_wait(struct m0_reqh_service_ctx *ctx);

M0_INTERNAL struct m0_reqh_service_ctx *
m0_reqh_service_ctx_from_session(struct m0_rpc_session *session);

M0_INTERNAL void m0_reqh_service_ctx_subscribe(struct m0_reqh_service_ctx *ctx);

M0_INTERNAL void
m0_reqh_service_ctx_unsubscribe(struct m0_reqh_service_ctx *ctx);

#endif /* __MOTR_REQH_REQH_SERVICE_H__ */

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