vec.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2013-2021 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_LIB_VEC_H__
#define __MOTR_LIB_VEC_H__

#include "motr/config.h"  /* CONFIG_X86_64 CONFIG_AARCH64 */
#include "lib/types.h"
#include "lib/buf.h"
#include "lib/varr.h"
#include "xcode/xcode_attr.h"

#ifdef __KERNEL__
#include "lib/linux_kernel/vec.h"
#endif

struct m0_vec {
        uint32_t     v_nr;
        m0_bcount_t *v_count;
} M0_XCA_SEQUENCE M0_XCA_DOMAIN(rpc);

M0_INTERNAL m0_bcount_t m0_vec_count(const struct m0_vec *vec);

M0_INTERNAL bool m0_vec_is_empty(const struct m0_vec *vec);

struct m0_vec_cursor {
        const struct m0_vec *vc_vec;
        uint32_t             vc_seg;
        m0_bcount_t          vc_offset;
};

M0_INTERNAL void m0_vec_cursor_init(struct m0_vec_cursor *cur,
                                    const struct m0_vec *vec);

M0_INTERNAL bool m0_vec_cursor_move(struct m0_vec_cursor *cur,
                                    m0_bcount_t count);

M0_INTERNAL m0_bcount_t m0_vec_cursor_step(const struct m0_vec_cursor *cur);

M0_INTERNAL m0_bcount_t m0_vec_cursor_end(const struct m0_vec_cursor *cur);

struct m0_indexvec {
        struct m0_vec  iv_vec;
        m0_bindex_t   *iv_index;
};

struct m0_bufvec {
        struct m0_vec  ov_vec;
        void         **ov_buf;
};

#define M0_BUFVEC_INIT_BUF(addr_ptr, count_ptr) (struct m0_bufvec){     \
        .ov_vec = {                                                     \
                .v_nr = 1,                                              \
                .v_count = (count_ptr),                                 \
        },                                                              \
        .ov_buf = (addr_ptr)                                            \
}

M0_INTERNAL int m0_bufvec_alloc(struct m0_bufvec *bufvec,
                                uint32_t num_segs, m0_bcount_t seg_size);

M0_INTERNAL int m0_bufvec_empty_alloc(struct m0_bufvec *bufvec,
                                      uint32_t          num_segs);

M0_INTERNAL int m0_bufvec_extend(struct m0_bufvec *bufvec,
                                 uint32_t num_segs);

M0_INTERNAL int m0_bufvec_merge(struct m0_bufvec *dst_bufvec,
                                struct m0_bufvec *src_bufvec);

M0_INTERNAL int m0_bufvec_alloc_aligned(struct m0_bufvec *bufvec,
                                        uint32_t num_segs,
                                        m0_bcount_t seg_size, unsigned shift);

M0_INTERNAL int m0_bufvec_alloc_aligned_packed(struct m0_bufvec *bufvec,
                                               uint32_t num_segs,
                                               m0_bcount_t seg_size,
                                               unsigned shift);
M0_INTERNAL int m0__bufvec_dont_dump(struct m0_bufvec *bufvec);

M0_INTERNAL void m0_bufvec_free(struct m0_bufvec *bufvec);

M0_INTERNAL void m0_bufvec_free2(struct m0_bufvec *bufvec);

M0_INTERNAL void m0_bufvec_free_aligned(struct m0_bufvec *bufvec,
                                        unsigned shift);

M0_INTERNAL void m0_bufvec_free_aligned_packed(struct m0_bufvec *bufvec,
                                               unsigned shift);
M0_INTERNAL uint32_t m0_bufvec_pack(struct m0_bufvec *bufvec);

M0_INTERNAL int m0_bufvec_splice(const struct m0_bufvec *bvec, m0_bcount_t nr,
                                 struct m0_buf          *buf);

M0_INTERNAL int m0_indexvec_alloc(struct m0_indexvec *ivec, uint32_t len);

M0_INTERNAL void m0_indexvec_free(struct m0_indexvec *ivec);

M0_INTERNAL uint32_t m0_indexvec_pack(struct m0_indexvec *ivec);

struct m0_bufvec_cursor {
        struct m0_vec_cursor  bc_vc;
};

M0_INTERNAL void m0_bufvec_cursor_init(struct m0_bufvec_cursor *cur,
                                       const struct m0_bufvec *bvec);

