mem_xprt.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_NET_BULK_MEM_XPRT_H__
#define __MOTR_NET_BULK_MEM_XPRT_H__

#include "lib/atomic.h"
#include "lib/thread.h"

#ifdef __KERNEL__
#include <linux/in.h>
#include <linux/inet.h>

/* The kernel does not define these types */
typedef __be32 in_addr_t;
typedef __be16 in_port_t;

#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#endif

#include "motr/magic.h"
#include "net/bulk_mem.h"

struct m0_net_bulk_mem_domain_pvt;
struct m0_net_bulk_mem_tm_pvt;
struct m0_net_bulk_mem_buffer_pvt;
struct m0_net_bulk_mem_end_point;
struct m0_net_bulk_mem_work_item;

enum m0_net_bulk_mem_work_opcode {
        M0_NET_XOP_STATE_CHANGE=0,
        M0_NET_XOP_CANCEL_CB,
        M0_NET_XOP_MSG_RECV_CB,
        M0_NET_XOP_MSG_SEND,
        M0_NET_XOP_PASSIVE_BULK_CB,
        M0_NET_XOP_ACTIVE_BULK,
        M0_NET_XOP_ERROR_CB,

        M0_NET_XOP_NR
};

enum m0_net_bulk_mem_tm_state {
        M0_NET_XTM_UNDEFINED   = M0_NET_TM_UNDEFINED,
        M0_NET_XTM_INITIALIZED = M0_NET_TM_INITIALIZED,
        M0_NET_XTM_STARTING    = M0_NET_TM_STARTING,
        M0_NET_XTM_STARTED     = M0_NET_TM_STARTED,
        M0_NET_XTM_STOPPING    = M0_NET_TM_STOPPING,
        M0_NET_XTM_STOPPED     = M0_NET_TM_STOPPED,
        M0_NET_XTM_FAILED      = M0_NET_TM_FAILED,
};

struct m0_net_bulk_mem_work_item {
        struct m0_list_link                 xwi_link;

        enum m0_net_bulk_mem_work_opcode    xwi_op;

        enum m0_net_bulk_mem_tm_state       xwi_next_state;

        int32_t                             xwi_status;

        m0_bcount_t                         xwi_nbe_length;

        struct m0_net_end_point            *xwi_nbe_ep;
};

struct m0_net_bulk_mem_buffer_pvt {
        struct m0_net_buffer                *xb_buffer;

        struct m0_net_bulk_mem_work_item     xb_wi;

        int64_t                              xb_buf_id;
};

static inline struct m0_net_bulk_mem_buffer_pvt *
mem_buffer_to_pvt(const struct m0_net_buffer *nb)
{
        return nb->nb_xprt_private;
}

struct m0_net_bulk_mem_tm_pvt {
        struct m0_net_transfer_mc        *xtm_tm;
        enum m0_net_bulk_mem_tm_state     xtm_state;
        struct m0_list                    xtm_work_list;
        struct m0_cond                    xtm_work_list_cv;
        uint32_t                          xtm_callback_counter;
        struct m0_thread                 *xtm_worker_threads;
        size_t                            xtm_num_workers;
};

static inline struct m0_net_bulk_mem_tm_pvt *
mem_tm_to_pvt(const struct m0_net_transfer_mc *tm)
{
        return tm->ntm_xprt_private;
}

struct m0_net_bulk_mem_end_point {
        uint64_t                 xep_magic;

        struct sockaddr_in       xep_sa;

        uint32_t                 xep_service_id;

        struct m0_net_end_point  xep_ep;

        char                     xep_addr[M0_NET_BULK_MEM_XEP_ADDR_LEN];
};

static inline struct m0_net_bulk_mem_end_point *
mem_ep_to_pvt(const struct m0_net_end_point *ep)
{
        return container_of(ep, struct m0_net_bulk_mem_end_point, xep_ep);
}

