client.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_CLIENT_H__
#define __MOTR_CLIENT_H__

#include "lib/vec.h"
#include "lib/types.h"
#include "sm/sm.h"             /* struct m0_sm */
#include "rpc/rpc_machine.h"   /* M0_RPC_DEF_MAX_RPC_MSG_SIZE */
#include "fid/fid.h"
#include "lib/cookie.h"
#include "xcode/xcode_attr.h"
enum m0_entity_opcode {
        M0_EO_INVALID,    /* 0 */
        M0_EO_CREATE,     /* 1 */
        M0_EO_DELETE,     /* 2 */
        M0_EO_SYNC,       /* 3 */
        M0_EO_OPEN,       /* 4 */
        M0_EO_GETATTR,    /* 5 */
        M0_EO_SETATTR,    /* 6 */
        M0_EO_LAYOUT_GET, /* 7 */
        M0_EO_LAYOUT_SET, /* 8 */
        M0_EO_NR          /* 9 */
} M0_XCA_ENUM;

enum m0_obj_opcode {
        M0_OC_READ = M0_EO_NR + 1,  /* 10 */
        M0_OC_WRITE,                /* 11 */
        M0_OC_ALLOC,                /* 12 */
        M0_OC_FREE,                 /* 13 */
        M0_OC_NR                    /* 14 */
} M0_XCA_ENUM;

/* Index operation codes. */
enum m0_idx_opcode {
        M0_IC_GET = M0_OC_NR + 1,  /* 15 */
        M0_IC_PUT,                 /* 16 */
        M0_IC_DEL,                 /* 17 */
        M0_IC_NEXT,                /* 18 */
        M0_IC_LOOKUP,              /* 19 */
        M0_IC_LIST,                /* 20 */
        M0_IC_NR                   /* 21 */
} M0_XCA_ENUM;

enum m0_op_obj_flags {
        M0_OOF_NOHOLE = 1 << 0,
        M0_OOF_SYNC   = 1 << 1
} M0_XCA_ENUM;

enum m0_entity_type {
        M0_ET_REALM,
        M0_ET_OBJ,
        M0_ET_IDX
} M0_XCA_ENUM;

 enum m0_entity_flags {
        M0_ENF_META = 1 << 0,
        M0_ENF_NO_RMW =  1 << 1,
        M0_ENF_DI = 1 << 2
 } M0_XCA_ENUM;

struct m0_op {
        uint64_t                       op_magic;

        unsigned int                   op_code;
        int32_t                        op_rc;
        struct m0_sm_group             op_sm_group;
        struct m0_sm                   op_sm;
        const struct m0_op_ops        *op_cbs;
        struct m0_entity              *op_entity;
        m0_time_t                      op_linger; /* a town in Luxembourg. */
        size_t                         op_size;
        uint64_t                       op_gen;
        struct m0_op                  *op_parent;
        struct m0_sm_ast               op_parent_ast;
        struct m0_tl                   op_pending_tx;
        struct m0_mutex                op_pending_tx_lock;
        /* Operation's private data, can be used as arguments for callbacks.*/
        void                          *op_datum;
        uint64_t                       op_count;
        void                          *op_priv;
        struct m0_mutex                op_priv_lock;
};

enum m0_op_state {
        M0_OS_UNINITIALISED,
        M0_OS_INITIALISED,
        M0_OS_LAUNCHED,
        M0_OS_EXECUTED,
        M0_OS_STABLE,
        M0_OS_FAILED,
        M0_OS_NR
};

struct m0_entity {
        enum m0_entity_type en_type;
        struct m0_uint128   en_id;
        struct m0_realm    *en_realm;
        struct m0_sm        en_sm;
        struct m0_sm_group  en_sm_group;
        struct m0_tl        en_pending_tx;
        struct m0_mutex     en_pending_tx_lock;
        uint32_t            en_flags;
};

struct m0_obj_attr {
        m0_bcount_t   oa_bshift;

        uint64_t      oa_layout_id;

        struct m0_fid oa_pool;

        struct m0_fid oa_pver;

        size_t        oa_buf_size;
};

enum m0_client_layout_type {
        M0_LT_PDCLUST = 0,
        M0_LT_COMPOSITE,
        M0_LT_CAPTURE,
        M0_LT_NR
};

