setup.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_MOTR_MOTR_SETUP_H__
#define __MOTR_MOTR_MOTR_SETUP_H__

#include <stdio.h> /* FILE */

#include "lib/tlist.h"
#include "lib/types.h"        /* m0_uint128 */
#include "reqh/reqh_service.h"
#include "stob/stob.h"
#include "net/lnet/lnet.h"    /* M0_NET_LNET_XEP_ADDR_LEN */
#include "net/buffer_pool.h"
#include "mdstore/mdstore.h"  /* m0_mdstore */
#include "fol/fol.h"          /* m0_fol */
#include "reqh/reqh.h"        /* m0_reqh */
#include "yaml.h"             /* yaml_document_t */

#include "be/ut/helper.h"     /* m0_be_ut_backend_seg_add2 */
#include "dtm0/domain.h"      /* m0_dtm0_domain */
#include "pool/pool.h"        /* m0_pools_common */
#include "ha/ha.h"            /* m0_ha */
#include "motr/ha.h"          /* m0_motr_ha */
#include "module/module.h"    /* m0_module */

enum {
        M0_SETUP_DEFAULT_POOL_WIDTH = 10
};

enum {
        M0_AD_STOB_DOM_KEY_DEFAULT = 0x1,
        M0_ADDB2_STOB_DOM_KEY      = 0xaddbf11e, /* ADDB file */
        M0_BE_SEG_SIZE_DEFAULT     = 128 * 1024 * 1024ULL,
};

enum stob_type {
        M0_LINUX_STOB,
        M0_AD_STOB,
        M0_STOB_TYPE_NR
};

M0_EXTERN const char *m0_cs_stypes[M0_STOB_TYPE_NR];

struct cs_args {
        int    ca_argc;
        int    ca_argc_max;
        char **ca_argv;
};

struct cs_endpoint_and_xprt {
        const char      *ex_cep;
        const char      *ex_endpoint;
        const char      *ex_xprt;
        char            *ex_scrbuf;
        uint64_t         ex_magix;
        struct m0_tlink  ex_linkage;
        uint32_t         ex_tm_colour;
};

struct cs_stob_file {
        bool            sf_is_initialised;
        yaml_document_t sf_document;
};

struct cs_stobs {
        struct m0_stob_domain *s_sdom;
        struct cs_stob_file    s_sfile;
        bool                   s_ad_disks_init;
};

enum cs_reqh_ctx_states {
        RC_UNINITIALISED,
        RC_REQH_INITIALISED,
        RC_INITIALISED
};

struct m0_reqh_context {
        const char                  *rc_stpath;

        const char                  *rc_addb_stlocation;

        const char                  *rc_dfilepath;

        const char                  *rc_stype;

        const char                  *rc_bepath;

        char                       **rc_services;

        struct m0_fid               *rc_service_fids;

        uint32_t                     rc_nr_services;

        struct m0_tl                 rc_eps;

        enum cs_reqh_ctx_states      rc_state;

        struct cs_stobs              rc_stob;

        struct m0_be_ut_backend      rc_be;
        struct m0_be_seg            *rc_beseg;

        struct m0_dtm0_domain        rc_dtm0_domain;

        const char                  *rc_be_log_path;
        const char                  *rc_be_seg0_path;
        const char                  *rc_be_seg_path;
        m0_bcount_t                  rc_be_seg_size;
        m0_bcount_t                  rc_be_log_size;
        m0_bcount_t                  rc_be_tx_group_tx_nr_max;
        m0_bcount_t                  rc_be_tx_group_reg_nr_max;
        m0_bcount_t                  rc_be_tx_group_reg_size_max;
        m0_bcount_t                  rc_be_tx_group_payload_size_max;
        m0_bcount_t                  rc_be_tx_reg_nr_max;
        m0_bcount_t                  rc_be_tx_reg_size_max;
        m0_bcount_t                  rc_be_tx_payload_size_max;
        m0_time_t                    rc_be_tx_group_freeze_timeout_min;
        m0_time_t                    rc_be_tx_group_freeze_timeout_max;

        const char                  *rc_confdb;

        struct m0_mdstore            rc_mdstore;

        struct m0_cob_domain_id      rc_cdom_id;

        struct m0_fol               *rc_fol;

        struct m0_reqh               rc_reqh;

        uint64_t                     rc_magix;