M0_INTERNAL bool m0_bufvec_cursor_move(struct m0_bufvec_cursor *cur,
                                       m0_bcount_t count);

M0_INTERNAL bool m0_bufvec_cursor_align(struct m0_bufvec_cursor *cur,
                                        uint64_t alignment);

M0_INTERNAL m0_bcount_t m0_bufvec_cursor_step(const struct m0_bufvec_cursor
                                              *cur);

M0_INTERNAL void *m0_bufvec_cursor_addr(struct m0_bufvec_cursor *cur);

M0_INTERNAL m0_bcount_t m0_bufvec_cursor_copy(struct m0_bufvec_cursor *dcur,
                                              struct m0_bufvec_cursor *scur,
                                              m0_bcount_t num_bytes);
M0_INTERNAL m0_bcount_t m0_bufvec_cursor_copyto(struct m0_bufvec_cursor *dcur,
                                                void *sdata,
                                                m0_bcount_t num_bytes);
M0_INTERNAL m0_bcount_t m0_bufvec_cursor_copyfrom(struct m0_bufvec_cursor *scur,
                                                  void *ddata,
                                                  m0_bcount_t num_bytes);

M0_INTERNAL int m0_bufvec_cursor_cmp(struct m0_bufvec_cursor *c0,
                                     struct m0_bufvec_cursor *c1);
M0_INTERNAL m0_bcount_t m0_bufvec_cursor_prefix(struct m0_bufvec_cursor *c0,
                                                struct m0_bufvec_cursor *c1);

