client_internal.h

Go to the documentation of this file.

/* -*- C -*- */
/*
 * Copyright (c) 2016-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_CLIENT_INTERNAL_H__
#define __MOTR_CLIENT_INTERNAL_H__

#ifdef __KERNEL__
#define M0_CLIENT_THREAD_ENTER M0_THREAD_ENTER
#else
#define M0_CLIENT_THREAD_ENTER
#endif

#define OP_OBJ2CODE(op_obj) op_obj->oo_oc.oc_op.op_code

#define OP_IDX2CODE(op_idx) op_idx->oi_oc.oc_op.op_code

#define MOCK
#define CLIENT_FOR_M0T1FS

#include "module/instance.h"
#include "motr/init.h"

#include "ioservice/io_fops.h"  /* m0_io_fop_{init,fini,release} */
#include "conf/schema.h"        /* m0_conf_service_type */
#include "conf/confc.h"         /* m0_confc */
#include "layout/pdclust.h"     /* struct m0_pdclust_attr */
#include "pool/pool.h"          /* struct m0_pool */
#include "reqh/reqh.h"          /* struct m0_reqh */
#include "rm/rm.h"              /* stuct m0_rm_owner */
#include "rm/rm_rwlock.h"       /* enum m0_rm_rwlock_req_type */
#include "lib/refs.h"
#include "lib/hash.h"
#include "file/file.h"          /* struct m0_file */
#include "motr/ha.h"            /* m0_motr_ha */
#include "addb2/identifier.h"

#include "be/ut/helper.h"       /* struct m0_be_ut_backend */

#include "motr/client.h"      /* m0_* */
#include "motr/idx.h"  /* m0_idx_* */
#include "motr/pg.h"          /* nwxfer and friends */
#include "motr/sync.h"        /* sync_request */
#include "fop/fop.h"
#include "dtm0/domain.h"        /* m0_dtm0_domain */

struct m0_idx_service_ctx;
struct m0_dtm0_service;
struct m0_dtx;

#ifdef CLIENT_FOR_M0T1FS

#define MOTR_MDCOB_LOOKUP_SKIP 3

enum {
        M0_OBJ_NAME_MAX_LEN = 64
};
#endif

enum {
        M0_RM_HBUCKET_NR = 100
};

enum m0__entity_states {
        M0_ES_INIT = 1,
        M0_ES_CREATING,
        M0_ES_DELETING,
        M0_ES_OPENING,
        M0_ES_OPEN,
        M0_ES_CLOSING,
        M0_ES_FAILED
};

enum  m0_pbuf_type {
        M0_PBUF_DIR,
        M0_PBUF_IND,
        M0_PBUF_NONE
};

M0_INTERNAL bool entity_invariant_full(struct m0_entity *ent);
M0_INTERNAL bool entity_invariant_locked(const struct m0_entity *ent);

void m0_op_fini(struct m0_op *op);

struct m0_ast_rc {
        struct m0_sm_ast        ar_ast;
        int                     ar_rc;
        uint64_t                ar_magic;

};

/*
 * Client has a number of nested structures, all of which are passed to the
 * application as a 'struct m0_op'. The application may in fact
 * allocate some of these structures, without knowing what they are, or how
 * big they should be. 'struct m0_op' is always the first member, and
 * contains all the fields the application is permitted to change.
 *
 * A 'struct m0_op' is always contained in a
 * 'struct m0_op_common'. This contains the fields that are common to
 * all operations, namely the launch/executed/finalise callbacks. The
 * application is not permitted to change (or even see) these.
 *
 * Operations then have a different 'super type' depending on whether they are
 * operating on an object, index or realm.
 *
 * Object operations always have a 'struct m0_op_obj', this represents
 * the namespace/metadata aspects of the object, such as its layout. Operations
 * such as create/delete will use this struct as the root 'type' of their work,
 * as they don't need IO buffers etc.
 *
 * 'struct m0_op_io' is the last (and biggest/highest) type, it contains
 * the databuf and paritybuf arrays for reading/writing object data.
 *
 *                   +---m0_op_common-----------+
 *                   |                          |
 *                   |    +-m0_op--------+      |
 *                   |    |              |      |
 *                   |    +--------------+      |
 *                   |                          |
 *                   +--------------------------+
 *
 *                  \/_                        _\/
 *
 * +m0_op_io---------------+      +m0_op_idx--------------+
 * | +m0_op_obj---------+  |      |                       |
 * | |                  |  |      | [m0_op_common]        |
 * | |  [m0_op_common]  |  |      |                       |
 * | |                  |  |      +-----------------------+
 * | +------------------+  |
 * |                       |
 * +-----------------------+
 *
 *  +m0_op_md---------------+     +m0_op_sync-------------+
 *  |                       |     |                       |
 *  | [m0_op_common]        |     | [m0_op_common]        |
 *  |                       |     |                       |
 *  +-----------------------+     +-----------------------+
 *
 */