        struct m0_motr              *rc_motr;

        uint32_t                     rc_recv_queue_min_length;

        uint32_t                     rc_max_rpc_msg_size;

        bool                         rc_be_seg_preallocate;

        struct m0_fid                rc_fid;

        bool                         rc_disable_direct_io;

        bool                         rc_fis_enabled;

        m0_bcount_t                  rc_addb_record_file_size;
};

struct m0_motr {
        struct m0_pools_common      cc_pools_common;

        struct m0_rwlock            cc_rwlock;

        struct m0_reqh_context      cc_reqh_ctx;

        struct m0_net_xprt        **cc_xprts;

        size_t                      cc_xprts_nr;

        struct m0_tl                cc_ndoms;

        FILE                       *cc_outfile;

        struct m0_tl                cc_buffer_pools;

        size_t                      cc_recv_queue_min_length;

        size_t                      cc_max_rpc_msg_size;

        struct cs_endpoint_and_xprt cc_stats_svc_epx;

        struct m0_tl                cc_ios_eps;

        struct m0_tl                cc_mds_eps;

        uint32_t                    cc_pool_width;

        struct m0_motr_ha           cc_motr_ha;
        bool                        cc_ha_is_started;
        char                       *cc_ha_addr; 
        bool                        cc_daemon;

        bool                        cc_mkfs;

        bool                        cc_force;

        bool                        cc_no_storage;

        bool                        cc_no_conf;

        bool                        cc_no_all2all_connections;

        bool                        cc_enable_finj;

        struct cs_args              cc_args;

        m0_bcount_t                 cc_sns_buf_nr;

        struct m0_module            cc_module;

        int                         cc_setup_env_argc;
        char                      **cc_setup_env_argv;

        uint64_t                    cc_magic;

        struct m0_conf_root        *cc_conf_root;

        bool                        cc_skip_pools_and_ha_update;

        bool                        cc_ha_was_started;
};

enum {
        CS_MAX_EP_ADDR_LEN = 86 /* "lnet:" + M0_NET_LNET_XEP_ADDR_LEN */
};
M0_BASSERT(CS_MAX_EP_ADDR_LEN >= sizeof "lnet:" + M0_NET_LNET_XEP_ADDR_LEN);

struct cs_ad_stob {
        struct m0_stob_domain *as_dom;
        struct m0_stob        *as_stob_back;
        uint64_t               as_magix;
        struct m0_tlink        as_linkage;
};

int m0_cs_init(struct m0_motr *cs_motr,
               struct m0_net_xprt **xprts, size_t xprts_nr, FILE *out, bool mkfs);
void m0_cs_fini(struct m0_motr *cs_motr);

int m0_cs_setup_env(struct m0_motr *cs_motr, int argc, char **argv);

int m0_cs_start(struct m0_motr *cs_motr);

M0_INTERNAL struct m0_rpc_machine *m0_motr_to_rmach(struct m0_motr *motr);

M0_INTERNAL struct m0_confc *m0_motr2confc(struct m0_motr *motr);

struct m0_reqh *m0_cs_reqh_get(struct m0_motr *cctx);

M0_INTERNAL struct m0_motr *m0_cs_ctx_get(struct m0_reqh *reqh);

M0_INTERNAL struct m0_reqh_context *m0_cs_reqh_context(struct m0_reqh *reqh);

M0_INTERNAL struct m0_storage_devs *m0_cs_storage_devs_get(void);

M0_INTERNAL struct m0_net_domain *m0_cs_net_domain_locate(struct m0_motr *cctx,
                                                          const char *xprtname);

M0_INTERNAL int m0_ep_and_xprt_extract(struct cs_endpoint_and_xprt *epx,
                                       const char *ep);

M0_INTERNAL void m0_ep_and_xprt_fini(struct cs_endpoint_and_xprt *epx);

M0_TL_DESCR_DECLARE(cs_eps, extern);
M0_TL_DECLARE(cs_eps, M0_INTERNAL, struct cs_endpoint_and_xprt);
M0_BOB_DECLARE(M0_INTERNAL, cs_endpoint_and_xprt);

M0_INTERNAL int m0_motr_stob_reopen(struct m0_reqh *reqh,
                                    struct m0_poolmach *pm,
                                    uint32_t dev_id);

#endif /* __MOTR_MOTR_MOTR_SETUP_H__ */

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