ctg_store.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_CAS_CTG_STORE_H__
#define __MOTR_CAS_CTG_STORE_H__

#include "fop/fom_generic.h"
#include "fop/fom_long_lock.h"
#include "be/op.h"
#include "be/btree.h"
#include "be/btree_xc.h"
#include "be/tx_credit.h"
#include "format/format.h"
#include "cas/cas.h"
#include "motr/setup.h"

struct m0_cas_ctg {
        struct m0_format_header cc_head;
        struct m0_format_footer cc_foot;
        /*
         * m0_be_btree has it's own volatile-only fields, so it can't be placed
         * before the m0_format_footer, where only persistent fields allowed
         */
        struct m0_be_btree      cc_tree;
        struct m0_be_long_lock  cc_lock;
        struct m0_be_chan       cc_chan;
        struct m0_be_mutex      cc_chan_guard;
        /*
         * Indicates whether catalogue is initialised after its fetch from BE
         * segment. Non-meta catalogue is initialised on its first lookup in
         * meta.
         */
        bool                    cc_inited;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

enum m0_cas_ctg_format_version {
        M0_CAS_CTG_FORMAT_VERSION_1 = 1,

        /*
         * CAS with versioned key-value pair feature.
         * There is no backward compatibility with ver1 at the moment.
         */
        M0_CAS_CTG_FORMAT_VERSION_2,
        /*M0_CAS_CTG_FORMAT_VERSION_3,*/
        /*M0_CAS_CTG_FORMAT_VERSION_4,*/

        M0_CAS_CTG_FORMAT_VERSION = M0_CAS_CTG_FORMAT_VERSION_2,
};

enum m0_cas_state_format_version {
        M0_CAS_STATE_FORMAT_VERSION_1 = 1,

        /* future versions, uncomment and update M0_CAS_STATE_FORMAT_VERSION */
        /*M0_CAS_STATE_FORMAT_VERSION_2,*/
        /*M0_CAS_STATE_FORMAT_VERSION_3,*/

