io.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_IO_H__
#define __MOTR_IO_H__

#include "ioservice/fid_convert.h"
#include "motr/client_internal.h"

/*
 * These three are used as macros since they are used as lvalues which is
 * not possible by using static inline functions.
 */
#define INDEX(ivec, i) ((ivec)->iv_index[(i)])
#define COUNT(ivec, i) ((ivec)->iv_vec.v_count[(i)])
#define BUFVI(ovec, i) ((ovec)->ov_buf[(i)])
#define BUFVC(ovec, i) ((ovec)->ov_vec.v_count[(i)])

#define SEG_NR(vec)    ((vec)->iv_vec.v_nr)

#define SHIFT2MASK(x) ~((1ULL<<x) -1)

/* op_io's state configuration */
extern struct m0_sm_conf io_sm_conf;

extern const struct m0_op_io_ops ioo_ops;
extern const struct m0_op_io_ops ioo_oostore_ops;

extern const struct m0_uint128 m0_rm_group;

/* BOB types */
extern const struct m0_bob_type ioo_bobtype;
M0_BOB_DECLARE(M0_INTERNAL, m0_op_io);

extern struct m0_bob_type iofop_bobtype;
M0_BOB_DECLARE(M0_INTERNAL, ioreq_fop);

extern const struct m0_bob_type tioreq_bobtype;
M0_BOB_DECLARE(M0_INTERNAL, target_ioreq);

extern const struct m0_bob_type nwxfer_bobtype;
M0_BOB_DECLARE(M0_INTERNAL, nw_xfer_request);

extern const struct m0_bob_type pgiomap_bobtype;
M0_BOB_DECLARE(M0_INTERNAL, pargrp_iomap);

extern const struct m0_bob_type dtbuf_bobtype;
M0_BOB_DECLARE(M0_INTERNAL, data_buf);

/* iofops list */
M0_TL_DESCR_DECLARE(iofops, M0_EXTERN);
M0_TL_DECLARE(iofops, M0_INTERNAL, struct ioreq_fop);

M0_TL_DECLARE(rpcbulk, M0_INTERNAL, struct m0_rpc_bulk_buf);
M0_TL_DESCR_DECLARE(rpcbulk, M0_EXTERN);

/* tioreq hash table*/
M0_TL_DECLARE(tioreqht, M0_EXTERN, struct target_ioreq);
/* a workaround to expose hash tl (should fix in hash.h)*/
M0_TL_DESCR_DECLARE(tioreqht, M0_EXTERN);
M0_HT_DESCR_DECLARE(tioreqht, M0_EXTERN);
M0_HT_DECLARE(tioreqht, M0_EXTERN, struct target_ioreq, uint64_t);

M0_INTERNAL bool addr_is_network_aligned(void *addr);

M0_INTERNAL uint64_t obj_buffer_size(const struct m0_obj *obj);

M0_INTERNAL uint64_t m0__page_size(const struct m0_op_io *ioo);

M0_INTERNAL uint64_t page_nr(m0_bcount_t size, struct m0_obj *obj);

M0_INTERNAL uint32_t layout_n(struct m0_pdclust_layout *play);

M0_INTERNAL uint32_t layout_k(struct m0_pdclust_layout *play);

M0_INTERNAL uint64_t page_id(m0_bindex_t offset, struct m0_obj *obj);

M0_INTERNAL uint64_t layout_unit_size(struct m0_pdclust_layout *play);

M0_INTERNAL uint32_t rows_nr(struct m0_pdclust_layout *play,
                             struct m0_obj *obj);

M0_INTERNAL uint64_t data_size(struct m0_pdclust_layout *play);

M0_INTERNAL struct m0_pdclust_instance *
pdlayout_instance(struct m0_layout_instance *li);

M0_INTERNAL struct m0_pdclust_layout *
pdlayout_get(const struct m0_op_io *ioo);

M0_INTERNAL struct m0_layout_instance *
layout_instance(const struct m0_op_io *ioo);

M0_INTERNAL struct m0_parity_math *parity_math(struct m0_op_io *ioo);

M0_INTERNAL uint64_t target_offset(uint64_t                  frame,
                                   struct m0_pdclust_layout *play,
                                   m0_bindex_t               gob_offset);
M0_INTERNAL uint32_t di_cksum_offset(struct m0_pdclust_layout *play,
                                   m0_bindex_t               gob_offset);