struct m0_op_common {
        struct m0_op           oc_op;
        uint64_t               oc_magic;

#ifdef MOCK
        /* Timer used to move sm between states*/
        struct m0_sm_timer     oc_sm_timer;
#endif

        void                 (*oc_cb_launch)(struct m0_op_common *oc);
        void                 (*oc_cb_replied)(struct m0_op_common *oc);
        void                 (*oc_cb_cancel)(struct m0_op_common *oc);
        void                 (*oc_cb_fini)(struct m0_op_common *oc);
        void                 (*oc_cb_free)(struct m0_op_common *oc);

        /* Callback operations for states*/
        void                 (*oc_cb_executed)(void *args);
        void                 (*oc_cb_stable)(void *args);
        void                 (*oc_cb_failed)(void *args);
};

struct m0_op_idx {
        struct m0_op_common  oi_oc;
        uint64_t             oi_magic;

        struct m0_idx       *oi_idx;

        /* K-V pairs */
        struct m0_bufvec    *oi_keys;
        struct m0_bufvec    *oi_vals;

        /* Hold per key-value query return code. */
        int32_t             *oi_rcs;

        /* Number of queries sent to index*/
        int32_t              oi_nr_queries;
        bool                 oi_query_rc;

        struct m0_sm_group  *oi_sm_grp;
        struct m0_ast_rc     oi_ar;

        /* A bit-mask of m0_op_idx_flags. */
        uint32_t             oi_flags;

        struct m0_sm_ast    oi_ast;
        struct dix_req     *oi_dix_req;
        bool                oi_in_completion;

        struct m0_dtx      *oi_dtx;
};

struct m0_op_obj {
        struct m0_op_common         oo_oc;
        uint64_t                    oo_magic;

        struct m0_sm_group         *oo_sm_grp;
        struct m0_ast_rc            oo_ar;

        struct m0_fid               oo_fid;
#ifdef CLIENT_FOR_M0T1FS
        struct m0_fid               oo_pfid;
        struct m0_buf               oo_name;
#endif
        struct m0_fid               oo_pver;     /* cob pool version */
        struct m0_layout_instance  *oo_layout_instance;

        /* MDS fop */
        struct m0_fop              *oo_mds_fop;
};

struct m0_op_io {
        struct m0_op_obj                  ioo_oo;
        uint64_t                          ioo_magic;

        struct m0_obj                    *ioo_obj;

        struct m0_indexvec                ioo_ext;

        struct m0_bufvec                  ioo_data;
        struct m0_bufvec                  ioo_attr;

        uint64_t                          ioo_attr_mask;
        uint32_t                          ioo_flags;
        struct m0_fid                     ioo_pver;

        int32_t                           ioo_rc;

        struct pargrp_iomap             **ioo_iomaps;

        uint64_t                          ioo_iomap_nr;

        enum m0_pbuf_type                 ioo_pbuf_type;
        uint64_t                          ioo_rmw_read_pages;

        struct m0_sm                      ioo_sm;

        const struct m0_op_io_ops        *ioo_ops;

        struct m0_file                    ioo_flock;

        struct nw_xfer_request            ioo_nwxfer;

        enum sns_repair_state             ioo_sns_state;

        uint64_t                        *ioo_failed_session;

        uint64_t                        *ioo_failed_nodes;

        uint32_t                         ioo_dgmap_nr;
        bool                             ioo_dgmode_io_sent;

        uint64_t                         ioo_copied_nr;

        uint64_t                         ioo_map_idx;

        struct m0_sm_ast                 ioo_ast;