        M0_CAS_STATE_FORMAT_VERSION = M0_CAS_STATE_FORMAT_VERSION_1,
};

enum {
        M0_CAS_CTG_VAL_HDR_SIZE = sizeof(uint64_t) + sizeof(uint64_t),
        M0_CAS_CTG_KEY_HDR_SIZE = sizeof(uint64_t),
};

struct m0_cas_state {
        struct m0_format_header cs_header;
        struct m0_cas_ctg      *cs_meta;
        uint64_t                cs_rec_nr;
        uint64_t                cs_rec_size;
        struct m0_format_footer cs_footer;
        struct m0_be_mutex      cs_ctg_init_mutex;
} M0_XCA_RECORD M0_XCA_DOMAIN(be);

struct m0_ctg_op {
        struct m0_fom            *co_fom;
        struct m0_cas_ctg        *co_ctg;
        struct m0_be_op           co_beop;
        struct m0_be_btree_anchor co_anchor;
        struct m0_be_btree_cursor co_cur;
        bool                      co_cur_initialised;
        int                       co_cur_phase;
        struct m0_clink           co_clink;
        struct m0_chan            co_channel;
        struct m0_mutex           co_channel_lock;
        struct m0_buf             co_key;
        struct m0_buf             co_val;
        struct m0_buf             co_out_key;
        struct m0_buf             co_out_val;
        /* Version of the co_out_val+co_out_key record. */
        struct m0_crv             co_out_ver;
        struct m0_buf             co_mem_buf;
        int                       co_opcode;
        int                       co_ct;
        uint32_t                  co_flags;
        int                       co_rc;
        m0_bcount_t               co_cnt;
        bool                      co_is_versioned;
};

#define CTG_OP_COMBINE(opc, ct) (((uint64_t)(opc)) | ((ct) << 16))

M0_INTERNAL int  m0_ctg_store_init(struct m0_be_domain *dom);

M0_INTERNAL void m0_ctg_store_fini(void);

M0_INTERNAL struct m0_cas_ctg *m0_ctg_meta(void);

M0_INTERNAL struct m0_cas_ctg *m0_ctg_dead_index(void);

M0_INTERNAL struct m0_cas_ctg *m0_ctg_ctidx(void);

M0_INTERNAL void m0_ctg_op_init    (struct m0_ctg_op *ctg_op,
                                    struct m0_fom    *fom,
                                    uint32_t          flags);

M0_INTERNAL int  m0_ctg_op_rc      (struct m0_ctg_op *ctg_op);

M0_INTERNAL void m0_ctg_op_fini    (struct m0_ctg_op *ctg_op);

M0_INTERNAL int  m0_ctg_meta_insert(struct m0_ctg_op    *ctg_op,
                                    const struct m0_fid *fid,
                                    int                  next_phase);

M0_INTERNAL int m0_ctg_gc_wait(struct m0_ctg_op *ctg_op,
                               int               next_phase);

M0_INTERNAL int m0_ctg_dead_index_insert(struct m0_ctg_op  *ctg_op,
                                         struct m0_cas_ctg *ctg,
                                         int                next_phase);

M0_INTERNAL int  m0_ctg_meta_lookup(struct m0_ctg_op    *ctg_op,
                                    const struct m0_fid *fid,
                                    int                  next_phase);

M0_INTERNAL
struct m0_cas_ctg *m0_ctg_meta_lookup_result(struct m0_ctg_op *ctg_op);

M0_INTERNAL int m0_ctg_meta_delete(struct m0_ctg_op    *ctg_op,
                                   const struct m0_fid *fid,
                                   int                  next_phase);

M0_INTERNAL int m0_ctg_insert(struct m0_ctg_op    *ctg_op,
                              struct m0_cas_ctg   *ctg,
                              const struct m0_buf *key,
                              const struct m0_buf *val,
                              int                  next_phase);

M0_INTERNAL int m0_ctg_lookup_delete(struct m0_ctg_op    *ctg_op,
                                     struct m0_cas_ctg   *ctg,
                                     const struct m0_buf *key,
                                     struct m0_buf       *val,
                                     int                  flags,
                                     int                  next_phase);

M0_INTERNAL int m0_ctg_delete(struct m0_ctg_op    *ctg_op,
                              struct m0_cas_ctg   *ctg,
                              const struct m0_buf *key,
                              int                  next_phase);

M0_INTERNAL int m0_ctg_lookup(struct m0_ctg_op    *ctg_op,
                              struct m0_cas_ctg   *ctg,
                              const struct m0_buf *key,
                              int                  next_phase);

M0_INTERNAL void m0_ctg_lookup_result(struct m0_ctg_op *ctg_op,
                                      struct m0_buf    *buf);

M0_INTERNAL void m0_ctg_op_get_ver(struct m0_ctg_op     *ctg_op,
                                   struct m0_crv *out);

M0_INTERNAL int m0_ctg_minkey(struct m0_ctg_op  *ctg_op,
                              struct m0_cas_ctg *ctg,
                              int                next_phase);
M0_INTERNAL int m0_ctg_truncate(struct m0_ctg_op  *ctg_op,
                                struct m0_cas_ctg *ctg,
                                m0_bcount_t        limit,
                                int                next_phase);

M0_INTERNAL int m0_ctg_drop(struct m0_ctg_op  *ctg_op,
                            struct m0_cas_ctg *ctg,
                            int                next_phase);

M0_INTERNAL void m0_ctg_meta_cursor_init(struct m0_ctg_op *ctg_op);

M0_INTERNAL int  m0_ctg_meta_cursor_get(struct m0_ctg_op    *ctg_op,
                                        const struct m0_fid *fid,
                                        int                  next_phase);

M0_INTERNAL int  m0_ctg_meta_cursor_next(struct m0_ctg_op *ctg_op,
                                         int               next_phase);

M0_INTERNAL void m0_ctg_cursor_init(struct m0_ctg_op  *ctg_op,
                                    struct m0_cas_ctg *ctg);

M0_INTERNAL bool m0_ctg_cursor_is_initialised(struct m0_ctg_op *ctg_op);

M0_INTERNAL int  m0_ctg_cursor_get(struct m0_ctg_op    *ctg_op,
                                   const struct m0_buf *key,
                                   int                  next_phase);

M0_INTERNAL int  m0_ctg_cursor_next(struct m0_ctg_op *ctg_op,
                                    int               next_phase);

M0_INTERNAL void m0_ctg_cursor_kv_get(struct m0_ctg_op *ctg_op,
                                      struct m0_buf    *key,
                                      struct m0_buf    *val);

M0_INTERNAL void m0_ctg_cursor_put(struct m0_ctg_op *ctg_op);

M0_INTERNAL void m0_ctg_cursor_fini(struct m0_ctg_op *ctg_op);

M0_INTERNAL void m0_ctg_insert_credit(struct m0_cas_ctg      *ctg,
                                      m0_bcount_t             knob,
                                      m0_bcount_t             vnob,
                                      struct m0_be_tx_credit *accum);

M0_INTERNAL void m0_ctg_delete_credit(struct m0_cas_ctg      *ctg,
                                      m0_bcount_t             knob,
                                      m0_bcount_t             vnob,
                                      struct m0_be_tx_credit *accum);

M0_INTERNAL void m0_ctg_ctidx_insert_credits(struct m0_cas_id       *cid,
                                             struct m0_be_tx_credit *accum);

M0_INTERNAL void m0_ctg_drop_credit(struct m0_fom          *fom,
                                    struct m0_be_tx_credit *accum,
                                    struct m0_cas_ctg      *ctg,
                                    m0_bcount_t            *limit);

M0_INTERNAL void m0_ctg_try_init(struct m0_cas_ctg *ctg);

M0_INTERNAL void m0_ctg_fini(struct m0_fom     *fom0,
                             struct m0_cas_ctg *ctg);

M0_INTERNAL void m0_ctg_mark_deleted_credit(struct m0_be_tx_credit *accum);

M0_INTERNAL void m0_ctg_create_credit(struct m0_be_tx_credit *accum);

M0_INTERNAL void m0_ctg_dead_clean_credit(struct m0_be_tx_credit *accum);

M0_INTERNAL void m0_ctg_ctidx_delete_credits(struct m0_cas_id       *cid,
                                             struct m0_be_tx_credit *accum);

M0_INTERNAL int m0_ctg_ctidx_insert_sync(const struct m0_cas_id *cid,
                                         struct m0_be_tx        *tx);

M0_INTERNAL int m0_ctg_ctidx_delete_sync(const struct m0_cas_id *cid,
                                         struct m0_be_tx        *tx);

M0_INTERNAL int m0_ctg_ctidx_lookup_sync(const struct m0_fid   *fid,
                                         struct m0_dix_layout **layout);

M0_INTERNAL int  m0_ctg_mem_place(struct m0_ctg_op    *ctg_op,
                                  const struct m0_buf *buf,
                                  int                  next_phase);
M0_INTERNAL void m0_ctg_mem_place_get(struct m0_ctg_op *ctg_op,
                                      struct m0_buf    *buf);
M0_INTERNAL int  m0_ctg_mem_free(struct m0_ctg_op *ctg_op,
                                 void             *area,
                                 int               next_phase);

M0_INTERNAL uint64_t m0_ctg_rec_nr(void);

M0_INTERNAL uint64_t m0_ctg_rec_size(void);

M0_INTERNAL struct m0_long_lock *m0_ctg_del_lock(void);

M0_INTERNAL struct m0_long_lock *m0_ctg_lock(struct m0_cas_ctg *ctg);

M0_INTERNAL int m0_ctg_create(struct m0_be_seg *seg, struct m0_be_tx *tx,
                              struct m0_cas_ctg **out,
                              const struct m0_fid *cas_fid);

M0_INTERNAL int m0_ctg__meta_insert(struct m0_be_btree  *meta,
                                    const struct m0_fid *fid,
                                    struct m0_cas_ctg   *ctg,
                                    struct m0_be_tx     *tx);

M0_INTERNAL int m0_ctg_meta_find_ctg(struct m0_cas_ctg    *meta,
                                     const struct m0_fid  *ctg_fid,
                                     struct m0_cas_ctg   **ctg);

M0_INTERNAL const struct m0_be_btree_kv_ops *m0_ctg_btree_ops(void);

M0_INTERNAL void m0_ctg_state_inc_update(struct m0_be_tx *tx, uint64_t size);

M0_INTERNAL int ctgdump(struct m0_motr *motr_ctx, char *fidstr,
                        char *dump_in_hex_str);

#endif /* __MOTR_CAS_CTG_STORE_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
 */