file_internal.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_M0T1FS_FILE_INTERNAL_H__
#define __MOTR_M0T1FS_FILE_INTERNAL_H__

/* import */
struct m0_pdclust_tgt_addr;
struct m0_pdclust_src_addr;

/* export */
struct io_request;
struct nw_xfer_request;
struct pargrp_iomap;
struct target_ioreq;
struct io_req_fop;

struct io_request_ops;
struct nw_xfer_ops;
struct pargrp_iomap_ops;
struct target_ioreq_ops;

enum   page_attr;
enum   copy_direction;
enum   nw_xfer_state;
enum   io_req_state;
enum   io_req_type;
enum   pargrp_iomap_rmwtype;

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_NR                  = 10,
};

enum copy_direction {
        CD_COPY_FROM_USER,
        CD_COPY_TO_USER,
        CD_NR,
};

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

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;
};

enum io_req_state {
        IRS_UNINITIALIZED,
        IRS_INITIALIZED,
        IRS_READING,
        IRS_WRITING,
        IRS_READ_COMPLETE,
        IRS_WRITE_COMPLETE,
        IRS_DEGRADED_READING,
        IRS_DEGRADED_WRITING,
        IRS_REQ_COMPLETE,
        IRS_FAILED,
};


struct io_request_ops {
        int (*iro_iomaps_prepare) (struct io_request  *req);

        void (*iro_iomaps_destroy)(struct io_request  *req);

        int (*iro_user_data_copy) (struct io_request  *req,
                                   enum copy_direction dir,
                                   enum page_attr      filter);

        int (*iro_parity_recalc)  (struct io_request  *req);

        int (*iro_parity_verify)  (struct io_request  *req);

        int (*iro_iosm_handle)    (struct io_request  *req);

        int (*iro_dgmode_read)    (struct io_request *req, bool rmw);

        int (*iro_dgmode_recover) (struct io_request *req);

        int (*iro_dgmode_write)   (struct io_request *req, bool rmw);

        int  (*iro_file_lock)     (struct io_request *req);

        void (*iro_file_unlock)   (struct io_request *req);
};

struct io_request {
        uint64_t                     ir_magic;

        int                          ir_rc;

        m0_bcount_t                  ir_copied_nr;

        struct file                 *ir_file;

        struct m0_indexvec_varr      ir_ivv;

        struct pargrp_iomap        **ir_iomaps;

        uint64_t                     ir_iomap_nr;

        const struct iovec          *ir_iovec;

        struct m0_sm                 ir_sm;

        enum io_req_type             ir_type;

        bool                         ir_direct_io;

        const struct io_request_ops *ir_ops;

        struct nw_xfer_request       ir_nwxfer;

        struct m0_rm_incoming        ir_in;

        enum sns_repair_state        ir_sns_state;

        uint32_t                     ir_dgmap_nr;

        uint64_t                    *ir_failed_session;
};

struct data_buf {
        uint64_t             db_magic;

        struct m0_buf        db_buf;

        struct m0_buf        db_auxbuf;

        struct page         *db_page;

        enum page_attr       db_flags;

        struct target_ioreq *db_tioreq;
};

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

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

struct pargrp_iomap {
        uint64_t                        pi_magic;

        uint64_t                        pi_grpid;

        enum pargrp_iomap_state         pi_state;

        struct m0_indexvec_varr         pi_ivv;

        enum pargrp_iomap_rmwtype       pi_rtype;

        struct data_buf              ***pi_databufs;

        struct data_buf              ***pi_paritybufs;

        const struct pargrp_iomap_ops  *pi_ops;

        struct io_request              *pi_ioreq;
};

struct pargrp_iomap_ops {
        int (*pi_populate)  (struct pargrp_iomap        *iomap,
                             struct m0_ivec_varr_cursor *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,
                                  uint64_t             segid,
                                  bool                 rmw);

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

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

        int (*pi_parity_verify)   (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);
};

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_varr   dr_ivec_varr;

        struct m0_indexvec_varr   dr_bufvec;

        struct m0_varr            dr_pageattrs;

        struct target_ioreq      *dr_tioreq;
};

enum target_ioreq_type {
        TI_NONE,
        TI_READ_WRITE,
        TI_COB_CREATE,
};

struct cc_req_fop {
        struct m0_fop        crf_fop;

        struct m0_sm_ast     crf_ast;

        struct target_ioreq *crf_tioreq;
};

struct target_ioreq {
        uint64_t                       ti_magic;

        struct m0_fid                  ti_fid;

        uint64_t                       ti_obj;

        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;

        struct m0_indexvec_varr        ti_ivv;

        struct m0_indexvec_varr        ti_bufvec;

        struct dgmode_rwvec           *ti_dgvec;

        struct m0_varr                 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 io_req_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;
};

M0_INTERNAL struct inode *m0t1fs_file_to_inode(const struct file *file);

M0_INTERNAL struct m0t1fs_inode *
m0t1fs_file_to_m0inode(const struct file *file);

M0_INTERNAL struct m0t1fs_inode *
m0t1fs_inode_to_m0inode(const struct inode *inode);

M0_INTERNAL struct m0t1fs_sb *m0inode_to_sb(const struct m0t1fs_inode *m0inode);

#endif /* __MOTR_M0T1FS_FILE_INTERNAL_H__ */