        struct m0_sm_ast                 ioo_done_ast;

        struct m0_clink                  ioo_clink;

        struct m0_chan                   ioo_completion;

        bool                             ioo_rect_needed;

        int                              ioo_addb2_mapped;
};

struct m0_io_args {
        struct m0_obj      *ia_obj;
        enum m0_obj_opcode  ia_opcode;
        struct m0_indexvec *ia_ext;
        struct m0_bufvec   *ia_data;
        struct m0_bufvec   *ia_attr;
        uint64_t            ia_mask;
        uint32_t            ia_flags;
};

struct m0_op_md {
        struct m0_op_common mdo_oc;
        struct m0_bufvec    mdo_key;
        struct m0_bufvec    mdo_val;
        struct m0_bufvec    mdo_chk;
};

bool m0_op_md_invariant(const struct m0_op_md *mop);

union m0_max_size_op {
        struct m0_op_io io;
        struct m0_op_md md;
};

struct m0_op_sync {
        struct m0_op_common  os_oc;
        uint64_t             os_magic;

        struct m0_sm_group  *os_sm_grp;
        struct m0_ast_rc     os_ar;

        struct sync_request *os_req;

        int32_t              os_mode;
};

enum m0_cob_req_states {
        COB_REQ_ACTIVE,
        COB_REQ_SENDING,
        COB_REQ_DONE,
} M0_XCA_ENUM;

struct m0_ios_cob_req {
        struct m0_op_obj *icr_oo;
        uint32_t          icr_index;
        struct m0_ast_rc  icr_ar;
        uint64_t          icr_magic;
};

struct m0_client_layout_ops {
        int  (*lo_alloc) (struct m0_client_layout **);
        int  (*lo_get) (struct m0_client_layout *);
        void (*lo_put) (struct m0_client_layout *);
        int  (*lo_io_build)(struct m0_io_args *io_args, struct m0_op **op);
};

enum {
        /*  4K, typical linux/intel page size */
#ifdef CONFIG_X86_64
        M0_DEFAULT_BUF_SHIFT        = 12,
#elif defined (CONFIG_AARCH64)
        M0_DEFAULT_BUF_SHIFT        = 16,
#else
#error  "The platform is not supported"
#endif
        /* 512, typical disk sector */
        M0_MIN_BUF_SHIFT            = 9,

        /* RPC */
        M0_RPC_TIMEOUT              = 60, /* Seconds */
        M0_RPC_MAX_RETRIES          = 60,
        M0_RPC_RESEND_INTERVAL      = M0_MKTIME(M0_RPC_TIMEOUT, 0) /
                                          M0_RPC_MAX_RETRIES,
        M0_MAX_NR_RPC_IN_FLIGHT     = 100,

        M0_AST_THREAD_TIMEOUT       = 10,
        M0_MAX_NR_CONTAINERS        = 1024,

        M0_MAX_NR_IOS               = 128,
        M0_MD_REDUNDANCY            = 3,

        /*
         * These constants are used to create buffers acceptable to the
         * network code.
         */
        
#ifdef CONFIG_X86_64
        M0_NETBUF_MASK              = 4096 - 1,
        M0_NETBUF_SHIFT             = 12,
#elif defined (CONFIG_AARCH64)
        M0_NETBUF_MASK              = 65536 - 1,
        M0_NETBUF_SHIFT             = 16,
#else
#error  "The platform is not supported"
#endif
};

enum initlift_direction {
        SHUTDOWN = -1,
        STARTUP = 1,
};

struct m0_client {
        uint64_t                                m0c_magic;

        struct m0                              *m0c_motr;

        struct m0_sm_group                      m0c_sm_group;

        struct m0_reqh                          m0c_reqh;

        struct m0_clink                         m0c_conf_exp;
        struct m0_clink                         m0c_conf_ready;
        struct m0_clink                         m0c_conf_ready_async;

        struct m0_fid                           m0c_process_fid;
        struct m0_fid                           m0c_profile_fid;

        struct m0_pools_common                  m0c_pools_common;

        struct m0_reqh_service_ctx             *m0c_ha_rsctx;

        struct m0_motr_ha                       m0c_motr_ha;

        struct m0_idx_service_ctx               m0c_idx_svc_ctx;

        struct m0_atomic64                      m0c_pending_io_nr;