typedef void (*m0_net_bulk_mem_work_fn_t)(struct m0_net_transfer_mc *tm,
                                          struct m0_net_bulk_mem_work_item *wi);

struct m0_net_bulk_mem_ops {
        m0_net_bulk_mem_work_fn_t  bmo_work_fn[M0_NET_XOP_NR];

        int (*bmo_ep_create)(struct m0_net_end_point  **epp,
                             struct m0_net_transfer_mc *tm,
                             const struct sockaddr_in  *sa,
                             uint32_t id);

        struct m0_net_bulk_mem_end_point *(*bmo_ep_alloc)(void);

        void (*bmo_ep_free)(struct m0_net_bulk_mem_end_point *mep);

        void (*bmo_ep_release)(struct m0_ref *ref);

        void (*bmo_ep_get)(struct m0_net_end_point *ep);

        void (*bmo_wi_add)(struct m0_net_bulk_mem_work_item *wi,
                           struct m0_net_bulk_mem_tm_pvt *tp);

        bool (*bmo_buffer_in_bounds)(const struct m0_net_buffer *nb);

        int  (*bmo_desc_create)(struct m0_net_buf_desc *desc,
                                struct m0_net_transfer_mc *tm,
                                enum m0_net_queue_type qt,
                                m0_bcount_t buflen,
                                int64_t buf_id);

        void (*bmo_post_error)(struct m0_net_transfer_mc *tm,
                               int status);

        void (*bmo_wi_post_buffer_event)(struct m0_net_bulk_mem_work_item *wi);
};

struct m0_net_bulk_mem_domain_pvt {
        struct m0_net_domain             *xd_dom;

        const struct m0_net_bulk_mem_ops *xd_ops;

        size_t                            xd_addr_tuples;

        size_t                            xd_num_tm_threads;

        struct m0_list_link               xd_dom_linkage;

        bool                              xd_derived;

        uint64_t                          xd_buf_id_counter;
};

static inline struct m0_net_bulk_mem_domain_pvt *
mem_dom_to_pvt(const struct m0_net_domain *dom)
{
        return dom->nd_xprt_private;
}

static inline struct m0_net_buffer *
mem_wi_to_buffer(struct m0_net_bulk_mem_work_item *wi)
{
        struct m0_net_bulk_mem_buffer_pvt *bp;
        bp = container_of(wi, struct m0_net_bulk_mem_buffer_pvt, xb_wi);
        return bp->xb_buffer;
}

static inline struct m0_net_bulk_mem_work_item *
mem_buffer_to_wi(struct m0_net_buffer *buf)
{
        struct m0_net_bulk_mem_buffer_pvt *bp = mem_buffer_to_pvt(buf);
        return &bp->xb_wi;
}

static inline in_addr_t mem_ep_addr(struct m0_net_end_point *ep)
{
        struct m0_net_bulk_mem_end_point *mep =
                container_of(ep, struct m0_net_bulk_mem_end_point, xep_ep);
        return mep->xep_sa.sin_addr.s_addr;
}

static inline in_port_t mem_ep_port(struct m0_net_end_point *ep)
{
        struct m0_net_bulk_mem_end_point *mep =
                container_of(ep, struct m0_net_bulk_mem_end_point, xep_ep);
        return mep->xep_sa.sin_port;
}

static inline uint32_t mem_ep_sid(struct m0_net_end_point *ep)
{
        struct m0_net_bulk_mem_end_point *mep =
                container_of(ep, struct m0_net_bulk_mem_end_point, xep_ep);
        return mep->xep_service_id;
}

static inline bool mem_sa_eq(const struct sockaddr_in *sa1,
                             const struct sockaddr_in *sa2)
{
        return sa1->sin_addr.s_addr == sa2->sin_addr.s_addr &&
               sa1->sin_port        == sa2->sin_port;
}

M0_INTERNAL int m0_mem_xprt_init(void);
M0_INTERNAL void m0_mem_xprt_fini(void);

#endif /* __MOTR_NET_BULK_MEM_XPRT_H__ */

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