fop.h

Go to the documentation of this file.

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

#include "lib/types.h"
#include "lib/list.h"
#include "lib/refs.h"
#include "lib/errno.h"
#include "fol/fol.h"
#include "fop/fom.h"
#include "rpc/item.h"
#include "net/net_otw_types.h"

/* import */
struct m0_fol;
struct m0_db_tx;
struct m0_xcode_type;

/* export */
struct m0_fop_data;
struct m0_fop;
struct m0_fop_fol_frag;

struct m0_fop_data {
        void            *fd_data;
};

struct m0_fop {
        struct m0_ref       f_ref;
        struct m0_fop_type *f_type;
        struct m0_fop_data  f_data;
        struct m0_rpc_item  f_item;
        void               *f_opaque;
};

M0_INTERNAL void m0_fop_init(struct m0_fop *fop, struct m0_fop_type *fopt,
                             void *data, void (*fop_release)(struct m0_ref *));

M0_INTERNAL void m0_fop_fini(struct m0_fop *fop);

struct m0_fop *m0_fop_get(struct m0_fop *fop);

void m0_fop_put(struct m0_fop *fop);
void m0_fop_put0(struct m0_fop *fop);

void m0_fop_put_lock(struct m0_fop *fop);
void m0_fop_put0_lock(struct m0_fop *fop);

struct m0_fop *m0_fop_alloc(struct m0_fop_type *fopt, void *data,
                            struct m0_rpc_machine *mach);
struct m0_fop *m0_fop_alloc_at(struct m0_rpc_session *sess,
                               struct m0_fop_type *fopt);
struct m0_fop *m0_fop_reply_alloc(struct m0_fop *req,
                                  struct m0_fop_type *fopt);

M0_INTERNAL void m0_fop_release(struct m0_ref *ref);
void *m0_fop_data(const struct m0_fop *fop);

M0_INTERNAL int m0_fop_data_alloc(struct m0_fop *fop);

struct m0_rpc_item *m0_fop_to_rpc_item(const struct m0_fop *fop);
struct m0_fop *m0_rpc_item_to_fop(const struct m0_rpc_item *item);
void m0_fop_rpc_machine_set(struct m0_fop *fop, struct m0_rpc_machine *mach);
struct m0_rpc_machine *m0_fop_rpc_machine(const struct m0_fop *fop);
uint32_t m0_fop_opcode(const struct m0_fop *fop);
M0_INTERNAL const char *m0_fop_name(const struct m0_fop *fop);
struct m0_net_transfer_mc *m0_fop_tm_get(const struct m0_fop *fop);
struct m0_net_domain *m0_fop_domain_get(const struct m0_fop *fop);

M0_INTERNAL struct m0_fop_type *m0_item_type_to_fop_type
    (const struct m0_rpc_item_type *rit);

#define M0_FOP_DEFAULT_ITEM_TYPE_OPS \
        .rito_encode       = m0_fop_item_type_default_encode,      \
        .rito_decode       = m0_fop_item_type_default_decode,      \
        .rito_payload_size = m0_fop_payload_size,                  \
        .rito_item_get     = m0_fop_item_get,                      \
        .rito_item_put     = m0_fop_item_put

extern const struct m0_rpc_item_type_ops m0_fop_default_item_type_ops;

struct m0_fop_type {
        const char                       *ft_name;
        struct m0_tlink                   ft_linkage;
        const struct m0_fop_type_ops     *ft_ops;
        const struct m0_xcode_type       *ft_xt;
        struct m0_fom_type                ft_fom_type;
        struct m0_rpc_item_type           ft_rpc_item_type;
        uint64_t                          ft_magix;
};

M0_INTERNAL struct m0_fop_type *m0_fop_type_next(struct m0_fop_type *ftype);

M0_INTERNAL struct m0_fop_type *m0_fop_type_find(uint32_t opcode);

