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_SNS_CM_H__
#define __MOTR_SNS_CM_H__

#include "net/buffer_pool.h"
#include "pool/pool.h"

#include "cm/cm.h"
#include "sns/cm/iter.h"
#include "sns/cm/ag.h"
#include "rm/rm.h"
#include "file/file.h"
#include "lib/hash.h"
#include "cm/repreb/cm.h" /* m0_cm_op */
#include "ha/msg.h"       /* m0_ha_msg */


enum m0_sns_cm_op {
        SNS_INVALID           = 0,
        SNS_REPAIR            = 1 << 1,
        SNS_REBALANCE         = 1 << 2,
        SNS_REPAIR_QUIESCE    = 1 << 3,
        SNS_REBALANCE_QUIESCE = 1 << 4,
        SNS_REPAIR_STATUS     = 1 << 5,
        SNS_REBALANCE_STATUS  = 1 << 6,
        SNS_REPAIR_ABORT      = 1 << 7,
        SNS_REBALANCE_ABORT   = 1 << 8,
};

enum m0_sns_cm_status {
        SNS_CM_STATUS_INVALID = 0,
        SNS_CM_STATUS_IDLE    = 1,
        SNS_CM_STATUS_STARTED = 2,
        SNS_CM_STATUS_FAILED  = 3,
        SNS_CM_STATUS_PAUSED  = 4,
        SNS_CM_STATUS_NR,
};

enum m0_sns_cm_local_unit_type {
        M0_SNS_CM_UNIT_LOCAL,
        M0_SNS_CM_UNIT_HOLE_EOF,
        M0_SNS_CM_UNIT_INVALID
};

struct m0_sns_cm_buf_pool {
        struct m0_net_buffer_pool sb_bp;
        struct m0_chan            sb_wait;
};

struct m0_sns_cm_helpers {
        int (*sch_ag_in_cp_units)(const struct m0_sns_cm *scm,
                                  const struct m0_cm_ag_id *id,
                                  struct m0_sns_cm_file_ctx *fctx,
                                  uint32_t *in_cp_nr,
                                  uint32_t *in_units_nr,
                                  struct m0_cm_proxy_in_count *pcount);

        uint64_t (*sch_ag_unit_start)(const struct m0_pdclust_layout *pl);

        uint64_t (*sch_ag_unit_end)(const struct m0_pdclust_layout *pl);

        bool     (*sch_ag_is_relevant)(struct m0_sns_cm *scm,
                                       struct m0_sns_cm_file_ctx *fctx,
                                       uint64_t group);

        int      (*sch_ag_setup)(struct m0_sns_cm_ag *sag,
                                 struct m0_pdclust_layout *pl);

        int      (*sch_cob_locate)(struct m0_sns_cm *scm,
                                   struct m0_cob_domain *cdom,
                                   struct m0_poolmach *pm,
                                   const struct m0_fid *cob_fid);

       bool      (*sch_is_cob_failed)(struct m0_poolmach *pm,
                                      uint32_t cob_index);
};

struct m0_sns_cm_rm_ctx {
        /*
         * Resource manager domain for this sns copy machine.
         * Ideally this should be a part of reqh object, but
         * that would require modifications in the rm code.
         */
        struct m0_rm_domain             rc_dom;
        struct m0_rm_resource_type      rc_rt;
        struct m0_pools_common         *rc_pc;
};

struct m0_sns_cm {
        struct m0_cm                    sc_base;

        enum m0_cm_op                   sc_op;

        const struct m0_sns_cm_helpers *sc_helpers;

        struct m0_cob_domain           *sc_cob_dom;

        struct m0_sns_cm_iter           sc_it;

        struct m0_sns_cm_ag_iter        sc_ag_it;
        struct m0_sns_cm_buf_pool       sc_ibp;

        uint64_t                        sc_ibp_reserved_nr;

        struct m0_sns_cm_buf_pool       sc_obp;

        uint32_t                        sc_repair_done;

        m0_time_t                       sc_start_time;

        m0_time_t                       sc_stop_time;

        m0_time_t                       sc_last_status_print_time;

        size_t                          *sc_total_read_size;
        size_t                          *sc_total_write_size;

        struct m0_htable                sc_file_ctx;

        struct m0_mutex                 sc_file_ctx_mutex;

        struct m0_sns_cm_rm_ctx         sc_rm_ctx;

