layout.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2012-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_LAYOUT_LAYOUT_H__
#define __MOTR_LAYOUT_LAYOUT_H__

/* import */
#include "lib/types.h"  /* uint64_t */
#include "lib/tlist.h"  /* struct m0_tl */
#include "lib/mutex.h"  /* struct m0_mutex */
#include "lib/arith.h"  /* M0_IS_8ALIGNED */
#include "lib/refs.h"   /* struct m0_ref */

#include "fid/fid.h"    /* struct m0_fid */
#include "layout/layout_pver.h" /* m0_layout_init_by_pver() */

struct m0_bufvec_cursor;
struct m0_be_tx;
struct m0_client;

/* export */
struct m0_layout_domain;
struct m0_layout;
struct m0_layout_ops;
struct m0_layout_type;
struct m0_layout_type_ops;
struct m0_layout_enum;
struct m0_layout_enum_ops;
struct m0_layout_enum_type;
struct m0_layout_enum_type_ops;
struct m0_striped_layout;
struct m0_layout_instance;
struct m0_layout_instance_ops;
struct m0_layout_rec;
struct m0_pools_common;

enum m0_layout_xcode_op {
        M0_LXO_BUFFER_OP, /* Operate on a buffer. */
        M0_LXO_DB_LOOKUP, /* Lookup for layout from the DB. */
        M0_LXO_DB_ADD,    /* Add layout to the DB. */
        M0_LXO_DB_UPDATE, /* Update layout in the DB. */
        M0_LXO_DB_DELETE  /* Delete layout from the DB. */
};

enum {
        M0_LAYOUT_TYPE_MAX      = 32,
        M0_LAYOUT_ENUM_TYPE_MAX = 32
};

#ifdef CONFIG_X86_64
        enum { M0_DEFAULT_LAYOUT_ID = 1 };
#elif defined (CONFIG_AARCH64)
/*
 * Layout id defines the object unit size which cannot be less than
 * the page size: 1 - 4KB, 2 - 8KB, 3 - 16KB and so on. On RHEL aarch64
 * platform the page size is 64KB, hence the default layout id must be 5.
 */
        enum { M0_DEFAULT_LAYOUT_ID = 5 };
#else
#error  "The platform is not supported"
#endif

struct m0_layout_domain {
        struct m0_layout_type      *ld_type[M0_LAYOUT_TYPE_MAX];

        struct m0_layout_enum_type *ld_enum[M0_LAYOUT_ENUM_TYPE_MAX];

        struct m0_tl                ld_layout_list;

        void                       *ld_type_data[M0_LAYOUT_TYPE_MAX];

        void                       *ld_enum_data[M0_LAYOUT_ENUM_TYPE_MAX];

        m0_bcount_t                 ld_max_recsize;

        struct m0_mutex             ld_lock;
};

struct m0_layout {
        uint64_t                     l_id;

        struct m0_layout_type       *l_type;

        struct m0_layout_domain     *l_dom;

        struct m0_ref                l_ref;

        uint32_t                     l_user_count;
        struct m0_mutex              l_lock;
        const struct m0_layout_ops  *l_ops;
        uint64_t                     l_magic;
        struct m0_tlink              l_list_linkage;
        struct m0_pool_version      *l_pver;
};

struct m0_layout_ops {
        void        (*lo_fini)(struct m0_ref *ref);

        void        (*lo_delete)(struct m0_layout *l);

        m0_bcount_t (*lo_recsize)(const struct m0_layout *l);

        int         (*lo_instance_build)(struct m0_layout           *l,
                                         const struct m0_fid        *fid,
                                         struct m0_layout_instance **linst);

        int         (*lo_decode)(struct m0_layout *l,
                                 struct m0_bufvec_cursor *cur,
                                 enum m0_layout_xcode_op op,
                                 struct m0_be_tx *tx,
                                 uint32_t user_count);

        int         (*lo_encode)(struct m0_layout *l,
                                 enum m0_layout_xcode_op op,
                                 struct m0_be_tx *tx,
                                 struct m0_bufvec_cursor *out);
};

struct m0_layout_type {
        const char                      *lt_name;

        uint32_t                         lt_id;

        uint32_t                         lt_ref_count;

        const struct m0_layout_type_ops *lt_ops;
};

struct m0_layout_type_ops {
        int         (*lto_register)(struct m0_layout_domain *dom,
                                    const struct m0_layout_type *lt);

        void        (*lto_unregister)(struct m0_layout_domain *dom,
                                      const struct m0_layout_type *lt);

        m0_bcount_t (*lto_max_recsize)(struct m0_layout_domain *dom);

        int         (*lto_allocate)(struct m0_layout_domain *dom,
                                    uint64_t lid,
                                    struct m0_layout **out);
};

struct m0_layout_enum {
        struct m0_layout_enum_type      *le_type;

        struct m0_layout_domain         *le_dom;
        bool                             le_sl_is_set;

        struct m0_striped_layout        *le_sl;

        const struct m0_layout_enum_ops *le_ops;

        uint64_t                         le_magic;
};

struct m0_layout_enum_ops {
        uint32_t    (*leo_nr)(const struct m0_layout_enum *e);

        void        (*leo_get)(const struct m0_layout_enum *e, uint32_t idx,
                               const struct m0_fid *gfid, struct m0_fid *out);

        m0_bcount_t (*leo_recsize)(struct m0_layout_enum *e);

        void        (*leo_fini)(struct m0_layout_enum *e);

        void        (*leo_delete)(struct m0_layout_enum *e);

        int         (*leo_decode)(struct m0_layout_enum *e,
                                  struct m0_bufvec_cursor *cur,
                                  enum m0_layout_xcode_op op,
                                  struct m0_be_tx *tx,
                                  struct m0_striped_layout *stl);

