lnet_core_types.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_LNET_TYPES_H__
#define __MOTR_NET_LNET_CORE_TYPES_H__

#include "net/net.h"  /* m0_net_queue_type */

/* forward references */
struct nlx_core_bev_link;
struct nlx_core_bev_cqueue;
struct nlx_core_buffer;
struct nlx_core_buffer_event;
struct nlx_core_domain;
struct nlx_core_ep_addr;
struct nlx_core_transfer_mc;
struct nlx_core_buf_desc;
struct page;

typedef uint64_t nlx_core_opaque_ptr_t;
M0_BASSERT(sizeof(nlx_core_opaque_ptr_t) >= sizeof(void *));

struct nlx_core_ep_addr {
        uint64_t cepa_nid;    
        uint32_t cepa_pid;    
        uint32_t cepa_portal; 
        uint32_t cepa_tmid;   
} __attribute__((__packed__));

/* Match bit related definitions */
enum {
        M0_NET_LNET_TMID_BITS      = 12,
        M0_NET_LNET_TMID_SHIFT     = 64 - M0_NET_LNET_TMID_BITS,
        M0_NET_LNET_TMID_MAX       = (1 << M0_NET_LNET_TMID_BITS) - 1,
        M0_NET_LNET_TMID_INVALID   = M0_NET_LNET_TMID_MAX+1,
        M0_NET_LNET_BUFFER_ID_BITS = 64 - M0_NET_LNET_TMID_BITS,
        M0_NET_LNET_BUFFER_ID_MIN  = 1,
        M0_NET_LNET_BUFFER_ID_MAX  = (1ULL << M0_NET_LNET_BUFFER_ID_BITS) - 1,
        M0_NET_LNET_BUFFER_ID_MASK = M0_NET_LNET_BUFFER_ID_MAX,
};
M0_BASSERT(M0_NET_LNET_TMID_BITS + M0_NET_LNET_BUFFER_ID_BITS <= 64);

struct nlx_core_kmem_loc {
        union {
                struct {
                        struct page *kl_page;
                        uint32_t     kl_offset;
                } __attribute__((__packed__));
                uint32_t     kl_data[3];
        };
        uint32_t     kl_checksum;
};
M0_BASSERT(sizeof(((struct nlx_core_kmem_loc*) NULL)->kl_page) +
           sizeof(((struct nlx_core_kmem_loc*) NULL)->kl_offset) ==
           sizeof(((struct nlx_core_kmem_loc*) NULL)->kl_data));

enum {
        M0_NET_LNET_NIDSTR_SIZE = 32,
};

struct nlx_core_bev_link {
        nlx_core_opaque_ptr_t cbl_c_self;

        nlx_core_opaque_ptr_t cbl_c_next;

        struct nlx_core_kmem_loc cbl_p_self_loc;

        struct nlx_core_kmem_loc cbl_p_next_loc;
};

struct nlx_core_bev_cqueue {
        size_t                 cbcq_nr;

        struct m0_atomic64     cbcq_count;

        nlx_core_opaque_ptr_t cbcq_consumer;

        struct nlx_core_kmem_loc cbcq_producer_loc;
};

enum {
        M0_NET_LNET_BEVQ_MIN_SIZE  = 2,
        M0_NET_LNET_BEVQ_NUM_RESERVED = 1,
};

struct nlx_core_buffer_event {
        struct nlx_core_bev_link     cbe_tm_link;

        nlx_core_opaque_ptr_t        cbe_buffer_id;

        m0_time_t                    cbe_time;

        int32_t                      cbe_status;

        m0_bcount_t                  cbe_length;

        m0_bindex_t                  cbe_offset;

        struct nlx_core_ep_addr      cbe_sender;

        bool                         cbe_unlinked;

        void                        *cbe_kpvt;
};

struct nlx_core_domain {
        void    *cd_upvt; 
        void    *cd_kpvt; 
        unsigned _debug_;
};

struct nlx_core_transfer_mc {
        uint64_t                   ctm_magic;

        struct nlx_core_ep_addr    ctm_addr;

        struct nlx_core_bev_cqueue ctm_bevq;

        size_t                     ctm_bev_needed;

        uint64_t                   ctm_mb_counter;

        void                      *ctm_upvt; 
        void                      *ctm_kpvt; 
        unsigned                   _debug_;
};

struct nlx_core_buffer {
        uint64_t                cb_magic;

        nlx_core_opaque_ptr_t   cb_buffer_id;

        enum m0_net_queue_type  cb_qtype;

        m0_bcount_t             cb_length;

        m0_bcount_t             cb_min_receive_size;

        uint32_t                cb_max_operations;

        uint64_t                cb_match_bits;

        struct nlx_core_ep_addr cb_addr;

        void                   *cb_upvt; 
        void                   *cb_kpvt; 
};

struct nlx_core_buf_desc {
        union {
                struct {
                        uint64_t                 cbd_match_bits;

                        struct nlx_core_ep_addr  cbd_passive_ep;

                        uint32_t                 cbd_qtype;

                        m0_bcount_t              cbd_size;
                };
                uint64_t         cbd_data[5];
        };
        uint64_t         cbd_checksum;
};
 /* LNetCore */

#endif /* __MOTR_NET_LNET_CORE_TYPES_H__ */

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