        struct m0_confc_update_state            m0c_confc_state;

        struct m0_chan                          m0c_conf_ready_chan;

        struct m0_ref                           m0c_ongoing_io;

        /* Also required for confc to connect! */
        struct m0_thread                        m0c_astthread;

        bool                                    m0c_astthread_active;

        struct m0_chan                          m0c_io_wait;

#ifdef CLIENT_FOR_M0T1FS

        struct m0_fid                           m0c_root_fid;

        int                                     m0_namelen;
#endif

        char                                   *m0c_laddr;
        struct m0_net_xprt                     *m0c_xprt;
        struct m0_net_domain                    m0c_ndom;
        struct m0_net_buffer_pool               m0c_buffer_pool;
        struct m0_rpc_machine                   m0c_rpc_machine;

        struct m0_config                       *m0c_config;

        struct m0_sm                            m0c_initlift_sm;
        enum initlift_direction                 m0c_initlift_direction;
        int                                     m0c_initlift_rc;

#ifdef MOCK
        struct m0_htable                        m0c_mock_entities;
#endif

        struct m0_htable                        m0c_rm_ctxs;

        struct m0_dtm0_service                 *m0c_dtms;

        struct m0_dtm0_domain                   m0c_dtm0_domain;
};

extern struct m0_semaphore cpus_sem;

struct m0_rm_lock_ctx {
        struct m0_rw_lockable   rmc_rw_file;
        struct m0_rm_owner      rmc_owner;
        struct m0_rm_remote     rmc_creditor;
        struct m0_fid           rmc_key;
        struct m0_fid           rmc_own_fid;
        struct m0_ref           rmc_ref;
        struct m0_htable       *rmc_htable;
        struct m0_hlink         rmc_hlink;
        uint64_t                rmc_magic;
        uint64_t                rmc_gen;
};

M0_HT_DECLARE(rm_ctx, M0_INTERNAL, struct m0_rm_lock_ctx, struct m0_fid);

struct m0_rm_lock_req {
        struct m0_rm_incoming rlr_in;
        struct m0_mutex       rlr_mutex;
        int32_t               rlr_rc;
        struct m0_chan        rlr_chan;
};

M0_INTERNAL int m0_obj_lock_get(struct m0_obj *obj,
                                struct m0_rm_lock_req *req,
                                struct m0_clink *clink,
                                enum m0_rm_rwlock_req_type rw_type);

M0_INTERNAL int m0_obj_lock_get_sync(struct m0_obj *obj,
                                     struct m0_rm_lock_req *req,
                                     enum m0_rm_rwlock_req_type rw_type);

extern const struct m0_bob_type oc_bobtype;
extern const struct m0_bob_type oo_bobtype;
extern const struct m0_bob_type op_bobtype;
extern const struct m0_bob_type ar_bobtype;

M0_BOB_DECLARE(M0_INTERNAL, m0_op_common);
M0_BOB_DECLARE(M0_INTERNAL, m0_op_obj);
M0_BOB_DECLARE(M0_INTERNAL, m0_op);
M0_BOB_DECLARE(M0_INTERNAL, m0_ast_rc);

M0_INTERNAL int m0_client_global_init(void);
M0_INTERNAL void m0_client_global_fini(void);

M0_INTERNAL struct m0_confc* m0_confc(struct m0_client *m0c);

M0_INTERNAL int m0_op_executed(struct m0_op *op);
M0_INTERNAL int m0_op_stable(struct m0_op *op);
M0_INTERNAL int m0_op_failed(struct m0_op *op);
M0_INTERNAL int m0_op_get(struct m0_op **op, size_t size);

M0_INTERNAL struct m0_client *
m0__entity_instance(const struct m0_entity *entity);

M0_INTERNAL struct m0_client *
m0__op_instance(const struct m0_op *op);

M0_INTERNAL struct m0_op *
m0__ioo_to_op(struct m0_op_io *ioo);

M0_INTERNAL struct m0_client *
m0__obj_instance(const struct m0_obj *obj);

M0_INTERNAL struct m0_client*
m0__oo_instance(struct m0_op_obj *oo);

M0_INTERNAL bool m0__is_oostore(struct m0_client *instance);

