pool.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_POOL_POOL_H__
#define __MOTR_POOL_POOL_H__

#include "format/format.h"     /* m0_format_header */
#include "lib/chan.h"          /* m0_clink */
#include "lib/rwlock.h"
#include "lib/tlist.h"
#include "lib/tlist_xc.h"
#include "fd/fd.h"             /* m0_fd_tile */
#include "reqh/reqh_service.h" /* m0_reqh_service_ctx */
#include "conf/obj.h"
#include "layout/pdclust.h"    /* m0_pdclust_attr */
#include "pool/pool_machine.h"
#include "pool/pool_machine_xc.h"
#include "pool/policy.h"       /* m0_pver_policy_code */

/* import */
struct m0_io_req;

/* export */
struct m0_pool;
struct m0_pool_spare_usage;
struct m0_confc_update_state;

enum {
        PM_DEFAULT_NR_NODES = 10,
        PM_DEFAULT_NR_DEV = 80,
        PM_DEFAULT_MAX_NODE_FAILURES = 1,
        PM_DEFAULT_MAX_DEV_FAILURES = 80,
        POOL_MAX_RPC_NR_IN_FLIGHT = 100
};

enum map_type {
        IOS = 1,
        MDS
};

enum {
        PV_SNS_DIRTY = 1 << 0,
};

struct m0_pool_device_to_service {
        struct m0_reqh_service_ctx *pds_ctx;

        struct m0_fid               pds_sdev_fid;
};

struct m0_pool {
        struct m0_fid          po_id;

        struct m0_tl           po_vers;

        struct m0_tlink        po_linkage;

        struct m0_tl           po_failed_devices;

        struct m0_pver_policy *po_pver_policy;
        uint64_t               po_magic;
};

struct m0_pool_version {
        struct m0_fid                pv_id;

        bool                         pv_is_dirty;

        bool                         pv_is_stale;

        struct m0_pdclust_attr       pv_attr;

        uint32_t                     pv_nr_nodes;

        struct m0_pool              *pv_pool;

        struct m0_pools_common      *pv_pc;

        struct m0_poolmach           pv_mach;

        /* The fault tolerant tile associated with the pool version. */
        struct m0_fd_tile            pv_fd_tile;

        /* Failure domains tree associated with the pool version. */
        struct m0_fd_tree            pv_fd_tree;
        uint32_t                     pv_fd_tol_vec[M0_CONF_PVER_HEIGHT];

        uint32_t                     pv_sns_flags;

        struct m0_tlink              pv_linkage;

        uint64_t                     pv_magic;
};

struct m0_pools_common {
        struct m0_tl                      pc_pools;

        struct m0_confc                  *pc_confc;

        struct m0_rpc_machine            *pc_rmach;

        struct m0_tl                      pc_svc_ctxs;

        struct m0_reqh_service_ctx      **pc_mds_map;

        struct m0_reqh_service_ctx       *pc_rm_ctx;

        uint64_t                          pc_nr_svcs[M0_CST_NR];

        uint32_t                          pc_nr_devices;

        struct m0_pool_device_to_service *pc_dev2svc;

        uint32_t                          pc_md_redundancy;
        struct m0_pool                   *pc_md_pool;
        struct m0_layout_instance        *pc_md_pool_linst;

        struct m0_ha_entrypoint_client   *pc_ha_ecl;
        struct m0_clink                   pc_ha_clink;
        struct m0_mutex                   pc_rm_lock;
        struct m0_pool_version           *pc_cur_pver;
        struct m0_mutex                   pc_mutex;

        struct m0_tl                      pc_abandoned_svc_ctxs;
        struct m0_clink                   pc_conf_exp;
        struct m0_clink                   pc_conf_ready_async;
        struct m0_pool                   *pc_dix_pool;
};

M0_TL_DESCR_DECLARE(pools_common_svc_ctx, M0_EXTERN);
M0_TL_DECLARE(pools_common_svc_ctx, M0_EXTERN, struct m0_reqh_service_ctx);

M0_TL_DESCR_DECLARE(pool_version, M0_EXTERN);
M0_TL_DECLARE(pool_version, M0_EXTERN, struct m0_pool_version);

M0_TL_DESCR_DECLARE(pools, M0_EXTERN);
M0_TL_DECLARE(pools, M0_EXTERN, struct m0_pool);

M0_TL_DESCR_DECLARE(pool_failed_devs, M0_EXTERN);
M0_TL_DECLARE(pool_failed_devs, M0_EXTERN, struct m0_pooldev);

M0_INTERNAL int m0_pools_common_init(struct m0_pools_common *pc,
                                      struct m0_rpc_machine *rmach);

/* This internal API is only used by pool implementation and m0t1fs UT. */
M0_INTERNAL int m0__pools_common_init(struct m0_pools_common *pc,
                                      struct m0_rpc_machine *rmach,
                                      struct m0_conf_root *root);

