pg.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2016-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_PG_H__
#define __MOTR_PG_H__

#include "lib/hash.h"
#include "ioservice/io_fops.h"  /* m0_io_fop_{init,fini,release} */
#include "layout/pdclust.h"     /* struct m0_pdclust_attr */
#include "pool/pool.h"          /* struct m0_pool */

/* Exports */
struct pargrp_iomap;
struct target_ioreq;
struct ioreq_fop;
struct nw_xfer_request;

enum ioreq_state {
        IRS_UNINITIALIZED,
        IRS_INITIALIZED,
        IRS_READING,
        IRS_WRITING,
        IRS_READ_COMPLETE,
        IRS_WRITE_COMPLETE,
        IRS_TRUNCATE,
        IRS_TRUNCATE_COMPLETE,
        IRS_DEGRADED_READING,
        IRS_DEGRADED_WRITING,
        IRS_REQ_COMPLETE,
        IRS_FAILED,
};

enum page_attr {
        PA_NONE                = 0,

        PA_READ                = (1 << 0),

        PA_FULLPAGE_MODIFY     = (1 << 1),

        PA_PARTPAGE_MODIFY     = (1 << 2),

        PA_WRITE               = (1 << 3),

        PA_DATA                = (1 << 4),

        PA_PARITY              = (1 << 5),

        PA_COPY_FRMUSR_DONE    = (1 << 6),

        PA_READ_FAILED         = (1 << 7),

        PA_DGMODE_READ         = (1 << 8),

        PA_DGMODE_WRITE        = (1 << 9),

        PA_APP_MEMORY          = (1 << 10),

        PA_TRUNC               = (1 << 11),

        PA_NR                  = 12,
};

enum pargrp_iomap_rmwtype {
        PIR_NONE,
        PIR_READOLD,
        PIR_READREST,
        PIR_NR,
};

enum pargrp_iomap_state {
        PI_NONE,
        PI_HEALTHY,
        PI_DEGRADED,
        PI_NR,
};


enum nw_xfer_state {
        NXS_UNINITIALIZED,
        NXS_INITIALIZED,
        NXS_INFLIGHT,
        NXS_COMPLETE,
        NXS_STATE_NR,
};

enum copy_direction {
        CD_COPY_FROM_APP,
        CD_COPY_TO_APP,
};

struct data_buf {
        uint64_t             db_magic;

        struct m0_buf        db_buf;

        struct m0_buf        db_auxbuf;

        enum page_attr       db_flags;

        struct target_ioreq *db_tioreq;

        struct m0_key_val    db_maj_ele;

        uint64_t             db_crc;

        uint32_t             db_key;
};

struct nw_xfer_ops {
        int  (*nxo_distribute) (struct nw_xfer_request  *xfer);

        void (*nxo_complete)   (struct nw_xfer_request  *xfer, bool rmw);

        int  (*nxo_dispatch)   (struct nw_xfer_request  *xfer);

        int  (*nxo_tioreq_map) (struct nw_xfer_request           *xfer,
                                const struct m0_pdclust_src_addr *src,
                                struct m0_pdclust_tgt_addr       *tgt,
                                struct target_ioreq             **tio);
};

struct nw_xfer_request {
        uint64_t                  nxr_magic;

        int                       nxr_rc;

        uint64_t                  nxr_bytes;

        enum nw_xfer_state        nxr_state;

        const struct nw_xfer_ops *nxr_ops;

        struct m0_htable          nxr_tioreqs_hash;

        struct m0_mutex           nxr_lock;
        struct m0_atomic64       nxr_iofop_nr;

        struct m0_atomic64       nxr_rdbulk_nr;

        struct m0_atomic64        nxr_ccfop_nr;
};

struct pargrp_iomap {
        uint64_t                        pi_magic;

        uint64_t                        pi_grpid;

        enum pargrp_iomap_state         pi_state;

        struct m0_indexvec              pi_ivec;

        enum pargrp_iomap_rmwtype       pi_rtype;

        struct data_buf              ***pi_databufs;

        uint32_t                        pi_max_row;

        uint32_t                        pi_max_col;

        struct data_buf              ***pi_paritybufs;

        const struct pargrp_iomap_ops  *pi_ops;

        struct m0_op_io                *pi_ioo;

        bool                            pi_trunc_partial;
        bool                            pi_is_corrupted;
};

struct pargrp_iomap_ops {
        int (*pi_populate)  (struct pargrp_iomap      *iomap,
                             struct m0_ivec_cursor    *cursor,
                             struct m0_bufvec_cursor  *buf_cursor);

        bool (*pi_spans_seg) (struct pargrp_iomap *iomap,
                              m0_bindex_t          index,
                              m0_bcount_t          count);

        int (*pi_readrest)   (struct pargrp_iomap *iomap);

        uint64_t (*pi_fullpages_find) (struct pargrp_iomap *map);

        int (*pi_seg_process)    (struct pargrp_iomap *map,
                                  uint32_t             segid,
                                  bool                 rmw,
                                  uint64_t             start_buf_index,
                                  struct m0_bufvec_cursor *buf_cursor);

        int (*pi_readold_auxbuf_alloc) (struct pargrp_iomap *map);