M0_INTERNAL uint64_t group_id(m0_bindex_t index, m0_bcount_t dtsize);

M0_INTERNAL m0_bcount_t seg_endpos(const struct m0_indexvec *ivec, uint32_t i);

M0_INTERNAL uint64_t indexvec_page_nr(const struct m0_vec  *vec,
                                      struct m0_obj *obj);

M0_INTERNAL uint64_t iomap_page_nr(const struct pargrp_iomap *map);

M0_INTERNAL uint64_t parity_units_page_nr(struct m0_pdclust_layout *play,
                                          struct m0_obj *obj);

#if !defined(round_down)

M0_INTERNAL uint64_t round_down(uint64_t val, uint64_t size);
#endif

#if !defined(round_up)

M0_INTERNAL uint64_t round_up(uint64_t val, uint64_t size);

#endif

M0_INTERNAL uint32_t io_desc_size(struct m0_net_domain *ndom);

M0_INTERNAL uint32_t io_seg_size(void);

M0_INTERNAL void page_pos_get(struct pargrp_iomap  *map,
                              m0_bindex_t           index,
                              m0_bindex_t           grp_size,
                              uint32_t             *row,
                              uint32_t             *col);

/*
 * Returns the starting offset of page given its position in data matrix.
 * Acts as opposite of page_pos_get() API.
 */
M0_INTERNAL m0_bindex_t data_page_offset_get(struct pargrp_iomap *map,
                                             uint32_t             row,
                                             uint32_t             col);

M0_INTERNAL uint32_t ioreq_sm_state(const struct m0_op_io *ioo);

M0_INTERNAL uint64_t tolerance_of_level(struct m0_op_io *ioo,
                                        uint64_t lv);

M0_INTERNAL struct m0_rm_domain *
rm_domain_get(struct m0_client *instance);

M0_INTERNAL struct m0_poolmach*
ioo_to_poolmach(struct m0_op_io *ioo);

M0_INTERNAL bool nw_xfer_request_invariant(const struct nw_xfer_request *xfer);

M0_INTERNAL void target_ioreq_fini(struct target_ioreq *ti);

M0_INTERNAL void target_ioreq_cancel(struct target_ioreq *ti);

M0_INTERNAL struct m0_fid target_fid(struct m0_op_io *ioo,
                                     struct m0_pdclust_tgt_addr *tgt);

M0_INTERNAL void nw_xfer_request_init(struct nw_xfer_request *xfer);

M0_INTERNAL void nw_xfer_request_fini(struct nw_xfer_request *xfer);

M0_INTERNAL bool ioreq_fop_invariant(const struct ioreq_fop *fop);

M0_INTERNAL int ioreq_fop_async_submit(struct m0_io_fop      *iofop,
                                       struct m0_rpc_session *session);

M0_INTERNAL int ioreq_fop_init(struct ioreq_fop    *fop,
                               struct target_ioreq *ti,
                               enum page_attr       pattr);
M0_INTERNAL void ioreq_fop_fini(struct ioreq_fop *fop);

M0_INTERNAL int ioreq_cc_fop_init(struct target_ioreq *ti);

M0_INTERNAL int ioreq_fop_dgmode_read(struct ioreq_fop *irfop);

M0_INTERNAL void ioreq_sm_state_set_locked(struct m0_op_io *ioo,
                                           int state);

M0_INTERNAL void ioreq_sm_failed_locked(struct m0_op_io *ioo, int rc);

M0_INTERNAL bool data_buf_invariant(const struct data_buf *db);

M0_INTERNAL uint64_t pargrp_id_find(m0_bindex_t             index,
                                    const struct m0_op_io  *ioo,
                                    const struct ioreq_fop *ir_fop);

M0_INTERNAL bool pargrp_iomap_invariant(const struct pargrp_iomap *map);

M0_INTERNAL bool pargrp_iomap_invariant_nr(const struct m0_op_io *ioo);

M0_INTERNAL int pargrp_iomap_init(struct pargrp_iomap *map,
                                  struct m0_op_io     *ioo,
                                  uint64_t             grpid);
M0_INTERNAL void pargrp_iomap_fini(struct pargrp_iomap *map,
                                   struct m0_obj *obj);

M0_INTERNAL struct m0_obj_attr *
m0_io_attr(struct m0_op_io *ioo);
#endif /* __MOTR_IO_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
 */