#define M0_BUFVEC_FOR2(c0, c1, frag)                            \
{                                                               \
        struct m0_bufvec_cursor *__c0 = (c0);                   \
        struct m0_bufvec_cursor *__c1 = (c1);                   \
        m0_bcount_t              frag = 0;                      \
        while (!(m0_bufvec_cursor_move(__c0, frag) |            \
                 m0_bufvec_cursor_move(__c1, frag))) {          \
                frag = min_check(m0_bufvec_cursor_step(__c0),   \
                                 m0_bufvec_cursor_step(__c1));

#define M0_BUFVEC_ENDFOR2 } }

struct m0_ivec_cursor {
        struct m0_vec_cursor ic_cur;
};

M0_INTERNAL void m0_ivec_cursor_init(struct m0_ivec_cursor *cur,
                                     const struct m0_indexvec *ivec);

M0_INTERNAL bool m0_ivec_cursor_move(struct m0_ivec_cursor *cur,
                                     m0_bcount_t count);

M0_INTERNAL bool m0_ivec_cursor_move_to(struct m0_ivec_cursor *cursor,
                                        m0_bindex_t dest);

M0_INTERNAL m0_bcount_t m0_ivec_cursor_step(const struct m0_ivec_cursor *cur);

M0_INTERNAL m0_bindex_t m0_ivec_cursor_index(const struct m0_ivec_cursor *cur);

M0_INTERNAL m0_bindex_t
m0_ivec_cursor_conti(const struct m0_ivec_cursor *cur, m0_bindex_t dest);

struct m0_0vec {
        struct m0_bufvec         z_bvec;
        m0_bindex_t             *z_index;
        m0_bindex_t              z_last_buf_idx;
        m0_bcount_t              z_count;
};

#ifdef CONFIG_X86_64
enum {
        M0_0VEC_SHIFT = 12,
        M0_0VEC_ALIGN = (1 << M0_0VEC_SHIFT),
        M0_0VEC_MASK = M0_0VEC_ALIGN - 1,
        M0_SEG_SHIFT = 12,
        M0_SEG_SIZE  = (1 << M0_SEG_SHIFT),
};
#elif defined (CONFIG_AARCH64)
enum {
        M0_0VEC_SHIFT = 16,
        M0_0VEC_ALIGN = (1 << M0_0VEC_SHIFT),
        M0_0VEC_MASK = M0_0VEC_ALIGN - 1,
        M0_SEG_SHIFT = 16,
        M0_SEG_SIZE  = (1 << M0_SEG_SHIFT),
};
#else
  #error  "The platform is not supported"
#endif

M0_INTERNAL int m0_0vec_init(struct m0_0vec *zvec, uint32_t segs_nr);

M0_INTERNAL void m0_0vec_fini(struct m0_0vec *zvec);

M0_INTERNAL void m0_0vec_bvec_init(struct m0_0vec *zvec,
                                   const struct m0_bufvec *bufvec,
                                   const m0_bindex_t * indices);

M0_INTERNAL void m0_0vec_bufs_init(struct m0_0vec *zvec, void **bufs,
                                   const m0_bindex_t * indices,
                                   const m0_bcount_t * counts,
                                   uint32_t segs_nr);

M0_INTERNAL int m0_0vec_cbuf_add(struct m0_0vec *zvec, const struct m0_buf *buf,
                                 const m0_bindex_t * index);

M0_INTERNAL int m0_data_to_bufvec_copy(struct m0_bufvec_cursor *cur, void *data,
                                       size_t len);

M0_INTERNAL int m0_bufvec_to_data_copy(struct m0_bufvec_cursor *cur, void *data,
                                       size_t len);

M0_INTERNAL m0_bcount_t m0_bufvec_copy(struct m0_bufvec *dst,
                                       struct m0_bufvec *src,
                                       m0_bcount_t num_bytes);

struct m0_ioseg {
        uint64_t ci_index;
        uint64_t ci_count;
} M0_XCA_RECORD M0_XCA_DOMAIN(rpc);

struct m0_io_indexvec {
        uint32_t         ci_nr;
        struct m0_ioseg *ci_iosegs;
} M0_XCA_SEQUENCE M0_XCA_DOMAIN(rpc);

struct m0_io_indexvec_seq {
        uint32_t               cis_nr;
        struct m0_io_indexvec *cis_ivecs;
} M0_XCA_SEQUENCE M0_XCA_DOMAIN(rpc);

M0_INTERNAL m0_bcount_t m0_io_count(const struct m0_io_indexvec *io_info);

M0_INTERNAL int m0_indexvec_split(struct m0_indexvec    *in,
                                  m0_bcount_t            curr_pos,
                                  m0_bcount_t            nb_len,
                                  uint32_t               bshift,
                                  struct m0_indexvec    *out);

M0_INTERNAL int m0_indexvec_wire2mem(struct m0_io_indexvec *wire_ivec,
                                     int                    max_frags_nr,
                                     uint32_t               bshift,
                                     struct m0_indexvec    *mem_ivec);

M0_INTERNAL int m0_indexvec_mem2wire(struct m0_indexvec    *mem_ivec,
                                     int                    max_frags_nr,
                                     uint32_t               bshift,
                                     struct m0_io_indexvec *wire_ivec);

M0_INTERNAL int m0_indexvec_universal_set(struct m0_indexvec *iv);

M0_INTERNAL bool m0_indexvec_is_universal(const struct m0_indexvec *iv);


struct m0_indexvec_varr {
        struct m0_varr iv_count;

        struct m0_varr iv_index;

        uint32_t       iv_nr;
};

struct m0_ivec_varr_cursor {
        struct m0_indexvec_varr *vc_ivv;
        uint32_t             vc_seg;
        m0_bcount_t          vc_offset;
};

M0_INTERNAL int m0_indexvec_varr_alloc(struct m0_indexvec_varr *ivec,
                                       uint32_t len);

M0_INTERNAL void m0_indexvec_varr_free (struct m0_indexvec_varr *ivec);

M0_INTERNAL void
m0_ivec_varr_cursor_init(struct m0_ivec_varr_cursor *cur,
                         struct m0_indexvec_varr *ivec);
M0_INTERNAL bool
m0_ivec_varr_cursor_move(struct m0_ivec_varr_cursor *cur,
                         m0_bcount_t count);
M0_INTERNAL bool
m0_ivec_varr_cursor_move_to(struct m0_ivec_varr_cursor *cur,
                            m0_bindex_t dest);
M0_INTERNAL m0_bcount_t
m0_ivec_varr_cursor_step(const struct m0_ivec_varr_cursor *cur);

M0_INTERNAL m0_bindex_t
m0_ivec_varr_cursor_index(const struct m0_ivec_varr_cursor *cur);

M0_INTERNAL m0_bindex_t
m0_ivec_varr_cursor_conti(const struct m0_ivec_varr_cursor *cur,
                          m0_bindex_t dest);

M0_INTERNAL int m0_bufvec_to_buf_copy(struct m0_buf *buf,
                                      const struct m0_bufvec *bvec);

M0_INTERNAL int m0_buf_to_bufvec_copy(struct m0_bufvec *bvec,
                                      const struct m0_buf *buf);

/* __MOTR_LIB_VEC_H__ */
#endif

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