struct m0_client_layout;
struct m0_obj {
        struct m0_entity          ob_entity;
        struct m0_obj_attr        ob_attr;
        struct m0_client_layout  *ob_layout;
        struct m0_cookie   ob_cookie;
};

struct m0_client_layout {
        struct m0_entity            ml_entity;
        enum m0_client_layout_type  ml_type;
        /* Back pointer to the object it belongs to. */
        struct m0_obj              *ml_obj;
        const struct m0_client_layout_ops *ml_ops;
};

struct m0_idx_attr {
        uint32_t      idx_layout_type;
        struct m0_fid idx_pver;
};

struct m0_idx {
        struct m0_entity   in_entity;
        struct m0_idx_attr in_attr;
};

#define M0_COMPOSITE_EXTENT_INF (0xffffffffffffffff)
struct m0_composite_layer_idx_key {
        struct m0_uint128 cek_layer_id;
        m0_bindex_t       cek_off;
};

struct m0_composite_layer_idx_val {
        m0_bcount_t cev_len;
};

enum m0_realm_type {
        M0_ST_CONTAINER,
        M0_ST_EPOCH,
        M0_ST_DTX,
        M0_ST_NR
};

struct m0_client;

struct m0_realm {
        struct m0_entity   re_entity;
        enum m0_realm_type re_type;
        struct m0_client  *re_instance;
};

struct m0_container {
        struct m0_realm co_realm;
};

struct m0_epoch {
        struct m0_realm ep_realm;
};

struct m0__dtx {
        struct m0_realm dt_realm;
};

struct m0_op_ops {
        void (*oop_executed)(struct m0_op *op);
        void (*oop_failed)(struct m0_op *op);
        void (*oop_stable)   (struct m0_op *op);
};

struct m0_config {
        bool        mc_is_oostore;
        bool        mc_is_read_verify;

        bool        mc_is_addb_init;

        const char *mc_local_addr;
        const char *mc_ha_addr;
        const char *mc_process_fid;
        const char *mc_profile;

        uint32_t    mc_tm_recv_queue_min_len;
        uint32_t    mc_max_rpc_msg_size;

        /* TODO: This parameter is added for a temporary solution of
         * layout selection for s3 team. This has to be removed when
         * sophisticated solution is implemented.*/
        uint32_t    mc_layout_id;

        int         mc_idx_service_id;
        void       *mc_idx_service_conf;

        m0_bcount_t mc_addb_size;
};

extern const struct m0_uint128 M0_UBER_REALM;

extern const struct m0_uint128 M0_ID_APP;

struct m0_rm_lock_req;

int m0_obj_lock_init(struct m0_obj *obj);

void m0_obj_lock_fini(struct m0_obj *obj);

int m0_obj_write_lock_get(struct m0_obj *obj,
                        struct m0_rm_lock_req *req,
                        struct m0_clink *clink);

int m0_obj_write_lock_get_sync(struct m0_obj *obj,
                               struct m0_rm_lock_req *req);

int m0_obj_read_lock_get(struct m0_obj *obj,
                         struct m0_rm_lock_req *req,
                         struct m0_clink *clink);

int m0_obj_read_lock_get_sync(struct m0_obj *obj,
                              struct m0_rm_lock_req *req);

void m0_obj_lock_put(struct m0_rm_lock_req *req);

void m0_op_setup(struct m0_op *op,
                 const struct m0_op_ops *cbs,
                 m0_time_t linger);
void m0_op_launch(struct m0_op **op, uint32_t nr);

int32_t m0_op_wait(struct m0_op *op, uint64_t bits, m0_time_t to);

void m0_op_cancel(struct m0_op **op, uint32_t nr);

void m0_op_kick(struct m0_op *op);

int32_t m0_rc(const struct m0_op *op);

void m0_op_fini(struct m0_op *op);

void m0_op_free(struct m0_op *op);

void m0_container_init(struct m0_container        *con,
                       struct m0_realm            *parent,
                       const struct m0_uint128    *id,
                       struct m0_client           *instance);
void m0_epoch_init    (struct m0_epoch            *epoch,
                       struct m0_realm            *parent,
                       const struct m0_uint128    *id);
void m0__dtx_init     (struct m0__dtx             *dtx,
                       struct m0_realm            *parent,
                       const struct m0_uint128    *id);

void m0_obj_init(struct m0_obj           *obj,
                 struct m0_realm         *parent,
                 const struct m0_uint128 *id,
                 uint64_t                 layout_id);
