cas.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_CAS_H__
#define __MOTR_CAS_CAS_H__

#include "xcode/xcode_attr.h"
#include "fid/fid.h"
#include "fid/fid_xc.h"
#include "lib/types.h"
#include "lib/buf.h"
#include "lib/buf_xc.h"
#include "lib/cookie.h"
#include "lib/cookie_xc.h"
#include "rpc/at.h"             /* m0_rpc_at_buf */
#include "rpc/at_xc.h"          /* m0_rpc_at_buf_xc */
#include "fop/wire.h"           /* m0_fop_mod_rep */
#include "fop/wire_xc.h"
#include "fop/fom_interpose.h"  /* m0_fom_thralldom */
#include "dix/layout.h"
#include "dix/layout_xc.h"
#include "dtm0/tx_desc.h"       /* tx_desc */
#include "dtm0/tx_desc_xc.h"    /* xc for tx_desc */

/* Import */
struct m0_sm_conf;
struct m0_fom_type_ops;
struct m0_reqh_service_type;

struct m0_cas_hint {
        struct m0_cookie ch_cookie;
        uint64_t         ch_index;
} M0_XCA_RECORD M0_XCA_DOMAIN(rpc);

struct m0_cas_id {
        struct m0_fid          ci_fid;
        struct m0_cas_hint     ci_hint;
        struct m0_dix_layout   ci_layout;
} M0_XCA_RECORD M0_XCA_DOMAIN(rpc);

struct m0_cas_kv {
        struct m0_rpc_at_buf ck_key;
        struct m0_rpc_at_buf ck_val;
} M0_XCA_RECORD M0_XCA_DOMAIN(rpc);

struct m0_cas_kv_vec {
        uint64_t          cv_nr;
        struct m0_cas_kv *cv_rec;
} M0_XCA_SEQUENCE M0_XCA_DOMAIN(rpc);

struct m0_crv {
        uint64_t crv_encoded;
} M0_XCA_RECORD M0_XCA_DOMAIN(rpc|be);

struct m0_cas_rec {
        struct m0_rpc_at_buf cr_key;

        struct m0_rpc_at_buf cr_val;

        struct m0_cas_kv_vec cr_kv_bufs;

        struct m0_cas_hint   cr_hint;

        uint64_t             cr_rc;

        struct m0_crv cr_ver;
} M0_XCA_RECORD M0_XCA_DOMAIN(rpc);

struct m0_cas_recv {
        uint64_t           cr_nr;
        struct m0_cas_rec *cr_rec;
} M0_XCA_SEQUENCE M0_XCA_DOMAIN(rpc);

enum m0_cas_op_flags {
        COF_SLANT     = 1 << 0,
        COF_CREATE    = 1 << 1,
        COF_OVERWRITE = 1 << 2,
        COF_CROW      = 1 << 3,
        COF_RESERVE   = 1 << 4,
        COF_DEL_LOCK  = 1 << 5,
        COF_EXCLUDE_START_KEY = 1 << 6,
        COF_SYNC_WAIT = 1 << 7,
        COF_SKIP_LAYOUT = 1 << 8,

        COF_VERSIONED = 1 << 9,

        COF_SHOW_DEAD = 1 << 10,
        COF_NO_DTM = 1 << 11,
};

enum m0_cas_opcode {
        CO_GET,
        CO_PUT,
        CO_DEL,
        CO_CUR,
        CO_REP,
        CO_GC,
        CO_MIN,
        CO_TRUNC,
        CO_DROP,
        CO_MEM_PLACE,
        CO_MEM_FREE,
        CO_NR
} M0_XCA_ENUM;

enum m0_cas_type {
        CT_META,
        CT_BTREE,
        CT_DEAD_INDEX,
        CT_MEM
} M0_XCA_ENUM;

struct m0_cas_op {
        struct m0_cas_id       cg_id;

        struct m0_cas_recv     cg_rec;

        uint32_t               cg_flags;

        struct m0_dtm0_tx_desc cg_txd;
} M0_XCA_RECORD M0_XCA_DOMAIN(rpc);

struct m0_cas_rep {
        int32_t                 cgr_rc;

        struct m0_cas_recv      cgr_rep;

        struct m0_fop_mod_rep   cgr_mod_rep;
} M0_XCA_RECORD M0_XCA_DOMAIN(rpc);