struct m0_fop_type_ops {
        void (*fto_fop_replied)(struct m0_fop *fop, struct m0_fop *bfop);
        int (*fto_io_coalesce)(struct m0_fop *fop, uint64_t rpc_size);
        void (*fto_io_desc_get)(struct m0_fop *fop,
                                struct m0_net_buf_desc_data **desc);
        int (*fto_undo)(struct m0_fop_fol_frag *ffrag, struct m0_fol *fol);
        int (*fto_redo)(struct m0_fop_fol_frag *ffrag, struct m0_fol *fol);
};

typedef uint32_t m0_fop_type_code_t;

struct __m0_fop_type_init_args {
        const char                        *name;
        uint32_t                           opcode;
        uint64_t                           rpc_flags;
        const struct m0_xcode_type        *xt;
        const struct m0_fop_type_ops      *fop_ops;
        const struct m0_fom_type_ops      *fom_ops;
        const struct m0_rpc_item_type_ops *rpc_ops;
        const struct m0_sm_conf           *sm;
        const struct m0_reqh_service_type *svc_type;
};

void m0_fop_type_init(struct m0_fop_type *ft,
                      const struct __m0_fop_type_init_args *args);

#define M0_FOP_TYPE_INIT(ft, ...)                                        \
        m0_fop_type_init((ft), &(const struct __m0_fop_type_init_args) { \
                        __VA_ARGS__ });

#define M0_FOP_TYPE_INIT2_DECL struct __m0_fop_type_init_args __args
#define M0_FOP_TYPE_INIT2(ft, ...) ({                                    \
        __args = (struct __m0_fop_type_init_args) {__VA_ARGS__};         \
        m0_fop_type_init((ft), &__args); })

void m0_fop_type_fini(struct m0_fop_type *fopt);

struct m0_fop_type_batch {
        struct m0_fop_type             *tb_type;
        struct __m0_fop_type_init_args  tb_args;
};

M0_INTERNAL void m0_fop_type_init_nr(const struct m0_fop_type_batch *batch);
M0_INTERNAL void m0_fop_type_fini_nr(const struct m0_fop_type_batch *batch);

M0_INTERNAL int m0_fops_init(void);
M0_INTERNAL void m0_fops_fini(void);

#define M0_FOP_XCODE_OBJ(f) (struct m0_xcode_obj) {     \
                .xo_type = f->f_type->ft_xt,            \
                .xo_ptr  = m0_fop_data(f),              \
}

M0_INTERNAL int m0_fop_encdec(struct m0_fop           *fop,
                              struct m0_bufvec_cursor *cur,
                              enum m0_xcode_what       what);

M0_INTERNAL int m0_fop_xc_type(const struct m0_xcode_obj   *par,
                               const struct m0_xcode_type **out);

M0_INTERNAL int m0_fop_rep_xc_type(const struct m0_xcode_obj   *par,
                                   const struct m0_xcode_type **out);

struct m0_fop_fol_frag {
        uint32_t  ffrp_fop_code;
        uint32_t  ffrp_rep_code;
        void     *ffrp_fop M0_XCA_OPAQUE("m0_fop_xc_type");
        void     *ffrp_rep M0_XCA_OPAQUE("m0_fop_rep_xc_type");
} M0_XCA_RECORD;

M0_INTERNAL int m0_fop_fol_add(struct m0_fop *fop, struct m0_fop *rep,
                               struct m0_dtx *dtx);

extern struct m0_fol_frag_type m0_fop_fol_frag_type;

struct m0_rpc_machine *m0_fop_session_machine(const struct m0_rpc_session *s);

enum m0_addb2_fop_counter {
        M0_AFC_PHASE,
        M0_AFC_STATE,
        M0_AFC_RPC_OUT,
        M0_AFC_RPC_IN
};

int m0_fop_type_addb2_instrument(struct m0_fop_type *type);

void m0_fop_type_addb2_deinstrument(struct m0_fop_type *type);

#endif /* __MOTR_FOP_FOP_H__ */

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