        int (*pi_databuf_alloc)(struct pargrp_iomap *map,
                                uint32_t             row,
                                uint32_t             col,
                                struct m0_bufvec_cursor *buf_cursor);


        int (*pi_parity_recalc)(struct pargrp_iomap *map);

        int (*pi_parity_verify)(struct pargrp_iomap *map);

        int (*pi_parity_replica_verify)(struct pargrp_iomap *map);

        int (*pi_data_replicate)(struct pargrp_iomap *map);

        int (*pi_paritybufs_alloc)(struct pargrp_iomap *map);

        int (*pi_dgmode_process)(struct pargrp_iomap *map,
                                 struct target_ioreq *tio,
                                 m0_bindex_t         *index,
                                 uint32_t             count);

        int (*pi_dgmode_postprocess)(struct pargrp_iomap *map);

        int (*pi_dgmode_recover)(struct pargrp_iomap *map);

        int (*pi_replica_recover)(struct pargrp_iomap *map);
};

struct m0_op_io_ops {
        int (*iro_iomaps_prepare) (struct m0_op_io *ioo);

        void (*iro_iomaps_destroy)(struct m0_op_io *ioo);

        int (*iro_application_data_copy) (struct m0_op_io        *ioo,
                                          enum copy_direction     dir,
                                          enum page_attr          filter);

        int (*iro_parity_recalc)  (struct m0_op_io *ioo);

        int (*iro_parity_verify)  (struct m0_op_io  *ioo);

        void (*iro_iosm_handle_launch)(struct m0_sm_group *grp,
                                       struct m0_sm_ast *ast);

        void (*iro_iosm_handle_executed)(struct m0_sm_group *grp,
                                         struct m0_sm_ast *ast);

        int (*iro_dgmode_read)    (struct m0_op_io *ioo, bool rmw);

        int (*iro_dgmode_recover) (struct m0_op_io *ioo);

        int (*iro_dgmode_write)   (struct m0_op_io *ioo, bool rmw);

        int (*iro_replica_rectify) (struct m0_op_io *ioo, bool rmw);
};

struct target_ioreq_ops {
        void (*tio_seg_add)     (struct target_ioreq              *ti,
                                 const struct m0_pdclust_src_addr *src,
                                 const struct m0_pdclust_tgt_addr *tgt,
                                 m0_bindex_t                       gob_offset,
                                 m0_bcount_t                       count,
                                 struct pargrp_iomap              *map);

        int  (*tio_iofops_prepare) (struct target_ioreq *ti,
                                    enum page_attr       filter);

        int (*tio_cc_fops_prepare) (struct target_ioreq *ti);
};

struct dgmode_rwvec {
        struct m0_indexvec   dr_ivec;

        struct m0_bufvec     dr_bufvec;
        struct m0_bufvec     dr_auxbufvec;

        enum page_attr      *dr_pageattrs;

        struct target_ioreq *dr_tioreq;
};

struct cc_req_fop {
        struct m0_fop        crf_fop;

        struct m0_sm_ast     crf_ast;

        struct target_ioreq *crf_tioreq;
};

enum target_ioreq_type {
        TI_NONE,
        TI_READ_WRITE,
        TI_COB_CREATE,
        TI_COB_TRUNCATE,
};

struct target_ioreq {
        uint64_t                       ti_magic;

        struct m0_fid                  ti_fid;

        uint64_t                       ti_obj;
        m0_time_t                      ti_start_time;

        int                            ti_rc;

        uint64_t                       ti_parbytes;

        uint64_t                       ti_databytes;

        struct m0_tl                   ti_iofops;
        struct cc_req_fop              ti_cc_fop;

        bool                           ti_cc_fop_inited;

        struct m0_rpc_session         *ti_session;

        struct m0_hlink                ti_link;

        m0_bindex_t                    ti_goff;

        struct m0_indexvec             ti_ivec;

        struct m0_indexvec             ti_trunc_ivec;


        struct m0_bufvec               ti_bufvec;
        struct m0_bufvec               ti_auxbufvec;

        // TODO: Combine this into one struct for checksums
        struct m0_buf                  ti_attrbuf;
        m0_bcount_t                    ti_cksum_copied;

        /* Array for segment having b_nob value of checksum */
        uint32_t                      *ti_cksum_seg_b_nob;

        struct m0_indexvec             ti_goff_ivec;

        struct dgmode_rwvec           *ti_dgvec;

        enum page_attr                *ti_pageattrs;

        const struct target_ioreq_ops *ti_ops;

        struct nw_xfer_request        *ti_nwxfer;

        enum m0_pool_nd_state          ti_state;

        enum target_ioreq_type         ti_req_type;
};

struct ioreq_fop {
        uint64_t                     irf_magic;

        int                          irf_reply_rc;

        struct m0_io_fop             irf_iofop;

        enum page_attr               irf_pattr;

        struct m0_sm_ast             irf_ast;

        struct m0_tlink              irf_link;

        struct target_ioreq         *irf_tioreq;
};


#endif /* __MOTR_PG_H__ */

/*
 *  Local variables:
 *  c-indentation-style: "K&R"
 *  c-basic-offset: 8
 *  tab-width: 8
 *  fill-column: 80
 *  scroll-step: 1
 *  End:
 */
/*
 * vim: tabstop=8 shiftwidth=8 noexpandtab textwidth=80 nowrap
 */