M0_EXTERN struct m0_reqh_service_type m0_cas_service_type;
M0_EXTERN const struct m0_fid         m0_cas_meta_fid;
M0_EXTERN const struct m0_fid         m0_cas_dead_index_fid;
M0_EXTERN const struct m0_fid         m0_cas_ctidx_fid;
M0_EXTERN const struct m0_fid_type    m0_cas_index_fid_type;
M0_EXTERN const struct m0_fid_type    m0_dix_fid_type;
M0_EXTERN const struct m0_fid_type    m0_cctg_fid_type;

M0_EXTERN struct m0_fop_type cas_get_fopt;
M0_EXTERN struct m0_fop_type cas_put_fopt;
M0_EXTERN struct m0_fop_type cas_del_fopt;
M0_EXTERN struct m0_fop_type cas_cur_fopt;
M0_EXTERN struct m0_fop_type cas_rep_fopt;
M0_EXTERN struct m0_fop_type cas_gc_fopt;
extern    struct m0_fop_type m0_fop_fsync_cas_fopt;

#ifndef __KERNEL__
M0_INTERNAL void m0_cas_svc_init(void);
M0_INTERNAL void m0_cas_svc_fini(void);
M0_INTERNAL void m0_cas_svc_fop_args(struct m0_sm_conf            **sm_conf,
                                     const struct m0_fom_type_ops **fom_ops,
                                     struct m0_reqh_service_type  **svctype);
M0_INTERNAL void m0_cas__ut_svc_be_set(struct m0_reqh_service *svc,
                                       struct m0_be_domain *dom);
M0_INTERNAL struct m0_be_domain *
m0_cas__ut_svc_be_get(struct m0_reqh_service *svc);
M0_INTERNAL int m0_cas_fom_spawn(
        struct m0_fom           *lead,
        struct m0_fom_thralldom *thrall,
        struct m0_fop           *cas_fop,
        void                   (*on_fom_complete)(struct m0_fom_thralldom *,
                                                  struct m0_fom           *));
#else
#define m0_cas_svc_init()
#define m0_cas_svc_fini()
#define m0_cas_svc_fop_args(sm_conf, fom_ops, svctype) \
do {                                                   \
        *(sm_conf) = NULL;                             \
        *(fom_ops) = NULL;                             \
        *(svctype) = NULL;                             \
} while (0);
#endif /* __KERNEL__ */

M0_INTERNAL void m0_cas_id_fini(struct m0_cas_id *cid);
M0_INTERNAL bool m0_cas_id_invariant(const struct m0_cas_id *cid);

M0_INTERNAL bool cas_in_ut(void);

enum {
        /* Tombstone flag: marks a dead kv pair. We use the MSB here. */
        M0_CRV_TBS = 1L << (sizeof(uint64_t) * CHAR_BIT - 1),
        /*
         * A special value for the empty version.
         * A record with the empty version is always overwritten by any
         * PUT or DEL operation that has a valid non-empty version.
         * A PUT or DEL operation with the empty version always ignores
         * the version-aware behavior: records are actually removed by DEL,
         * and overwritten by PUT, no matter what was stored in the catalogue.
         */
        M0_CRV_VER_NONE = 0,
        /* The maximum possible value of a version. */
        M0_CRV_VER_MAX = (UINT64_MAX & ~M0_CRV_TBS) - 1,
        /* The minimum possible value of a version. */
        M0_CRV_VER_MIN = M0_CRV_VER_NONE + 1,
};

/*
 * 100:a == alive record with version 100
 * 123:d == dead record with version 123
 */
#define CRV_F "%" PRIu64 ":%c"
#define CRV_P(__crv) m0_crv_ts(__crv).dts_phys, m0_crv_tbs(__crv) ? 'd' : 'a'

#define M0_CRV_INIT_NONE ((struct m0_crv) { .crv_encoded = M0_CRV_VER_NONE })

M0_INTERNAL void m0_crv_init(struct m0_crv           *crv,
                             const struct m0_dtm0_ts *ts,
                             bool                     tbs);

M0_INTERNAL bool m0_crv_is_none(const struct m0_crv *crv);
M0_INTERNAL int m0_crv_cmp(const struct m0_crv *left,
                           const struct m0_crv *right);

M0_INTERNAL bool m0_crv_tbs(const struct m0_crv *crv);
M0_INTERNAL void m0_crv_tbs_set(struct m0_crv *crv, bool tbs);

M0_INTERNAL struct m0_dtm0_ts m0_crv_ts(const struct m0_crv *crv);
M0_INTERNAL void m0_crv_ts_set(struct m0_crv           *crv,
                               const struct m0_dtm0_ts *ts);

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