M0_INTERNAL void m0_pools_common_fini(struct m0_pools_common *pc);

M0_INTERNAL bool m0_pools_common_conf_ready_async_cb(struct m0_clink *clink);

M0_INTERNAL int m0_pools_service_ctx_create(struct m0_pools_common *pc);
M0_INTERNAL void m0_pools_service_ctx_destroy(struct m0_pools_common *pc);

M0_INTERNAL int m0_pool_init(struct m0_pool *pool, const struct m0_fid *id,
                             enum m0_pver_policy_code pver_policy);
M0_INTERNAL void m0_pool_fini(struct m0_pool *pool);

M0_INTERNAL int m0_pool_version_init_by_conf(struct m0_pool_version *pv,
                                             struct m0_conf_pver *pver,
                                             struct m0_pool *pool,
                                             struct m0_pools_common *pc);

M0_INTERNAL int m0_pool_version_init(struct m0_pool_version *pv,
                                     const struct m0_fid *id,
                                     struct m0_pool *pool,
                                     uint32_t pool_width,
                                     uint32_t nodes,
                                     uint32_t nr_data,
                                     uint32_t nr_failures,
                                     uint32_t nr_spare);

M0_INTERNAL int m0_pool_version_get(struct m0_pools_common  *pc,
                                    const struct m0_fid     *pool,
                                    struct m0_pool_version **pv);

M0_INTERNAL struct m0_pool_version *
m0_pool_version_lookup(const struct m0_pools_common *pc,
                       const struct m0_fid          *id);

M0_INTERNAL struct m0_pool_version *
m0_pool_version_find(struct m0_pools_common *pc, const struct m0_fid *id);

M0_INTERNAL void m0_pool_version_fini(struct m0_pool_version *pv);

M0_INTERNAL int m0_pool_versions_init_by_conf(struct m0_pool *pool,
                                              struct m0_pools_common *pc,
                                              const struct m0_conf_pool *cp,
                                              struct m0_sm_group *sm_grp,
                                              struct m0_dtm *dtm);

M0_INTERNAL void m0_pool_versions_fini(struct m0_pool *pool);

M0_INTERNAL void m0_pool_versions_stale_mark(struct m0_pools_common *pc,
                                             struct m0_confc_update_state *s);
M0_INTERNAL struct m0_pool_version *
m0_pool_version_md_get(const struct m0_pools_common *pc);

M0_INTERNAL struct m0_pool_version *
m0_pool_version_dix_get(const struct m0_pools_common *pc);

M0_INTERNAL int m0_pools_init(void);
M0_INTERNAL void m0_pools_fini(void);

M0_INTERNAL int m0_pools_setup(struct m0_pools_common *pc,
                               const struct m0_fid    *profile,
                               struct m0_sm_group     *sm_grp,
                               struct m0_dtm          *dtm);

M0_INTERNAL void m0_pools_destroy(struct m0_pools_common *pc);

M0_INTERNAL int m0_pool_versions_setup(struct m0_pools_common *pc);

M0_INTERNAL int m0_pool_version_append(struct m0_pools_common *pc,
                                       struct m0_conf_pver *pver,
                                       struct m0_pool_version **pv);

M0_INTERNAL void m0_pool_versions_destroy(struct m0_pools_common *pc);

M0_INTERNAL struct m0_pool_version *
m0_pool_clean_pver_find(const struct m0_pool *pool);

M0_INTERNAL uint64_t
m0_pool_version2layout_id(const struct m0_fid *pv_fid, uint64_t lid);

M0_INTERNAL struct m0_rpc_session *
m0_pools_common_active_rm_session(struct m0_pools_common *pc);

M0_INTERNAL struct m0_reqh_service_ctx *
m0_pools_common_service_ctx_find(const struct m0_pools_common *pc,
                                 const struct m0_fid *id,
                                 enum m0_conf_service_type type);
M0_INTERNAL void
m0_pools_common_service_ctx_connect_sync(struct m0_pools_common *pc);

M0_INTERNAL int m0_dix_pool_version_get(struct m0_pools_common  *pc,
                                        struct m0_pool_version **pv);

struct m0_poolnode {
        struct m0_format_header pn_header;
        uint32_t                pn_state M0_XCA_FENUM(m0_pool_nd_state);
        char                    pn_pad[4];
        struct m0_fid           pn_id;
        struct m0_poolmach     *pn_pm;
        uint32_t                pn_index;
        struct m0_be_clink      pn_clink;
        struct m0_format_footer pn_footer;
};
M0_BASSERT(sizeof(enum m0_pool_nd_state) == 4);

enum m0_poolnode_format_version {
        M0_POOLNODE_FORMAT_VERSION_1 = 1,

        /* future versions, uncomment and update M0_POOLNODE_FORMAT_VERSION */
        /*M0_POOLNODE_FORMAT_VERSION_2,*/
        /*M0_POOLNODE_FORMAT_VERSION_3,*/