        uint64_t                        sc_magic;

};

M0_INTERNAL int m0_sns_cm_type_register(void);
M0_INTERNAL void m0_sns_cm_type_deregister(void);

M0_INTERNAL size_t m0_sns_cm_buffer_pool_provision(struct m0_net_buffer_pool *bp,
                                                   size_t bufs_nr);
M0_INTERNAL void m0_sns_cm_buffer_pools_prune(struct m0_cm *cm);
M0_INTERNAL struct m0_net_buffer *m0_sns_cm_buffer_get(struct m0_net_buffer_pool
                                                       *bp, size_t colour);
M0_INTERNAL void m0_sns_cm_buffer_put(struct m0_net_buffer_pool *bp,
                                          struct m0_net_buffer *buf,
                                          uint64_t colour);

M0_INTERNAL int m0_sns_cm_buf_attach(struct m0_net_buffer_pool *bp, struct m0_cm_cp *cp);
M0_INTERNAL void m0_sns_cm_buf_wait(struct m0_sns_cm_buf_pool *sbp, struct m0_fom *fom);

M0_INTERNAL struct m0_sns_cm *cm2sns(struct m0_cm *cm);

M0_INTERNAL struct m0_cm_cp *m0_sns_cm_cp_alloc(struct m0_cm *cm);

M0_INTERNAL int m0_sns_cm_prepare(struct m0_cm *cm);

M0_INTERNAL void m0_sns_cm_stop(struct m0_cm *cm);

M0_INTERNAL int m0_sns_cm_setup(struct m0_cm *cm);

M0_INTERNAL bool m0_sns_is_peer(struct m0_cm               *cm,
                                struct m0_reqh_service_ctx *ctx);

M0_INTERNAL int m0_sns_cm_fail_dev_log(struct m0_cm *cm,
                                        enum m0_pool_nd_state pd_state);

M0_INTERNAL int m0_sns_cm_start(struct m0_cm *cm);

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

M0_INTERNAL void m0_sns_cm_complete(struct m0_cm *cm);

M0_INTERNAL void m0_sns_cm_fini(struct m0_cm *cm);

M0_INTERNAL int64_t
m0_sns_cm_incoming_reserve_bufs(struct m0_sns_cm *scm,
                                const struct m0_cm_ag_id *id);

M0_INTERNAL uint64_t m0_sns_cm_data_seg_nr(struct m0_sns_cm *scm,
                                           struct m0_pdclust_layout *pl);

M0_INTERNAL uint64_t m0_sns_cm_cp_buf_nr(struct m0_net_buffer_pool *bp,
                                         uint64_t data_seg_nr);

M0_INTERNAL int m0_sns_cm_has_space_for(struct m0_sns_cm *scm,
                                        struct m0_pdclust_layout *pl,
                                        uint64_t nr_bufs);

M0_INTERNAL void m0_sns_cm_reserve_space(struct m0_sns_cm *scm, size_t nr_bufs);

M0_INTERNAL void m0_sns_cm_cancel_reservation(struct m0_sns_cm *scm, size_t nr_bufs);

M0_INTERNAL enum sns_repair_state
m0_sns_cm_fid_repair_done(struct m0_fid *gfid, struct m0_reqh *reqh,
                          enum m0_pool_nd_state device_state);

M0_INTERNAL int m0_sns_cm_rm_init(struct m0_sns_cm *scm);
M0_INTERNAL void  m0_sns_cm_rm_fini(struct m0_sns_cm *scm);

M0_INTERNAL void m0_sns_cm_repair_trigger_fop_init(void);
M0_INTERNAL void m0_sns_cm_repair_trigger_fop_fini(void);

M0_INTERNAL void m0_sns_cm_rebalance_trigger_fop_init(void);
M0_INTERNAL void m0_sns_cm_rebalance_trigger_fop_fini(void);

M0_INTERNAL void m0_sns_cm_repair_sw_onwire_fop_init(void);
M0_INTERNAL void m0_sns_cm_repair_sw_onwire_fop_fini(void);

M0_INTERNAL void m0_sns_cm_rebalance_sw_onwire_fop_init(void);
M0_INTERNAL void m0_sns_cm_rebalance_sw_onwire_fop_fini(void);

M0_INTERNAL void m0_sns_cm_print_status(struct m0_sns_cm *scm);

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

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