        int         (*leo_encode)(const struct m0_layout_enum *le,
                                  enum m0_layout_xcode_op op,
                                  struct m0_be_tx *tx,
                                  struct m0_bufvec_cursor *out);
};

M0_INTERNAL void m0_layout_enum_fini(struct m0_layout_enum *le);

struct m0_layout_enum_type {
        const char                           *let_name;

        uint32_t                              let_id;

        uint32_t                              let_ref_count;

        const struct m0_layout_enum_type_ops *let_ops;
};

struct m0_layout_enum_type_ops {
        int         (*leto_register)(struct m0_layout_domain *dom,
                                     const struct m0_layout_enum_type *et);

        void        (*leto_unregister)(struct m0_layout_domain *dom,
                                       const struct m0_layout_enum_type *et);

        m0_bcount_t (*leto_max_recsize)(void);

        int         (*leto_allocate)(struct m0_layout_domain *dom,
                                     struct m0_layout_enum **out);
};

struct m0_striped_layout {
        struct m0_layout       sl_base;

        struct m0_layout_enum *sl_enum;
};

struct m0_layout_instance {
        struct m0_fid                        li_gfid;

        struct m0_layout                    *li_l;

        const struct m0_layout_instance_ops *li_ops;

        uint64_t                             li_magic;
};

struct m0_layout_instance_ops {
        void (*lio_fini)(struct m0_layout_instance *li);

        struct m0_layout_enum *
                (*lio_to_enum)(const struct m0_layout_instance *li);
};

M0_INTERNAL struct m0_layout_enum *m0_layout_instance_to_enum(const struct
                                                              m0_layout_instance
                                                              *li);

M0_INTERNAL int m0_layout_instance_build(struct m0_layout *l,
                                         const struct m0_fid *fid,
                                         struct m0_layout_instance **out);

M0_INTERNAL void m0_layout_instance_fini(struct m0_layout_instance *li);

struct m0_layout_rec {
        uint32_t  lr_lt_id;

        uint32_t  lr_user_count;

        char      lr_data[0];
};
M0_BASSERT(M0_IS_8ALIGNED(sizeof(struct m0_layout_rec)));

M0_INTERNAL int m0_layouts_init(void);
M0_INTERNAL void m0_layouts_fini(void);

M0_INTERNAL int m0_layout_domain_init(struct m0_layout_domain *dom);

M0_INTERNAL void m0_layout_domain_fini(struct m0_layout_domain *dom);

M0_INTERNAL void m0_layout_domain_cleanup(struct m0_layout_domain *dom);

M0_INTERNAL int m0_layout_standard_types_register(struct m0_layout_domain *dom);

M0_INTERNAL void m0_layout_standard_types_unregister(struct m0_layout_domain
                                                     *dom);

M0_INTERNAL int m0_layout_type_register(struct m0_layout_domain *dom,
                                        struct m0_layout_type *lt);

M0_INTERNAL void m0_layout_type_unregister(struct m0_layout_domain *dom,
                                           struct m0_layout_type *lt);

M0_INTERNAL int m0_layout_enum_type_register(struct m0_layout_domain *dom,
                                             struct m0_layout_enum_type *et);

M0_INTERNAL void m0_layout_enum_type_unregister(struct m0_layout_domain *dom,
                                                struct m0_layout_enum_type *et);

M0_INTERNAL void m0_layout_add(struct m0_layout_domain *dom, struct m0_layout *l);

M0_INTERNAL struct m0_layout *m0_layout_find(struct m0_layout_domain *dom,
                                             uint64_t lid);

M0_INTERNAL int64_t m0_layout_find_by_buffsize(struct m0_layout_domain *dom,
                                               struct m0_fid *pver,
                                               size_t buffsize);

M0_INTERNAL int64_t m0_layout_find_by_objsz(struct m0_client *cli,
                                            struct m0_fid *pool, size_t sz);

M0_INTERNAL void m0_layout_get(struct m0_layout *l);

M0_INTERNAL void m0_layout_put(struct m0_layout *l);

M0_INTERNAL void m0_layout_user_count_inc(struct m0_layout *l);

M0_INTERNAL void m0_layout_user_count_dec(struct m0_layout *l);

M0_INTERNAL int m0_layout_decode(struct m0_layout *l,
                                 struct m0_bufvec_cursor *cur,
                                 enum m0_layout_xcode_op op,
                                 struct m0_be_tx *tx);

M0_INTERNAL int m0_layout_encode(struct m0_layout *l,
                                 enum m0_layout_xcode_op op,
                                 struct m0_be_tx *tx,
                                 struct m0_bufvec_cursor *out);

M0_INTERNAL m0_bcount_t m0_layout_max_recsize(const struct m0_layout_domain
                                              *dom);

M0_INTERNAL struct m0_striped_layout *m0_layout_to_striped(const struct
                                                           m0_layout *l);

M0_INTERNAL struct m0_layout_enum *m0_striped_layout_to_enum(const struct
                                                             m0_striped_layout
                                                             *stl);

M0_INTERNAL struct m0_layout_enum *m0_layout_to_enum(const struct m0_layout *l);

M0_INTERNAL uint32_t m0_layout_enum_nr(const struct m0_layout_enum *e);


M0_INTERNAL void m0_layout_enum_get(const struct m0_layout_enum *e,
                                    uint32_t idx,
                                    const struct m0_fid *gfid,
                                    struct m0_fid *out);

M0_INTERNAL uint32_t m0_layout_enum_find(const struct m0_layout_enum *e,
                                         const struct m0_fid *gfid,
                                         const struct m0_fid *target);

/* __MOTR_LAYOUT_LAYOUT_H__ */
#endif

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