        M0_POOLNODE_FORMAT_VERSION = M0_POOLNODE_FORMAT_VERSION_1
};

struct m0_pooldev {
        struct m0_format_header pd_header;
        uint32_t                pd_state M0_XCA_FENUM(m0_pool_nd_state);
        char                    pd_pad[4];
        struct m0_fid           pd_id;
        struct m0_fid           pd_sdev_fid;
        uint32_t                pd_index;
        uint32_t                pd_sdev_idx;

        struct m0_poolnode     *pd_node;
        struct m0_poolmach     *pd_pm;
        struct m0_be_clink      pd_clink;

        struct m0_tlink         pd_fail_linkage;
        uint64_t                pd_magic;

        struct m0_format_footer pd_footer;
};

enum m0_pooldev_format_version {
        M0_POOLDEV_FORMAT_VERSION_1 = 1,

        /* future versions, uncomment and update M0_POOLDEV_FORMAT_VERSION */
        /*M0_POOLDEV_FORMAT_VERSION_2,*/
        /*M0_POOLDEV_FORMAT_VERSION_3,*/

        M0_POOLDEV_FORMAT_VERSION = M0_POOLDEV_FORMAT_VERSION_1
};

struct m0_pool_spare_usage {
        struct m0_format_header psu_header;
        uint32_t                psu_device_index;

        uint32_t                psu_device_state M0_XCA_FENUM(m0_pool_nd_state);
        struct m0_format_footer psu_footer;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

enum m0_pool_spare_usage_format_version {
        M0_POOL_SPARE_USAGE_FORMAT_VERSION_1 = 1,

        /* future versions, uncomment and update M0_POOL_SPARE_USAGE_FORMAT_VERSION */
        /*M0_POOL_SPARE_USAGE_FORMAT_VERSION_2,*/
        /*M0_POOL_SPARE_USAGE_FORMAT_VERSION_3,*/

        M0_POOL_SPARE_USAGE_FORMAT_VERSION = M0_POOL_SPARE_USAGE_FORMAT_VERSION_1
};

struct m0_rlimit {
       int rl_processor_throughput;
       int rl_memory;
       int rl_storage_throughput;
       int rl_network_throughput;
};

struct m0_poolserver {
        struct m0_poolnode      ps_node;
        /* struct m0_persistent_sm ps_mach; */
        struct m0_rlimit        ps_rl_usage; 
};

M0_INTERNAL int m0_poolserver_init(struct m0_poolserver *srv);
M0_INTERNAL void m0_poolserver_fini(struct m0_poolserver *srv);
M0_INTERNAL int m0_poolserver_reset(struct m0_poolserver *srv);
M0_INTERNAL int m0_poolserver_on(struct m0_poolserver *srv);
M0_INTERNAL int m0_poolserver_off(struct m0_poolserver *srv);
M0_INTERNAL int m0_poolserver_io_req(struct m0_poolserver *srv,
                                     struct m0_io_req *req);
M0_INTERNAL int m0_poolserver_device_join(struct m0_poolserver *srv,
                                          struct m0_pooldev *dev);
M0_INTERNAL int m0_poolserver_device_leave(struct m0_poolserver *srv,
                                           struct m0_pooldev *dev);

M0_INTERNAL int m0_pool_device_reopen(struct m0_poolmach *pm,
                                      struct m0_reqh *rs_reqh);

M0_INTERNAL int m0_pool_device_state_update(struct m0_reqh        *reqh,
                                            struct m0_be_tx       *tx,
                                            struct m0_fid         *dev_fid,
                                            enum m0_pool_nd_state  new_state);

enum sns_repair_state {
        SRS_UNINITIALIZED = 1,

        SRS_REPAIR_NOTDONE,

        SRS_REPAIR_DONE,

        SRS_NR,
};

M0_INTERNAL void m0_poolnode_clink_add(struct m0_clink *link,
                                       struct m0_chan  *chan);
M0_INTERNAL void m0_poolnode_clink_del(struct m0_clink *cl);

M0_INTERNAL void m0_pooldev_clink_add(struct m0_clink *link,
                                      struct m0_chan  *chan);
M0_INTERNAL void m0_pooldev_clink_del(struct m0_clink *cl);

M0_INTERNAL uint32_t m0_ha2pm_state_map(enum m0_ha_obj_state hastate);

M0_INTERNAL const char *m0_pool_dev_state_to_str(enum m0_pool_nd_state state);
M0_INTERNAL struct m0_pool *m0_pool_find(struct m0_pools_common *pc,
                                         const struct m0_fid *pool);

M0_INTERNAL void m0_pools_lock(struct m0_pools_common *pc);
M0_INTERNAL void m0_pools_unlock(struct m0_pools_common *pc);
M0_INTERNAL bool m0_pools_is_locked(struct m0_pools_common *pc);

#endif /* __MOTR_POOL_POOL_H__ */

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