void m0_obj_fini(struct m0_obj *obj);

void m0_obj_idx_init(struct m0_idx       *idx,
                     const struct m0_obj *obj);

int m0_obj_op(struct m0_obj       *obj,
              enum m0_obj_opcode   opcode,
              struct m0_indexvec  *ext,
              struct m0_bufvec    *data,
              struct m0_bufvec    *attr,
              uint64_t             mask,
              uint32_t             flags,
              struct m0_op       **op);

void m0_idx_init(struct m0_idx    *idx,
                        struct m0_realm  *parent,
                        const struct m0_uint128 *id);

void m0_idx_fini(struct m0_idx *idx);

int m0_idx_op(struct m0_idx       *idx,
              enum m0_idx_opcode   opcode,
              struct m0_bufvec    *keys,
              struct m0_bufvec    *vals,
              int32_t             *rcs,
              uint32_t             flags,
              struct m0_op       **op);

void m0_realm_create(struct m0_realm    *realm,
                     uint64_t wcount, uint64_t rcount,
                     struct m0_op **op);

void m0_realm_open(struct m0_realm   *realm,
                   uint64_t wcount, uint64_t rcount,
                   struct m0_op **op);

void m0_realm_close(struct m0_realm   *realm,
                    uint64_t wcount, uint64_t rcount,
                    struct m0_op **op);

int m0_entity_create(struct m0_fid    *pool,
                     struct m0_entity *entity,
                     struct m0_op    **op);
int m0_entity_delete(struct m0_entity *entity,
                     struct m0_op    **op);
int m0_entity_open(struct m0_entity *entity,
                   struct m0_op **op);
void m0_entity_fini(struct m0_entity *entity);

size_t m0_op_maxsize(void);

int m0_client_init(struct m0_client **m0c,
                   struct m0_config *conf,
                   bool init_m0);

void m0_client_fini(struct m0_client *m0c, bool fini_m0);

void m0_process_fid(const struct m0_client *m0c,
                    struct m0_fid *proc_fid);

int m0_sync_op_init(struct m0_op **sop);

int m0_sync_entity_add(struct m0_op *sop,
                       struct m0_entity *ent);
int m0_sync_op_add(struct m0_op *sop,
                   struct m0_op *op);

int m0_entity_sync(struct m0_entity *ent);

int m0_sync(struct m0_client *m0c, bool wait);

uint64_t m0_obj_unit_size_to_layout_id(int unit_size);

int m0_obj_layout_id_to_unit_size(uint64_t layout_id);

uint64_t m0_client_layout_id(const struct m0_client *instance);

enum m0_client_layout_type m0_obj_layout_type(struct m0_obj *obj);

int m0_composite_layer_add(struct m0_client_layout *layout,
                           struct m0_obj *sub_obj, int priority);
void m0_composite_layer_del(struct m0_client_layout *layout,
                            struct m0_uint128 subobj_id);

int m0_composite_layer_idx(struct m0_uint128 layer_id,
                           bool write, struct m0_idx *idx);
int m0_composite_layer_idx_key_to_buf(
                        struct m0_composite_layer_idx_key *key,
                        void **out_kbuf, m0_bcount_t *out_klen);
void m0_composite_layer_idx_key_from_buf(
                        struct m0_composite_layer_idx_key *key,
                        void *kbuf);
int m0_composite_layer_idx_val_to_buf(
                        struct m0_composite_layer_idx_val *val,
                        void **out_vbuf, m0_bcount_t *out_vlen);
void m0_composite_layer_idx_val_from_buf(
                        struct m0_composite_layer_idx_val *val,
                        void *vbuf);

int m0_client_layout_op(struct m0_obj          *obj,
                 enum m0_entity_opcode          opcode,
                 struct m0_client_layout       *layout,
                 struct m0_op                 **op);

int m0_client_layout_capture(struct m0_client_layout *layout,
                      struct m0_obj *obj,
                      struct m0_client_layout **out);

/* Allocate/free in-memory layout data struct for an object. */
struct m0_client_layout*
m0_client_layout_alloc(enum m0_client_layout_type type);
void m0_client_layout_free(struct m0_client_layout *layout);

//** @} end of client group */

#include "motr/idx.h" /* export m0_idx operations and services to client. */
#include "cas/cas.h"

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