/* sm conf that needs registering by m0_client_init */
extern struct m0_sm_conf m0_op_conf;
extern struct m0_sm_conf entity_conf;

/* used by the entity code to create operations */
M0_INTERNAL int m0_op_alloc(struct m0_op **op, size_t op_size);

M0_INTERNAL int m0_op_init(struct m0_op *op,
                           const struct m0_sm_conf *conf,
                           struct m0_entity *entity);

/* XXX juan: add doxygen */
M0_INTERNAL void m0_client_init_io_op(void);

M0_INTERNAL bool m0_op_obj_ast_rc_invariant(struct m0_ast_rc *ar);

M0_INTERNAL bool m0_op_obj_invariant(struct m0_op_obj *oo);

M0_INTERNAL bool m0_op_io_invariant(const struct m0_op_io *iop);

M0_INTERNAL struct m0_rpc_session *
m0_obj_container_id_to_session(struct m0_pool_version *pv,
                               uint64_t container_id);

M0_INTERNAL struct m0_locality *
m0__locality_pick(struct m0_client *cinst);

M0_INTERNAL bool
m0__obj_poolversion_is_valid(const struct m0_obj *obj);

M0_INTERNAL int m0__obj_namei_send(struct m0_op_obj *oo);

M0_INTERNAL int m0__obj_namei_cancel(struct m0_op *op);

M0_INTERNAL int m0__idx_cancel(struct m0_op_idx *oi);

M0_INTERNAL int m0__obj_attr_get_sync(struct m0_obj *obj);

M0_INTERNAL int m0_layout_mds_lookup(struct m0_client         *m0c,
                                     uint64_t                  lid,
                                     struct m0_client_layout **l_out);

M0_INTERNAL void m0_entity_init(struct m0_entity         *entity,
                                struct m0_realm          *parent,
                                const struct m0_uint128  *id,
                                const enum m0_entity_type type);
M0_INTERNAL int
m0__obj_pool_version_get(struct m0_obj *obj,
                         struct m0_pool_version **pv);

M0_INTERNAL uint64_t
m0__obj_layout_id_get(struct m0_op_obj *oo);

M0_INTERNAL int
m0__obj_layout_instance_build(struct m0_client           *cinst,
                              const uint64_t              layout_id,
                              const struct m0_fid        *fid,
                              struct m0_layout_instance **linst);

M0_INTERNAL int m0__cob_poolversion_get(struct m0_obj *obj);

M0_INTERNAL int obj_fid_make_name(char *name, size_t name_len,
                                  const struct m0_fid *fid);
M0_INTERNAL struct m0_obj*
m0__obj_entity(struct m0_entity *entity);
M0_INTERNAL uint64_t m0__obj_lid(struct m0_obj *obj);
M0_INTERNAL enum m0_client_layout_type
m0__obj_layout_type(struct m0_obj *obj);
M0_INTERNAL struct m0_fid m0__obj_pver(struct m0_obj *obj);
M0_INTERNAL void m0__obj_attr_set(struct m0_obj *obj,
                                  struct m0_fid  pver,
                                  uint64_t       lid);
M0_INTERNAL bool
m0__obj_pool_version_is_valid(const struct m0_obj *obj);
M0_INTERNAL bool m0__obj_is_parity_verify_mode(struct m0_client *instance);
M0_INTERNAL bool m0__obj_is_di_enabled(struct m0_op_io *ioo);
M0_INTERNAL bool m0__obj_is_cksum_validation_allowed(struct m0_op_io *ioo);
M0_INTERNAL int m0__obj_io_build(struct m0_io_args *args,
                                 struct m0_op     **op);
M0_INTERNAL void m0__obj_op_done(struct m0_op *op);

M0_INTERNAL bool m0__is_read_op(struct m0_op *op);
M0_INTERNAL bool m0__is_update_op(struct m0_op *op);

M0_INTERNAL int m0__io_ref_get(struct m0_client *m0c);
M0_INTERNAL void m0__io_ref_put(struct m0_client *m0c);
M0_INTERNAL struct m0_file *m0_client_fop_to_file(struct m0_fop *fop);
M0_INTERNAL bool entity_id_is_valid(const struct m0_uint128 *id);

M0_INTERNAL struct m0_client *
m0__idx_instance(const struct m0_idx *idx);

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