Quelle  ib_verbs.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */
/*
 * Copyright (c) 2004 Mellanox Technologies Ltd.  All rights reserved.
 * Copyright (c) 2004 Infinicon Corporation.  All rights reserved.
 * Copyright (c) 2004, 2020 Intel Corporation.  All rights reserved.
 * Copyright (c) 2004 Topspin Corporation.  All rights reserved.
 * Copyright (c) 2004 Voltaire Corporation.  All rights reserved.
 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
 * Copyright (c) 2005, 2006, 2007 Cisco Systems.  All rights reserved.
 */

#ifndef IB_VERBS_H
#define IB_VERBS_H

#include <linux/ethtool.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/kref.h>
#include <linux/list.h>
#include <linux/rwsem.h>
#include <linux/workqueue.h>
#include <linux/irq_poll.h>
#include <uapi/linux/if_ether.h>
#include <net/ipv6.h>
#include <net/ip.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/netdevice.h>
#include <linux/refcount.h>
#include <linux/if_link.h>
#include <linux/atomic.h>
#include <linux/mmu_notifier.h>
#include <linux/uaccess.h>
#include <linux/cgroup_rdma.h>
#include <linux/irqflags.h>
#include <linux/preempt.h>
#include <linux/dim.h>
#include <uapi/rdma/ib_user_verbs.h>
#include <rdma/rdma_counter.h>
#include <rdma/restrack.h>
#include <rdma/signature.h>
#include <uapi/rdma/rdma_user_ioctl.h>
#include <uapi/rdma/ib_user_ioctl_verbs.h>
#include <linux/pci-tph.h>

#define IB_FW_VERSION_NAME_MAX ETHTOOL_FWVERS_LEN

struct ib_umem_odp;
struct ib_uqp_object;
struct ib_usrq_object;
struct ib_uwq_object;
struct rdma_cm_id;
struct ib_port;
struct hw_stats_device_data;

extern struct workqueue_struct *ib_wq;
extern struct workqueue_struct *ib_comp_wq;
extern struct workqueue_struct *ib_comp_unbound_wq;

struct ib_ucq_object;

__printf(2, 3) __cold
void ibdev_emerg(const struct ib_device *ibdev, const char *format, ...);
__printf(2, 3) __cold
void ibdev_alert(const struct ib_device *ibdev, const char *format, ...);
__printf(2, 3) __cold
void ibdev_crit(const struct ib_device *ibdev, const char *format, ...);
__printf(2, 3) __cold
void ibdev_err(const struct ib_device *ibdev, const char *format, ...);
__printf(2, 3) __cold
void ibdev_warn(const struct ib_device *ibdev, const char *format, ...);
__printf(2, 3) __cold
void ibdev_notice(const struct ib_device *ibdev, const char *format, ...);
__printf(2, 3) __cold
void ibdev_info(const struct ib_device *ibdev, const char *format, ...);

#if defined(CONFIG_DYNAMIC_DEBUG) || \
 (defined(CONFIG_DYNAMIC_DEBUG_CORE) && defined(DYNAMIC_DEBUG_MODULE))
#define ibdev_dbg(__dev, format, args...)                       \
 dynamic_ibdev_dbg(__dev, format, ##args)
#else
__printf(2, 3) __cold
static inline
void ibdev_dbg(const struct ib_device *ibdev, const char *format, ...) {}
#endif

#define ibdev_level_ratelimited(ibdev_level, ibdev, fmt, ...)           \
do {                                                                    \
 static DEFINE_RATELIMIT_STATE(_rs,                              \
          DEFAULT_RATELIMIT_INTERVAL,       \
          DEFAULT_RATELIMIT_BURST);         \
 if (__ratelimit(&_rs))                                          \
  ibdev_level(ibdev, fmt, ##__VA_ARGS__);                 \
} while (0)

#define ibdev_emerg_ratelimited(ibdev, fmt, ...) \
 ibdev_level_ratelimited(ibdev_emerg, ibdev, fmt, ##__VA_ARGS__)
#define ibdev_alert_ratelimited(ibdev, fmt, ...) \
 ibdev_level_ratelimited(ibdev_alert, ibdev, fmt, ##__VA_ARGS__)
#define ibdev_crit_ratelimited(ibdev, fmt, ...) \
 ibdev_level_ratelimited(ibdev_crit, ibdev, fmt, ##__VA_ARGS__)
#define ibdev_err_ratelimited(ibdev, fmt, ...) \
 ibdev_level_ratelimited(ibdev_err, ibdev, fmt, ##__VA_ARGS__)
#define ibdev_warn_ratelimited(ibdev, fmt, ...) \
 ibdev_level_ratelimited(ibdev_warn, ibdev, fmt, ##__VA_ARGS__)
#define ibdev_notice_ratelimited(ibdev, fmt, ...) \
 ibdev_level_ratelimited(ibdev_notice, ibdev, fmt, ##__VA_ARGS__)
#define ibdev_info_ratelimited(ibdev, fmt, ...) \
 ibdev_level_ratelimited(ibdev_info, ibdev, fmt, ##__VA_ARGS__)

#if defined(CONFIG_DYNAMIC_DEBUG) || \
 (defined(CONFIG_DYNAMIC_DEBUG_CORE) && defined(DYNAMIC_DEBUG_MODULE))
/* descriptor check is first to prevent flooding with "callbacks suppressed" */
#define ibdev_dbg_ratelimited(ibdev, fmt, ...)                          \
do {                                                                    \
 static DEFINE_RATELIMIT_STATE(_rs,                              \
          DEFAULT_RATELIMIT_INTERVAL,       \
          DEFAULT_RATELIMIT_BURST);         \
 DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);                 \
 if (DYNAMIC_DEBUG_BRANCH(descriptor) && __ratelimit(&_rs))      \
  __dynamic_ibdev_dbg(&descriptor, ibdev, fmt,            \
        ##__VA_ARGS__);                     \
} while (0)
#else
__printf(2, 3) __cold
static inline
void ibdev_dbg_ratelimited(const struct ib_device *ibdev, const char *format, ...) {}
#endif

union ib_gid {
 u8 raw[16];
 struct {
  __be64 subnet_prefix;
  __be64 interface_id;
 } global;
};

extern union ib_gid zgid;

enum ib_gid_type {
 IB_GID_TYPE_IB = IB_UVERBS_GID_TYPE_IB,
 IB_GID_TYPE_ROCE = IB_UVERBS_GID_TYPE_ROCE_V1,
 IB_GID_TYPE_ROCE_UDP_ENCAP = IB_UVERBS_GID_TYPE_ROCE_V2,
 IB_GID_TYPE_SIZE
};

#define ROCE_V2_UDP_DPORT      4791
struct ib_gid_attr {
 struct net_device __rcu *ndev;
 struct ib_device *device;
 union ib_gid  gid;
 enum ib_gid_type gid_type;
 u16   index;
 u32   port_num;
};

enum {
 /* set the local administered indication */
 IB_SA_WELL_KNOWN_GUID = BIT_ULL(57) | 2,
};

enum rdma_transport_type {
 RDMA_TRANSPORT_IB,
 RDMA_TRANSPORT_IWARP,
 RDMA_TRANSPORT_USNIC,
 RDMA_TRANSPORT_USNIC_UDP,
 RDMA_TRANSPORT_UNSPECIFIED,
};

enum rdma_protocol_type {
 RDMA_PROTOCOL_IB,
 RDMA_PROTOCOL_IBOE,
 RDMA_PROTOCOL_IWARP,
 RDMA_PROTOCOL_USNIC_UDP
};

__attribute_const__ enum rdma_transport_type
rdma_node_get_transport(unsigned int node_type);

enum rdma_network_type {
 RDMA_NETWORK_IB,
 RDMA_NETWORK_ROCE_V1,
 RDMA_NETWORK_IPV4,
 RDMA_NETWORK_IPV6
};

static inline enum ib_gid_type ib_network_to_gid_type(enum rdma_network_type network_type)
{
 if (network_type == RDMA_NETWORK_IPV4 ||
     network_type == RDMA_NETWORK_IPV6)
  return IB_GID_TYPE_ROCE_UDP_ENCAP;
 else if (network_type == RDMA_NETWORK_ROCE_V1)
  return IB_GID_TYPE_ROCE;
 else
  return IB_GID_TYPE_IB;
}

static inline enum rdma_network_type
rdma_gid_attr_network_type(const struct ib_gid_attr *attr)
{
 if (attr->gid_type == IB_GID_TYPE_IB)
  return RDMA_NETWORK_IB;

 if (attr->gid_type == IB_GID_TYPE_ROCE)
  return RDMA_NETWORK_ROCE_V1;

 if (ipv6_addr_v4mapped((struct in6_addr *)&attr->gid))
  return RDMA_NETWORK_IPV4;
 else
  return RDMA_NETWORK_IPV6;
}

enum rdma_link_layer {
 IB_LINK_LAYER_UNSPECIFIED,
 IB_LINK_LAYER_INFINIBAND,
 IB_LINK_LAYER_ETHERNET,
};

enum ib_device_cap_flags {
 IB_DEVICE_RESIZE_MAX_WR = IB_UVERBS_DEVICE_RESIZE_MAX_WR,
 IB_DEVICE_BAD_PKEY_CNTR = IB_UVERBS_DEVICE_BAD_PKEY_CNTR,
 IB_DEVICE_BAD_QKEY_CNTR = IB_UVERBS_DEVICE_BAD_QKEY_CNTR,
 IB_DEVICE_RAW_MULTI = IB_UVERBS_DEVICE_RAW_MULTI,
 IB_DEVICE_AUTO_PATH_MIG = IB_UVERBS_DEVICE_AUTO_PATH_MIG,
 IB_DEVICE_CHANGE_PHY_PORT = IB_UVERBS_DEVICE_CHANGE_PHY_PORT,
 IB_DEVICE_UD_AV_PORT_ENFORCE = IB_UVERBS_DEVICE_UD_AV_PORT_ENFORCE,
 IB_DEVICE_CURR_QP_STATE_MOD = IB_UVERBS_DEVICE_CURR_QP_STATE_MOD,
 IB_DEVICE_SHUTDOWN_PORT = IB_UVERBS_DEVICE_SHUTDOWN_PORT,
 /* IB_DEVICE_INIT_TYPE = IB_UVERBS_DEVICE_INIT_TYPE, (not in use) */
 IB_DEVICE_PORT_ACTIVE_EVENT = IB_UVERBS_DEVICE_PORT_ACTIVE_EVENT,
 IB_DEVICE_SYS_IMAGE_GUID = IB_UVERBS_DEVICE_SYS_IMAGE_GUID,
 IB_DEVICE_RC_RNR_NAK_GEN = IB_UVERBS_DEVICE_RC_RNR_NAK_GEN,
 IB_DEVICE_SRQ_RESIZE = IB_UVERBS_DEVICE_SRQ_RESIZE,
 IB_DEVICE_N_NOTIFY_CQ = IB_UVERBS_DEVICE_N_NOTIFY_CQ,

 /* Reserved, old SEND_W_INV = 1 << 16,*/
 IB_DEVICE_MEM_WINDOW = IB_UVERBS_DEVICE_MEM_WINDOW,
 /*
 * Devices should set IB_DEVICE_UD_IP_SUM if they support
 * insertion of UDP and TCP checksum on outgoing UD IPoIB
 * messages and can verify the validity of checksum for
 * incoming messages.  Setting this flag implies that the
 * IPoIB driver may set NETIF_F_IP_CSUM for datagram mode.
 */
 IB_DEVICE_UD_IP_CSUM = IB_UVERBS_DEVICE_UD_IP_CSUM,
 IB_DEVICE_XRC = IB_UVERBS_DEVICE_XRC,

 /*
 * This device supports the IB "base memory management extension",
 * which includes support for fast registrations (IB_WR_REG_MR,
 * IB_WR_LOCAL_INV and IB_WR_SEND_WITH_INV verbs).  This flag should
 * also be set by any iWarp device which must support FRs to comply
 * to the iWarp verbs spec.  iWarp devices also support the
 * IB_WR_RDMA_READ_WITH_INV verb for RDMA READs that invalidate the
 * stag.
 */
 IB_DEVICE_MEM_MGT_EXTENSIONS = IB_UVERBS_DEVICE_MEM_MGT_EXTENSIONS,
 IB_DEVICE_MEM_WINDOW_TYPE_2A = IB_UVERBS_DEVICE_MEM_WINDOW_TYPE_2A,
 IB_DEVICE_MEM_WINDOW_TYPE_2B = IB_UVERBS_DEVICE_MEM_WINDOW_TYPE_2B,
 IB_DEVICE_RC_IP_CSUM = IB_UVERBS_DEVICE_RC_IP_CSUM,
 /* Deprecated. Please use IB_RAW_PACKET_CAP_IP_CSUM. */
 IB_DEVICE_RAW_IP_CSUM = IB_UVERBS_DEVICE_RAW_IP_CSUM,
 IB_DEVICE_MANAGED_FLOW_STEERING =
  IB_UVERBS_DEVICE_MANAGED_FLOW_STEERING,
 /* Deprecated. Please use IB_RAW_PACKET_CAP_SCATTER_FCS. */
 IB_DEVICE_RAW_SCATTER_FCS = IB_UVERBS_DEVICE_RAW_SCATTER_FCS,
 /* The device supports padding incoming writes to cacheline. */
 IB_DEVICE_PCI_WRITE_END_PADDING =
  IB_UVERBS_DEVICE_PCI_WRITE_END_PADDING,
 /* Placement type attributes */
 IB_DEVICE_FLUSH_GLOBAL = IB_UVERBS_DEVICE_FLUSH_GLOBAL,
 IB_DEVICE_FLUSH_PERSISTENT = IB_UVERBS_DEVICE_FLUSH_PERSISTENT,
 IB_DEVICE_ATOMIC_WRITE = IB_UVERBS_DEVICE_ATOMIC_WRITE,
};

enum ib_kernel_cap_flags {
 /*
 * This device supports a per-device lkey or stag that can be
 * used without performing a memory registration for the local
 * memory.  Note that ULPs should never check this flag, but
 * instead of use the local_dma_lkey flag in the ib_pd structure,
 * which will always contain a usable lkey.
 */
 IBK_LOCAL_DMA_LKEY = 1 << 0,
 /* IB_QP_CREATE_INTEGRITY_EN is supported to implement T10-PI */
 IBK_INTEGRITY_HANDOVER = 1 << 1,
 /* IB_ACCESS_ON_DEMAND is supported during reg_user_mr() */
 IBK_ON_DEMAND_PAGING = 1 << 2,
 /* IB_MR_TYPE_SG_GAPS is supported */
 IBK_SG_GAPS_REG = 1 << 3,
 /* Driver supports RDMA_NLDEV_CMD_DELLINK */
 IBK_ALLOW_USER_UNREG = 1 << 4,

 /* ipoib will use IB_QP_CREATE_BLOCK_MULTICAST_LOOPBACK */
 IBK_BLOCK_MULTICAST_LOOPBACK = 1 << 5,
 /* iopib will use IB_QP_CREATE_IPOIB_UD_LSO for its QPs */
 IBK_UD_TSO = 1 << 6,
 /* iopib will use the device ops:
 *   get_vf_config
 *   get_vf_guid
 *   get_vf_stats
 *   set_vf_guid
 *   set_vf_link_state
 */
 IBK_VIRTUAL_FUNCTION = 1 << 7,
 /* ipoib will use IB_QP_CREATE_NETDEV_USE for its QPs */
 IBK_RDMA_NETDEV_OPA = 1 << 8,
};

enum ib_atomic_cap {
 IB_ATOMIC_NONE,
 IB_ATOMIC_HCA,
 IB_ATOMIC_GLOB
};

enum ib_odp_general_cap_bits {
 IB_ODP_SUPPORT  = IB_UVERBS_ODP_SUPPORT,
 IB_ODP_SUPPORT_IMPLICIT = IB_UVERBS_ODP_SUPPORT_IMPLICIT,
};

enum ib_odp_transport_cap_bits {
 IB_ODP_SUPPORT_SEND = IB_UVERBS_ODP_SUPPORT_SEND,
 IB_ODP_SUPPORT_RECV = IB_UVERBS_ODP_SUPPORT_RECV,
 IB_ODP_SUPPORT_WRITE = IB_UVERBS_ODP_SUPPORT_WRITE,
 IB_ODP_SUPPORT_READ = IB_UVERBS_ODP_SUPPORT_READ,
 IB_ODP_SUPPORT_ATOMIC = IB_UVERBS_ODP_SUPPORT_ATOMIC,
 IB_ODP_SUPPORT_SRQ_RECV = IB_UVERBS_ODP_SUPPORT_SRQ_RECV,
 IB_ODP_SUPPORT_FLUSH = IB_UVERBS_ODP_SUPPORT_FLUSH,
 IB_ODP_SUPPORT_ATOMIC_WRITE = IB_UVERBS_ODP_SUPPORT_ATOMIC_WRITE,
};

struct ib_odp_caps {
 uint64_t general_caps;
 struct {
  uint32_t  rc_odp_caps;
  uint32_t  uc_odp_caps;
  uint32_t  ud_odp_caps;
  uint32_t  xrc_odp_caps;
 } per_transport_caps;
};

struct ib_rss_caps {
 /* Corresponding bit will be set if qp type from
 * 'enum ib_qp_type' is supported, e.g.
 * supported_qpts |= 1 << IB_QPT_UD
 */
 u32 supported_qpts;
 u32 max_rwq_indirection_tables;
 u32 max_rwq_indirection_table_size;
};

enum ib_tm_cap_flags {
 /*  Support tag matching with rendezvous offload for RC transport */
 IB_TM_CAP_RNDV_RC = 1 << 0,
};

struct ib_tm_caps {
 /* Max size of RNDV header */
 u32 max_rndv_hdr_size;
 /* Max number of entries in tag matching list */
 u32 max_num_tags;
 /* From enum ib_tm_cap_flags */
 u32 flags;
 /* Max number of outstanding list operations */
 u32 max_ops;
 /* Max number of SGE in tag matching entry */
 u32 max_sge;
};

struct ib_cq_init_attr {
 unsigned int cqe;
 u32  comp_vector;
 u32  flags;
};

enum ib_cq_attr_mask {
 IB_CQ_MODERATE = 1 << 0,
};

struct ib_cq_caps {
 u16     max_cq_moderation_count;
 u16     max_cq_moderation_period;
};

struct ib_dm_mr_attr {
 u64  length;
 u64  offset;
 u32  access_flags;
};

struct ib_dm_alloc_attr {
 u64 length;
 u32 alignment;
 u32 flags;
};

struct ib_device_attr {
 u64   fw_ver;
 __be64   sys_image_guid;
 u64   max_mr_size;
 u64   page_size_cap;
 u32   vendor_id;
 u32   vendor_part_id;
 u32   hw_ver;
 int   max_qp;
 int   max_qp_wr;
 u64   device_cap_flags;
 u64   kernel_cap_flags;
 int   max_send_sge;
 int   max_recv_sge;
 int   max_sge_rd;
 int   max_cq;
 int   max_cqe;
 int   max_mr;
 int   max_pd;
 int   max_qp_rd_atom;
 int   max_ee_rd_atom;
 int   max_res_rd_atom;
 int   max_qp_init_rd_atom;
 int   max_ee_init_rd_atom;
 enum ib_atomic_cap atomic_cap;
 enum ib_atomic_cap masked_atomic_cap;
 int   max_ee;
 int   max_rdd;
 int   max_mw;
 int   max_raw_ipv6_qp;
 int   max_raw_ethy_qp;
 int   max_mcast_grp;
 int   max_mcast_qp_attach;
 int   max_total_mcast_qp_attach;
 int   max_ah;
 int   max_srq;
 int   max_srq_wr;
 int   max_srq_sge;
 unsigned int  max_fast_reg_page_list_len;
 unsigned int  max_pi_fast_reg_page_list_len;
 u16   max_pkeys;
 u8   local_ca_ack_delay;
 int   sig_prot_cap;
 int   sig_guard_cap;
 struct ib_odp_caps odp_caps;
 uint64_t  timestamp_mask;
 uint64_t  hca_core_clock; /* in KHZ */
 struct ib_rss_caps rss_caps;
 u32   max_wq_type_rq;
 u32   raw_packet_caps; /* Use ib_raw_packet_caps enum */
 struct ib_tm_caps tm_caps;
 struct ib_cq_caps       cq_caps;
 u64   max_dm_size;
 /* Max entries for sgl for optimized performance per READ */
 u32   max_sgl_rd;
};

enum ib_mtu {
 IB_MTU_256  = 1,
 IB_MTU_512  = 2,
 IB_MTU_1024 = 3,
 IB_MTU_2048 = 4,
 IB_MTU_4096 = 5
};

enum opa_mtu {
 OPA_MTU_8192 = 6,
 OPA_MTU_10240 = 7
};

static inline int ib_mtu_enum_to_int(enum ib_mtu mtu)
{
 switch (mtu) {
 case IB_MTU_256:  return  256;
 case IB_MTU_512:  return  512;
 case IB_MTU_1024: return 1024;
 case IB_MTU_2048: return 2048;
 case IB_MTU_4096: return 4096;
 default:    return -1;
 }
}

static inline enum ib_mtu ib_mtu_int_to_enum(int mtu)
{
 if (mtu >= 4096)
  return IB_MTU_4096;
 else if (mtu >= 2048)
  return IB_MTU_2048;
 else if (mtu >= 1024)
  return IB_MTU_1024;
 else if (mtu >= 512)
  return IB_MTU_512;
 else
  return IB_MTU_256;
}

static inline int opa_mtu_enum_to_int(enum opa_mtu mtu)
{
 switch (mtu) {
 case OPA_MTU_8192:
  return 8192;
 case OPA_MTU_10240:
  return 10240;
 default:
  return(ib_mtu_enum_to_int((enum ib_mtu)mtu));
 }
}

static inline enum opa_mtu opa_mtu_int_to_enum(int mtu)
{
 if (mtu >= 10240)
  return OPA_MTU_10240;
 else if (mtu >= 8192)
  return OPA_MTU_8192;
 else
  return ((enum opa_mtu)ib_mtu_int_to_enum(mtu));
}

enum ib_port_state {
 IB_PORT_NOP  = 0,
 IB_PORT_DOWN  = 1,
 IB_PORT_INIT  = 2,
 IB_PORT_ARMED  = 3,
 IB_PORT_ACTIVE  = 4,
 IB_PORT_ACTIVE_DEFER = 5
};

static inline const char *__attribute_const__
ib_port_state_to_str(enum ib_port_state state)
{
 const char * const states[] = {
  [IB_PORT_NOP] = "NOP",
  [IB_PORT_DOWN] = "DOWN",
  [IB_PORT_INIT] = "INIT",
  [IB_PORT_ARMED] = "ARMED",
  [IB_PORT_ACTIVE] = "ACTIVE",
  [IB_PORT_ACTIVE_DEFER] = "ACTIVE_DEFER",
 };

 if (state < ARRAY_SIZE(states))
  return states[state];
 return "UNKNOWN";
}

enum ib_port_phys_state {
 IB_PORT_PHYS_STATE_SLEEP = 1,
 IB_PORT_PHYS_STATE_POLLING = 2,
 IB_PORT_PHYS_STATE_DISABLED = 3,
 IB_PORT_PHYS_STATE_PORT_CONFIGURATION_TRAINING = 4,
 IB_PORT_PHYS_STATE_LINK_UP = 5,
 IB_PORT_PHYS_STATE_LINK_ERROR_RECOVERY = 6,
 IB_PORT_PHYS_STATE_PHY_TEST = 7,
};

enum ib_port_width {
 IB_WIDTH_1X = 1,
 IB_WIDTH_2X = 16,
 IB_WIDTH_4X = 2,
 IB_WIDTH_8X = 4,
 IB_WIDTH_12X = 8
};

static inline int ib_width_enum_to_int(enum ib_port_width width)
{
 switch (width) {
 case IB_WIDTH_1X:  return  1;
 case IB_WIDTH_2X:  return  2;
 case IB_WIDTH_4X:  return  4;
 case IB_WIDTH_8X:  return  8;
 case IB_WIDTH_12X: return 12;
 default:    return -1;
 }
}

enum ib_port_speed {
 IB_SPEED_SDR = 1,
 IB_SPEED_DDR = 2,
 IB_SPEED_QDR = 4,
 IB_SPEED_FDR10 = 8,
 IB_SPEED_FDR = 16,
 IB_SPEED_EDR = 32,
 IB_SPEED_HDR = 64,
 IB_SPEED_NDR = 128,
 IB_SPEED_XDR = 256,
};

enum ib_stat_flag {
 IB_STAT_FLAG_OPTIONAL = 1 << 0,
};

/**
 * struct rdma_stat_desc
 * @name - The name of the counter
 * @flags - Flags of the counter; For example, IB_STAT_FLAG_OPTIONAL
 * @priv - Driver private information; Core code should not use
 */
struct rdma_stat_desc {
 const char *name;
 unsigned int flags;
 const void *priv;
};

/**
 * struct rdma_hw_stats
 * @lock - Mutex to protect parallel write access to lifespan and values
 *    of counters, which are 64bits and not guaranteed to be written
 *    atomicaly on 32bits systems.
 * @timestamp - Used by the core code to track when the last update was
 * @lifespan - Used by the core code to determine how old the counters
 *   should be before being updated again.  Stored in jiffies, defaults
 *   to 10 milliseconds, drivers can override the default be specifying
 *   their own value during their allocation routine.
 * @descs - Array of pointers to static descriptors used for the counters
 *   in directory.
 * @is_disabled - A bitmap to indicate each counter is currently disabled
 *   or not.
 * @num_counters - How many hardware counters there are.  If name is
 *   shorter than this number, a kernel oops will result.  Driver authors
 *   are encouraged to leave BUILD_BUG_ON(ARRAY_SIZE(@name) < num_counters)
 *   in their code to prevent this.
 * @value - Array of u64 counters that are accessed by the sysfs code and
 *   filled in by the drivers get_stats routine
 */
struct rdma_hw_stats {
 struct mutex lock; /* Protect lifespan and values[] */
 unsigned long timestamp;
 unsigned long lifespan;
 const struct rdma_stat_desc *descs;
 unsigned long *is_disabled;
 int  num_counters;
 u64  value[] __counted_by(num_counters);
};

#define RDMA_HW_STATS_DEFAULT_LIFESPAN 10

struct rdma_hw_stats *rdma_alloc_hw_stats_struct(
 const struct rdma_stat_desc *descs, int num_counters,
 unsigned long lifespan);

void rdma_free_hw_stats_struct(struct rdma_hw_stats *stats);

/* Define bits for the various functionality this port needs to be supported by
 * the core.
 */
/* Management                           0x00000FFF */
#define RDMA_CORE_CAP_IB_MAD            0x00000001
#define RDMA_CORE_CAP_IB_SMI            0x00000002
#define RDMA_CORE_CAP_IB_CM             0x00000004
#define RDMA_CORE_CAP_IW_CM             0x00000008
#define RDMA_CORE_CAP_IB_SA             0x00000010
#define RDMA_CORE_CAP_OPA_MAD           0x00000020

/* Address format                       0x000FF000 */
#define RDMA_CORE_CAP_AF_IB             0x00001000
#define RDMA_CORE_CAP_ETH_AH            0x00002000
#define RDMA_CORE_CAP_OPA_AH            0x00004000
#define RDMA_CORE_CAP_IB_GRH_REQUIRED   0x00008000

/* Protocol                             0xFFF00000 */
#define RDMA_CORE_CAP_PROT_IB           0x00100000
#define RDMA_CORE_CAP_PROT_ROCE         0x00200000
#define RDMA_CORE_CAP_PROT_IWARP        0x00400000
#define RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP 0x00800000
#define RDMA_CORE_CAP_PROT_RAW_PACKET   0x01000000
#define RDMA_CORE_CAP_PROT_USNIC        0x02000000

#define RDMA_CORE_PORT_IB_GRH_REQUIRED (RDMA_CORE_CAP_IB_GRH_REQUIRED \
     | RDMA_CORE_CAP_PROT_ROCE     \
     | RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP)

#define RDMA_CORE_PORT_IBA_IB          (RDMA_CORE_CAP_PROT_IB  \
     | RDMA_CORE_CAP_IB_MAD \
     | RDMA_CORE_CAP_IB_SMI \
     | RDMA_CORE_CAP_IB_CM  \
     | RDMA_CORE_CAP_IB_SA  \
     | RDMA_CORE_CAP_AF_IB)
#define RDMA_CORE_PORT_IBA_ROCE        (RDMA_CORE_CAP_PROT_ROCE \
     | RDMA_CORE_CAP_IB_MAD  \
     | RDMA_CORE_CAP_IB_CM   \
     | RDMA_CORE_CAP_AF_IB   \
     | RDMA_CORE_CAP_ETH_AH)
#define RDMA_CORE_PORT_IBA_ROCE_UDP_ENCAP   \
     (RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP \
     | RDMA_CORE_CAP_IB_MAD  \
     | RDMA_CORE_CAP_IB_CM   \
     | RDMA_CORE_CAP_AF_IB   \
     | RDMA_CORE_CAP_ETH_AH)
#define RDMA_CORE_PORT_IWARP           (RDMA_CORE_CAP_PROT_IWARP \
     | RDMA_CORE_CAP_IW_CM)
#define RDMA_CORE_PORT_INTEL_OPA       (RDMA_CORE_PORT_IBA_IB  \
     | RDMA_CORE_CAP_OPA_MAD)

#define RDMA_CORE_PORT_RAW_PACKET (RDMA_CORE_CAP_PROT_RAW_PACKET)

#define RDMA_CORE_PORT_USNIC  (RDMA_CORE_CAP_PROT_USNIC)

struct ib_port_attr {
 u64   subnet_prefix;
 enum ib_port_state state;
 enum ib_mtu  max_mtu;
 enum ib_mtu  active_mtu;
 u32                     phys_mtu;
 int   gid_tbl_len;
 unsigned int  ip_gids:1;
 /* This is the value from PortInfo CapabilityMask, defined by IBA */
 u32   port_cap_flags;
 u32   max_msg_sz;
 u32   bad_pkey_cntr;
 u32   qkey_viol_cntr;
 u16   pkey_tbl_len;
 u32   sm_lid;
 u32   lid;
 u8   lmc;
 u8   max_vl_num;
 u8   sm_sl;
 u8   subnet_timeout;
 u8   init_type_reply;
 u8   active_width;
 u16   active_speed;
 u8                      phys_state;
 u16   port_cap_flags2;
};

enum ib_device_modify_flags {
 IB_DEVICE_MODIFY_SYS_IMAGE_GUID = 1 << 0,
 IB_DEVICE_MODIFY_NODE_DESC = 1 << 1
};

#define IB_DEVICE_NODE_DESC_MAX 64

struct ib_device_modify {
 u64 sys_image_guid;
 char node_desc[IB_DEVICE_NODE_DESC_MAX];
};

enum ib_port_modify_flags {
 IB_PORT_SHUTDOWN  = 1,
 IB_PORT_INIT_TYPE  = (1<<2),
 IB_PORT_RESET_QKEY_CNTR  = (1<<3),
 IB_PORT_OPA_MASK_CHG  = (1<<4)
};

struct ib_port_modify {
 u32 set_port_cap_mask;
 u32 clr_port_cap_mask;
 u8 init_type;
};

enum ib_event_type {
 IB_EVENT_CQ_ERR,
 IB_EVENT_QP_FATAL,
 IB_EVENT_QP_REQ_ERR,
 IB_EVENT_QP_ACCESS_ERR,
 IB_EVENT_COMM_EST,
 IB_EVENT_SQ_DRAINED,
 IB_EVENT_PATH_MIG,
 IB_EVENT_PATH_MIG_ERR,
 IB_EVENT_DEVICE_FATAL,
 IB_EVENT_PORT_ACTIVE,
 IB_EVENT_PORT_ERR,
 IB_EVENT_LID_CHANGE,
 IB_EVENT_PKEY_CHANGE,
 IB_EVENT_SM_CHANGE,
 IB_EVENT_SRQ_ERR,
 IB_EVENT_SRQ_LIMIT_REACHED,
 IB_EVENT_QP_LAST_WQE_REACHED,
 IB_EVENT_CLIENT_REREGISTER,
 IB_EVENT_GID_CHANGE,
 IB_EVENT_WQ_FATAL,
};

const char *__attribute_const__ ib_event_msg(enum ib_event_type event);

struct ib_event {
 struct ib_device *device;
 union {
  struct ib_cq *cq;
  struct ib_qp *qp;
  struct ib_srq *srq;
  struct ib_wq *wq;
  u32  port_num;
 } element;
 enum ib_event_type event;
};

struct ib_event_handler {
 struct ib_device *device;
 void            (*handler)(struct ib_event_handler *, struct ib_event *);
 struct list_head  list;
};

#define INIT_IB_EVENT_HANDLER(_ptr, _device, _handler)  \
 do {       \
  (_ptr)->device  = _device;   \
  (_ptr)->handler = _handler;   \
  INIT_LIST_HEAD(&(_ptr)->list);   \
 } while (0)

struct ib_global_route {
 const struct ib_gid_attr *sgid_attr;
 union ib_gid dgid;
 u32  flow_label;
 u8  sgid_index;
 u8  hop_limit;
 u8  traffic_class;
};

struct ib_grh {
 __be32  version_tclass_flow;
 __be16  paylen;
 u8  next_hdr;
 u8  hop_limit;
 union ib_gid sgid;
 union ib_gid dgid;
};

union rdma_network_hdr {
 struct ib_grh ibgrh;
 struct {
  /* The IB spec states that if it's IPv4, the header
 * is located in the last 20 bytes of the header.
 */
  u8  reserved[20];
  struct iphdr roce4grh;
 };
};

#define IB_QPN_MASK  0xFFFFFF

enum {
 IB_MULTICAST_QPN = 0xffffff
};

#define IB_LID_PERMISSIVE cpu_to_be16(0xFFFF)
#define IB_MULTICAST_LID_BASE cpu_to_be16(0xC000)

enum ib_ah_flags {
 IB_AH_GRH = 1
};

enum ib_rate {
 IB_RATE_PORT_CURRENT = 0,
 IB_RATE_2_5_GBPS = 2,
 IB_RATE_5_GBPS   = 5,
 IB_RATE_10_GBPS  = 3,
 IB_RATE_20_GBPS  = 6,
 IB_RATE_30_GBPS  = 4,
 IB_RATE_40_GBPS  = 7,
 IB_RATE_60_GBPS  = 8,
 IB_RATE_80_GBPS  = 9,
 IB_RATE_120_GBPS = 10,
 IB_RATE_14_GBPS  = 11,
 IB_RATE_56_GBPS  = 12,
 IB_RATE_112_GBPS = 13,
 IB_RATE_168_GBPS = 14,
 IB_RATE_25_GBPS  = 15,
 IB_RATE_100_GBPS = 16,
 IB_RATE_200_GBPS = 17,
 IB_RATE_300_GBPS = 18,
 IB_RATE_28_GBPS  = 19,
 IB_RATE_50_GBPS  = 20,
 IB_RATE_400_GBPS = 21,
 IB_RATE_600_GBPS = 22,
 IB_RATE_800_GBPS = 23,
};

/**
 * ib_rate_to_mult - Convert the IB rate enum to a multiple of the
 * base rate of 2.5 Gbit/sec.  For example, IB_RATE_5_GBPS will be
 * converted to 2, since 5 Gbit/sec is 2 * 2.5 Gbit/sec.
 * @rate: rate to convert.
 */
__attribute_const__ int ib_rate_to_mult(enum ib_rate rate);

/**
 * ib_rate_to_mbps - Convert the IB rate enum to Mbps.
 * For example, IB_RATE_2_5_GBPS will be converted to 2500.
 * @rate: rate to convert.
 */
__attribute_const__ int ib_rate_to_mbps(enum ib_rate rate);


/**
 * enum ib_mr_type - memory region type
 * @IB_MR_TYPE_MEM_REG:       memory region that is used for
 *                            normal registration
 * @IB_MR_TYPE_SG_GAPS:       memory region that is capable to
 *                            register any arbitrary sg lists (without
 *                            the normal mr constraints - see
 *                            ib_map_mr_sg)
 * @IB_MR_TYPE_DM:            memory region that is used for device
 *                            memory registration
 * @IB_MR_TYPE_USER:          memory region that is used for the user-space
 *                            application
 * @IB_MR_TYPE_DMA:           memory region that is used for DMA operations
 *                            without address translations (VA=PA)
 * @IB_MR_TYPE_INTEGRITY:     memory region that is used for
 *                            data integrity operations
 */
enum ib_mr_type {
 IB_MR_TYPE_MEM_REG,
 IB_MR_TYPE_SG_GAPS,
 IB_MR_TYPE_DM,
 IB_MR_TYPE_USER,
 IB_MR_TYPE_DMA,
 IB_MR_TYPE_INTEGRITY,
};

enum ib_mr_status_check {
 IB_MR_CHECK_SIG_STATUS = 1,
};

/**
 * struct ib_mr_status - Memory region status container
 *
 * @fail_status: Bitmask of MR checks status. For each
 *     failed check a corresponding status bit is set.
 * @sig_err: Additional info for IB_MR_CEHCK_SIG_STATUS
 *     failure.
 */
struct ib_mr_status {
 u32      fail_status;
 struct ib_sig_err   sig_err;
};

/**
 * mult_to_ib_rate - Convert a multiple of 2.5 Gbit/sec to an IB rate
 * enum.
 * @mult: multiple to convert.
 */
__attribute_const__ enum ib_rate mult_to_ib_rate(int mult);

struct rdma_ah_init_attr {
 struct rdma_ah_attr *ah_attr;
 u32 flags;
 struct net_device *xmit_slave;
};

enum rdma_ah_attr_type {
 RDMA_AH_ATTR_TYPE_UNDEFINED,
 RDMA_AH_ATTR_TYPE_IB,
 RDMA_AH_ATTR_TYPE_ROCE,
 RDMA_AH_ATTR_TYPE_OPA,
};

struct ib_ah_attr {
 u16   dlid;
 u8   src_path_bits;
};

struct roce_ah_attr {
 u8   dmac[ETH_ALEN];
};

struct opa_ah_attr {
 u32   dlid;
 u8   src_path_bits;
 bool   make_grd;
};

struct rdma_ah_attr {
 struct ib_global_route grh;
 u8   sl;
 u8   static_rate;
 u32   port_num;
 u8   ah_flags;
 enum rdma_ah_attr_type type;
 union {
  struct ib_ah_attr ib;
  struct roce_ah_attr roce;
  struct opa_ah_attr opa;
 };
};

enum ib_wc_status {
 IB_WC_SUCCESS,
 IB_WC_LOC_LEN_ERR,
 IB_WC_LOC_QP_OP_ERR,
 IB_WC_LOC_EEC_OP_ERR,
 IB_WC_LOC_PROT_ERR,
 IB_WC_WR_FLUSH_ERR,
 IB_WC_MW_BIND_ERR,
 IB_WC_BAD_RESP_ERR,
 IB_WC_LOC_ACCESS_ERR,
 IB_WC_REM_INV_REQ_ERR,
 IB_WC_REM_ACCESS_ERR,
 IB_WC_REM_OP_ERR,
 IB_WC_RETRY_EXC_ERR,
 IB_WC_RNR_RETRY_EXC_ERR,
 IB_WC_LOC_RDD_VIOL_ERR,
 IB_WC_REM_INV_RD_REQ_ERR,
 IB_WC_REM_ABORT_ERR,
 IB_WC_INV_EECN_ERR,
 IB_WC_INV_EEC_STATE_ERR,
 IB_WC_FATAL_ERR,
 IB_WC_RESP_TIMEOUT_ERR,
 IB_WC_GENERAL_ERR
};

const char *__attribute_const__ ib_wc_status_msg(enum ib_wc_status status);

enum ib_wc_opcode {
 IB_WC_SEND = IB_UVERBS_WC_SEND,
 IB_WC_RDMA_WRITE = IB_UVERBS_WC_RDMA_WRITE,
 IB_WC_RDMA_READ = IB_UVERBS_WC_RDMA_READ,
 IB_WC_COMP_SWAP = IB_UVERBS_WC_COMP_SWAP,
 IB_WC_FETCH_ADD = IB_UVERBS_WC_FETCH_ADD,
 IB_WC_BIND_MW = IB_UVERBS_WC_BIND_MW,
 IB_WC_LOCAL_INV = IB_UVERBS_WC_LOCAL_INV,
 IB_WC_LSO = IB_UVERBS_WC_TSO,
 IB_WC_ATOMIC_WRITE = IB_UVERBS_WC_ATOMIC_WRITE,
 IB_WC_REG_MR,
 IB_WC_MASKED_COMP_SWAP,
 IB_WC_MASKED_FETCH_ADD,
 IB_WC_FLUSH = IB_UVERBS_WC_FLUSH,
/*
 * Set value of IB_WC_RECV so consumers can test if a completion is a
 * receive by testing (opcode & IB_WC_RECV).
 */
 IB_WC_RECV   = 1 << 7,
 IB_WC_RECV_RDMA_WITH_IMM
};

enum ib_wc_flags {
 IB_WC_GRH  = 1,
 IB_WC_WITH_IMM  = (1<<1),
 IB_WC_WITH_INVALIDATE = (1<<2),
 IB_WC_IP_CSUM_OK = (1<<3),
 IB_WC_WITH_SMAC  = (1<<4),
 IB_WC_WITH_VLAN  = (1<<5),
 IB_WC_WITH_NETWORK_HDR_TYPE = (1<<6),
};

struct ib_wc {
 union {
  u64  wr_id;
  struct ib_cqe *wr_cqe;
 };
 enum ib_wc_status status;
 enum ib_wc_opcode opcode;
 u32   vendor_err;
 u32   byte_len;
 struct ib_qp        *qp;
 union {
  __be32  imm_data;
  u32  invalidate_rkey;
 } ex;
 u32   src_qp;
 u32   slid;
 int   wc_flags;
 u16   pkey_index;
 u8   sl;
 u8   dlid_path_bits;
 u32 port_num; /* valid only for DR SMPs on switches */
 u8   smac[ETH_ALEN];
 u16   vlan_id;
 u8   network_hdr_type;
};

enum ib_cq_notify_flags {
 IB_CQ_SOLICITED   = 1 << 0,
 IB_CQ_NEXT_COMP   = 1 << 1,
 IB_CQ_SOLICITED_MASK  = IB_CQ_SOLICITED | IB_CQ_NEXT_COMP,
 IB_CQ_REPORT_MISSED_EVENTS = 1 << 2,
};

enum ib_srq_type {
 IB_SRQT_BASIC = IB_UVERBS_SRQT_BASIC,
 IB_SRQT_XRC = IB_UVERBS_SRQT_XRC,
 IB_SRQT_TM = IB_UVERBS_SRQT_TM,
};

static inline bool ib_srq_has_cq(enum ib_srq_type srq_type)
{
 return srq_type == IB_SRQT_XRC ||
        srq_type == IB_SRQT_TM;
}

enum ib_srq_attr_mask {
 IB_SRQ_MAX_WR = 1 << 0,
 IB_SRQ_LIMIT = 1 << 1,
};

struct ib_srq_attr {
 u32 max_wr;
 u32 max_sge;
 u32 srq_limit;
};

struct ib_srq_init_attr {
 void        (*event_handler)(struct ib_event *, void *);
 void         *srq_context;
 struct ib_srq_attr attr;
 enum ib_srq_type srq_type;

 struct {
  struct ib_cq   *cq;
  union {
   struct {
    struct ib_xrcd *xrcd;
   } xrc;

   struct {
    u32  max_num_tags;
   } tag_matching;
  };
 } ext;
};

struct ib_qp_cap {
 u32 max_send_wr;
 u32 max_recv_wr;
 u32 max_send_sge;
 u32 max_recv_sge;
 u32 max_inline_data;

 /*
 * Maximum number of rdma_rw_ctx structures in flight at a time.
 * ib_create_qp() will calculate the right amount of needed WRs
 * and MRs based on this.
 */
 u32 max_rdma_ctxs;
};

enum ib_sig_type {
 IB_SIGNAL_ALL_WR,
 IB_SIGNAL_REQ_WR
};

enum ib_qp_type {
 /*
 * IB_QPT_SMI and IB_QPT_GSI have to be the first two entries
 * here (and in that order) since the MAD layer uses them as
 * indices into a 2-entry table.
 */
 IB_QPT_SMI,
 IB_QPT_GSI,

 IB_QPT_RC = IB_UVERBS_QPT_RC,
 IB_QPT_UC = IB_UVERBS_QPT_UC,
 IB_QPT_UD = IB_UVERBS_QPT_UD,
 IB_QPT_RAW_IPV6,
 IB_QPT_RAW_ETHERTYPE,
 IB_QPT_RAW_PACKET = IB_UVERBS_QPT_RAW_PACKET,
 IB_QPT_XRC_INI = IB_UVERBS_QPT_XRC_INI,
 IB_QPT_XRC_TGT = IB_UVERBS_QPT_XRC_TGT,
 IB_QPT_MAX,
 IB_QPT_DRIVER = IB_UVERBS_QPT_DRIVER,
 /* Reserve a range for qp types internal to the low level driver.
 * These qp types will not be visible at the IB core layer, so the
 * IB_QPT_MAX usages should not be affected in the core layer
 */
 IB_QPT_RESERVED1 = 0x1000,
 IB_QPT_RESERVED2,
 IB_QPT_RESERVED3,
 IB_QPT_RESERVED4,
 IB_QPT_RESERVED5,
 IB_QPT_RESERVED6,
 IB_QPT_RESERVED7,
 IB_QPT_RESERVED8,
 IB_QPT_RESERVED9,
 IB_QPT_RESERVED10,
};

enum ib_qp_create_flags {
 IB_QP_CREATE_IPOIB_UD_LSO  = 1 << 0,
 IB_QP_CREATE_BLOCK_MULTICAST_LOOPBACK =
  IB_UVERBS_QP_CREATE_BLOCK_MULTICAST_LOOPBACK,
 IB_QP_CREATE_CROSS_CHANNEL              = 1 << 2,
 IB_QP_CREATE_MANAGED_SEND               = 1 << 3,
 IB_QP_CREATE_MANAGED_RECV               = 1 << 4,
 IB_QP_CREATE_NETIF_QP   = 1 << 5,
 IB_QP_CREATE_INTEGRITY_EN  = 1 << 6,
 IB_QP_CREATE_NETDEV_USE   = 1 << 7,
 IB_QP_CREATE_SCATTER_FCS  =
  IB_UVERBS_QP_CREATE_SCATTER_FCS,
 IB_QP_CREATE_CVLAN_STRIPPING  =
  IB_UVERBS_QP_CREATE_CVLAN_STRIPPING,
 IB_QP_CREATE_SOURCE_QPN   = 1 << 10,
 IB_QP_CREATE_PCI_WRITE_END_PADDING =
  IB_UVERBS_QP_CREATE_PCI_WRITE_END_PADDING,
 /* reserve bits 26-31 for low level drivers' internal use */
 IB_QP_CREATE_RESERVED_START  = 1 << 26,
 IB_QP_CREATE_RESERVED_END  = 1 << 31,
};

/*
 * Note: users may not call ib_close_qp or ib_destroy_qp from the event_handler
 * callback to destroy the passed in QP.
 */

struct ib_qp_init_attr {
 /* This callback occurs in workqueue context */
 void                  (*event_handler)(struct ib_event *, void *);

 void         *qp_context;
 struct ib_cq        *send_cq;
 struct ib_cq        *recv_cq;
 struct ib_srq        *srq;
 struct ib_xrcd        *xrcd;     /* XRC TGT QPs only */
 struct ib_qp_cap cap;
 enum ib_sig_type sq_sig_type;
 enum ib_qp_type  qp_type;
 u32   create_flags;

 /*
 * Only needed for special QP types, or when using the RW API.
 */
 u32   port_num;
 struct ib_rwq_ind_table *rwq_ind_tbl;
 u32   source_qpn;
};

struct ib_qp_open_attr {
 void                  (*event_handler)(struct ib_event *, void *);
 void         *qp_context;
 u32   qp_num;
 enum ib_qp_type  qp_type;
};

enum ib_rnr_timeout {
 IB_RNR_TIMER_655_36 =  0,
 IB_RNR_TIMER_000_01 =  1,
 IB_RNR_TIMER_000_02 =  2,
 IB_RNR_TIMER_000_03 =  3,
 IB_RNR_TIMER_000_04 =  4,
 IB_RNR_TIMER_000_06 =  5,
 IB_RNR_TIMER_000_08 =  6,
 IB_RNR_TIMER_000_12 =  7,
 IB_RNR_TIMER_000_16 =  8,
 IB_RNR_TIMER_000_24 =  9,
 IB_RNR_TIMER_000_32 = 10,
 IB_RNR_TIMER_000_48 = 11,
 IB_RNR_TIMER_000_64 = 12,
 IB_RNR_TIMER_000_96 = 13,
 IB_RNR_TIMER_001_28 = 14,
 IB_RNR_TIMER_001_92 = 15,
 IB_RNR_TIMER_002_56 = 16,
 IB_RNR_TIMER_003_84 = 17,
 IB_RNR_TIMER_005_12 = 18,
 IB_RNR_TIMER_007_68 = 19,
 IB_RNR_TIMER_010_24 = 20,
 IB_RNR_TIMER_015_36 = 21,
 IB_RNR_TIMER_020_48 = 22,
 IB_RNR_TIMER_030_72 = 23,
 IB_RNR_TIMER_040_96 = 24,
 IB_RNR_TIMER_061_44 = 25,
 IB_RNR_TIMER_081_92 = 26,
 IB_RNR_TIMER_122_88 = 27,
 IB_RNR_TIMER_163_84 = 28,
 IB_RNR_TIMER_245_76 = 29,
 IB_RNR_TIMER_327_68 = 30,
 IB_RNR_TIMER_491_52 = 31
};

enum ib_qp_attr_mask {
 IB_QP_STATE   = 1,
 IB_QP_CUR_STATE   = (1<<1),
 IB_QP_EN_SQD_ASYNC_NOTIFY = (1<<2),
 IB_QP_ACCESS_FLAGS  = (1<<3),
 IB_QP_PKEY_INDEX  = (1<<4),
 IB_QP_PORT   = (1<<5),
 IB_QP_QKEY   = (1<<6),
 IB_QP_AV   = (1<<7),
 IB_QP_PATH_MTU   = (1<<8),
 IB_QP_TIMEOUT   = (1<<9),
 IB_QP_RETRY_CNT   = (1<<10),
 IB_QP_RNR_RETRY   = (1<<11),
 IB_QP_RQ_PSN   = (1<<12),
 IB_QP_MAX_QP_RD_ATOMIC  = (1<<13),
 IB_QP_ALT_PATH   = (1<<14),
 IB_QP_MIN_RNR_TIMER  = (1<<15),
 IB_QP_SQ_PSN   = (1<<16),
 IB_QP_MAX_DEST_RD_ATOMIC = (1<<17),
 IB_QP_PATH_MIG_STATE  = (1<<18),
 IB_QP_CAP   = (1<<19),
 IB_QP_DEST_QPN   = (1<<20),
 IB_QP_RESERVED1   = (1<<21),
 IB_QP_RESERVED2   = (1<<22),
 IB_QP_RESERVED3   = (1<<23),
 IB_QP_RESERVED4   = (1<<24),
 IB_QP_RATE_LIMIT  = (1<<25),

 IB_QP_ATTR_STANDARD_BITS = GENMASK(20, 0),
};

enum ib_qp_state {
 IB_QPS_RESET,
 IB_QPS_INIT,
 IB_QPS_RTR,
 IB_QPS_RTS,
 IB_QPS_SQD,
 IB_QPS_SQE,
 IB_QPS_ERR
};

enum ib_mig_state {
 IB_MIG_MIGRATED,
 IB_MIG_REARM,
 IB_MIG_ARMED
};

enum ib_mw_type {
 IB_MW_TYPE_1 = 1,
 IB_MW_TYPE_2 = 2
};

struct ib_qp_attr {
 enum ib_qp_state qp_state;
 enum ib_qp_state cur_qp_state;
 enum ib_mtu  path_mtu;
 enum ib_mig_state path_mig_state;
 u32   qkey;
 u32   rq_psn;
 u32   sq_psn;
 u32   dest_qp_num;
 int   qp_access_flags;
 struct ib_qp_cap cap;
 struct rdma_ah_attr ah_attr;
 struct rdma_ah_attr alt_ah_attr;
 u16   pkey_index;
 u16   alt_pkey_index;
 u8   en_sqd_async_notify;
 u8   sq_draining;
 u8   max_rd_atomic;
 u8   max_dest_rd_atomic;
 u8   min_rnr_timer;
 u32   port_num;
 u8   timeout;
 u8   retry_cnt;
 u8   rnr_retry;
 u32   alt_port_num;
 u8   alt_timeout;
 u32   rate_limit;
 struct net_device *xmit_slave;
};

enum ib_wr_opcode {
 /* These are shared with userspace */
 IB_WR_RDMA_WRITE = IB_UVERBS_WR_RDMA_WRITE,
 IB_WR_RDMA_WRITE_WITH_IMM = IB_UVERBS_WR_RDMA_WRITE_WITH_IMM,
 IB_WR_SEND = IB_UVERBS_WR_SEND,
 IB_WR_SEND_WITH_IMM = IB_UVERBS_WR_SEND_WITH_IMM,
 IB_WR_RDMA_READ = IB_UVERBS_WR_RDMA_READ,
 IB_WR_ATOMIC_CMP_AND_SWP = IB_UVERBS_WR_ATOMIC_CMP_AND_SWP,
 IB_WR_ATOMIC_FETCH_AND_ADD = IB_UVERBS_WR_ATOMIC_FETCH_AND_ADD,
 IB_WR_BIND_MW = IB_UVERBS_WR_BIND_MW,
 IB_WR_LSO = IB_UVERBS_WR_TSO,
 IB_WR_SEND_WITH_INV = IB_UVERBS_WR_SEND_WITH_INV,
 IB_WR_RDMA_READ_WITH_INV = IB_UVERBS_WR_RDMA_READ_WITH_INV,
 IB_WR_LOCAL_INV = IB_UVERBS_WR_LOCAL_INV,
 IB_WR_MASKED_ATOMIC_CMP_AND_SWP =
  IB_UVERBS_WR_MASKED_ATOMIC_CMP_AND_SWP,
 IB_WR_MASKED_ATOMIC_FETCH_AND_ADD =
  IB_UVERBS_WR_MASKED_ATOMIC_FETCH_AND_ADD,
 IB_WR_FLUSH = IB_UVERBS_WR_FLUSH,
 IB_WR_ATOMIC_WRITE = IB_UVERBS_WR_ATOMIC_WRITE,

 /* These are kernel only and can not be issued by userspace */
 IB_WR_REG_MR = 0x20,
 IB_WR_REG_MR_INTEGRITY,

 /* reserve values for low level drivers' internal use.
 * These values will not be used at all in the ib core layer.
 */
 IB_WR_RESERVED1 = 0xf0,
 IB_WR_RESERVED2,
 IB_WR_RESERVED3,
 IB_WR_RESERVED4,
 IB_WR_RESERVED5,
 IB_WR_RESERVED6,
 IB_WR_RESERVED7,
 IB_WR_RESERVED8,
 IB_WR_RESERVED9,
 IB_WR_RESERVED10,
};

enum ib_send_flags {
 IB_SEND_FENCE  = 1,
 IB_SEND_SIGNALED = (1<<1),
 IB_SEND_SOLICITED = (1<<2),
 IB_SEND_INLINE  = (1<<3),
 IB_SEND_IP_CSUM  = (1<<4),

 /* reserve bits 26-31 for low level drivers' internal use */
 IB_SEND_RESERVED_START = (1 << 26),
 IB_SEND_RESERVED_END = (1 << 31),
};

struct ib_sge {
 u64 addr;
 u32 length;
 u32 lkey;
};

struct ib_cqe {
 void (*done)(struct ib_cq *cq, struct ib_wc *wc);
};

struct ib_send_wr {
 struct ib_send_wr      *next;
 union {
  u64  wr_id;
  struct ib_cqe *wr_cqe;
 };
 struct ib_sge        *sg_list;
 int   num_sge;
 enum ib_wr_opcode opcode;
 int   send_flags;
 union {
  __be32  imm_data;
  u32  invalidate_rkey;
 } ex;
};

struct ib_rdma_wr {
 struct ib_send_wr wr;
 u64   remote_addr;
 u32   rkey;
};

static inline const struct ib_rdma_wr *rdma_wr(const struct ib_send_wr *wr)
{
 return container_of(wr, struct ib_rdma_wr, wr);
}

struct ib_atomic_wr {
 struct ib_send_wr wr;
 u64   remote_addr;
 u64   compare_add;
 u64   swap;
 u64   compare_add_mask;
 u64   swap_mask;
 u32   rkey;
};

static inline const struct ib_atomic_wr *atomic_wr(const struct ib_send_wr *wr)
{
 return container_of(wr, struct ib_atomic_wr, wr);
}

struct ib_ud_wr {
 struct ib_send_wr wr;
 struct ib_ah  *ah;
 void   *header;
 int   hlen;
 int   mss;
 u32   remote_qpn;
 u32   remote_qkey;
 u16   pkey_index; /* valid for GSI only */
 u32   port_num; /* valid for DR SMPs on switch only */
};

static inline const struct ib_ud_wr *ud_wr(const struct ib_send_wr *wr)
{
 return container_of(wr, struct ib_ud_wr, wr);
}

struct ib_reg_wr {
 struct ib_send_wr wr;
 struct ib_mr  *mr;
 u32   key;
 int   access;
};

static inline const struct ib_reg_wr *reg_wr(const struct ib_send_wr *wr)
{
 return container_of(wr, struct ib_reg_wr, wr);
}

struct ib_recv_wr {
 struct ib_recv_wr      *next;
 union {
  u64  wr_id;
  struct ib_cqe *wr_cqe;
 };
 struct ib_sge        *sg_list;
 int   num_sge;
};

enum ib_access_flags {
 IB_ACCESS_LOCAL_WRITE = IB_UVERBS_ACCESS_LOCAL_WRITE,
 IB_ACCESS_REMOTE_WRITE = IB_UVERBS_ACCESS_REMOTE_WRITE,
 IB_ACCESS_REMOTE_READ = IB_UVERBS_ACCESS_REMOTE_READ,
 IB_ACCESS_REMOTE_ATOMIC = IB_UVERBS_ACCESS_REMOTE_ATOMIC,
 IB_ACCESS_MW_BIND = IB_UVERBS_ACCESS_MW_BIND,
 IB_ZERO_BASED = IB_UVERBS_ACCESS_ZERO_BASED,
 IB_ACCESS_ON_DEMAND = IB_UVERBS_ACCESS_ON_DEMAND,
 IB_ACCESS_HUGETLB = IB_UVERBS_ACCESS_HUGETLB,
 IB_ACCESS_RELAXED_ORDERING = IB_UVERBS_ACCESS_RELAXED_ORDERING,
 IB_ACCESS_FLUSH_GLOBAL = IB_UVERBS_ACCESS_FLUSH_GLOBAL,
 IB_ACCESS_FLUSH_PERSISTENT = IB_UVERBS_ACCESS_FLUSH_PERSISTENT,

 IB_ACCESS_OPTIONAL = IB_UVERBS_ACCESS_OPTIONAL_RANGE,
 IB_ACCESS_SUPPORTED =
  ((IB_ACCESS_FLUSH_PERSISTENT << 1) - 1) | IB_ACCESS_OPTIONAL,
};

/*
 * XXX: these are apparently used for ->rereg_user_mr, no idea why they
 * are hidden here instead of a uapi header!
 */
enum ib_mr_rereg_flags {
 IB_MR_REREG_TRANS = 1,
 IB_MR_REREG_PD  = (1<<1),
 IB_MR_REREG_ACCESS = (1<<2),
 IB_MR_REREG_SUPPORTED = ((IB_MR_REREG_ACCESS << 1) - 1)
};

struct ib_umem;

enum rdma_remove_reason {
 /*
 * Userspace requested uobject deletion or initial try
 * to remove uobject via cleanup. Call could fail
 */
 RDMA_REMOVE_DESTROY,
 /* Context deletion. This call should delete the actual object itself */
 RDMA_REMOVE_CLOSE,
 /* Driver is being hot-unplugged. This call should delete the actual object itself */
 RDMA_REMOVE_DRIVER_REMOVE,
 /* uobj is being cleaned-up before being committed */
 RDMA_REMOVE_ABORT,
 /* The driver failed to destroy the uobject and is being disconnected */
 RDMA_REMOVE_DRIVER_FAILURE,
};

struct ib_rdmacg_object {
#ifdef CONFIG_CGROUP_RDMA
 struct rdma_cgroup *cg;  /* owner rdma cgroup */
#endif
};

struct ib_ucontext {
 struct ib_device       *device;
 struct ib_uverbs_file  *ufile;

 struct ib_rdmacg_object cg_obj;
 u64 enabled_caps;
 /*
 * Implementation details of the RDMA core, don't use in drivers:
 */
 struct rdma_restrack_entry res;
 struct xarray mmap_xa;
};

struct ib_uobject {
 u64   user_handle; /* handle given to us by userspace */
 /* ufile & ucontext owning this object */
 struct ib_uverbs_file  *ufile;
 /* FIXME, save memory: ufile->context == context */
 struct ib_ucontext     *context; /* associated user context */
 void         *object;  /* containing object */
 struct list_head list;  /* link to context's list */
 struct ib_rdmacg_object cg_obj;  /* rdmacg object */
 int   id;  /* index into kernel idr */
 struct kref  ref;
 atomic_t  usecnt;  /* protects exclusive access */
 struct rcu_head  rcu;  /* kfree_rcu() overhead */

 const struct uverbs_api_object *uapi_object;
};

struct ib_udata {
 const void __user *inbuf;
 void __user *outbuf;
 size_t       inlen;
 size_t       outlen;
};

struct ib_pd {
 u32   local_dma_lkey;
 u32   flags;
 struct ib_device       *device;
 struct ib_uobject      *uobject;
 atomic_t           usecnt; /* count all resources */

 u32   unsafe_global_rkey;

 /*
 * Implementation details of the RDMA core, don't use in drivers:
 */
 struct ib_mr        *__internal_mr;
 struct rdma_restrack_entry res;
};

struct ib_xrcd {
 struct ib_device       *device;
 atomic_t  usecnt; /* count all exposed resources */
 struct inode        *inode;
 struct rw_semaphore tgt_qps_rwsem;
 struct xarray  tgt_qps;
};

struct ib_ah {
 struct ib_device *device;
 struct ib_pd  *pd;
 struct ib_uobject *uobject;
 const struct ib_gid_attr *sgid_attr;
 enum rdma_ah_attr_type type;
};

typedef void (*ib_comp_handler)(struct ib_cq *cq, void *cq_context);

enum ib_poll_context {
 IB_POLL_SOFTIRQ,    /* poll from softirq context */
 IB_POLL_WORKQUEUE,    /* poll from workqueue */
 IB_POLL_UNBOUND_WORKQUEUE, /* poll from unbound workqueue */
 IB_POLL_LAST_POOL_TYPE = IB_POLL_UNBOUND_WORKQUEUE,

 IB_POLL_DIRECT,     /* caller context, no hw completions */
};

struct ib_cq {
 struct ib_device       *device;
 struct ib_ucq_object   *uobject;
 ib_comp_handler    comp_handler;
 void                  (*event_handler)(struct ib_event *, void *);
 void                   *cq_context;
 int                cqe;
 unsigned int  cqe_used;
 atomic_t           usecnt; /* count number of work queues */
 enum ib_poll_context poll_ctx;
 struct ib_wc  *wc;
 struct list_head        pool_entry;
 union {
  struct irq_poll  iop;
  struct work_struct work;
 };
 struct workqueue_struct *comp_wq;
 struct dim *dim;

 /* updated only by trace points */
 ktime_t timestamp;
 u8 interrupt:1;
 u8 shared:1;
 unsigned int comp_vector;

 /*
 * Implementation details of the RDMA core, don't use in drivers:
 */
 struct rdma_restrack_entry res;
};

struct ib_srq {
 struct ib_device       *device;
 struct ib_pd        *pd;
 struct ib_usrq_object  *uobject;
 void        (*event_handler)(struct ib_event *, void *);
 void         *srq_context;
 enum ib_srq_type srq_type;
 atomic_t  usecnt;

 struct {
  struct ib_cq   *cq;
  union {
   struct {
    struct ib_xrcd *xrcd;
    u32  srq_num;
   } xrc;
  };
 } ext;

 /*
 * Implementation details of the RDMA core, don't use in drivers:
 */
 struct rdma_restrack_entry res;
};

enum ib_raw_packet_caps {
 /*
 * Strip cvlan from incoming packet and report it in the matching work
 * completion is supported.
 */
 IB_RAW_PACKET_CAP_CVLAN_STRIPPING =
  IB_UVERBS_RAW_PACKET_CAP_CVLAN_STRIPPING,
 /*
 * Scatter FCS field of an incoming packet to host memory is supported.
 */
 IB_RAW_PACKET_CAP_SCATTER_FCS = IB_UVERBS_RAW_PACKET_CAP_SCATTER_FCS,
 /* Checksum offloads are supported (for both send and receive). */
 IB_RAW_PACKET_CAP_IP_CSUM = IB_UVERBS_RAW_PACKET_CAP_IP_CSUM,
 /*
 * When a packet is received for an RQ with no receive WQEs, the
 * packet processing is delayed.
 */
 IB_RAW_PACKET_CAP_DELAY_DROP = IB_UVERBS_RAW_PACKET_CAP_DELAY_DROP,
};

enum ib_wq_type {
 IB_WQT_RQ = IB_UVERBS_WQT_RQ,
};

enum ib_wq_state {
 IB_WQS_RESET,
 IB_WQS_RDY,
 IB_WQS_ERR
};

struct ib_wq {
 struct ib_device       *device;
 struct ib_uwq_object   *uobject;
 void      *wq_context;
 void      (*event_handler)(struct ib_event *, void *);
 struct ib_pd        *pd;
 struct ib_cq        *cq;
 u32  wq_num;
 enum ib_wq_state       state;
 enum ib_wq_type wq_type;
 atomic_t  usecnt;
};

enum ib_wq_flags {
 IB_WQ_FLAGS_CVLAN_STRIPPING = IB_UVERBS_WQ_FLAGS_CVLAN_STRIPPING,
 IB_WQ_FLAGS_SCATTER_FCS  = IB_UVERBS_WQ_FLAGS_SCATTER_FCS,
 IB_WQ_FLAGS_DELAY_DROP  = IB_UVERBS_WQ_FLAGS_DELAY_DROP,
 IB_WQ_FLAGS_PCI_WRITE_END_PADDING =
    IB_UVERBS_WQ_FLAGS_PCI_WRITE_END_PADDING,
};

struct ib_wq_init_attr {
 void         *wq_context;
 enum ib_wq_type wq_type;
 u32  max_wr;
 u32  max_sge;
 struct ib_cq        *cq;
 void      (*event_handler)(struct ib_event *, void *);
 u32  create_flags; /* Use enum ib_wq_flags */
};

enum ib_wq_attr_mask {
 IB_WQ_STATE  = 1 << 0,
 IB_WQ_CUR_STATE  = 1 << 1,
 IB_WQ_FLAGS  = 1 << 2,
};

struct ib_wq_attr {
 enum ib_wq_state wq_state;
 enum ib_wq_state curr_wq_state;
 u32   flags; /* Use enum ib_wq_flags */
 u32   flags_mask; /* Use enum ib_wq_flags */
};

struct ib_rwq_ind_table {
 struct ib_device *device;
 struct ib_uobject      *uobject;
 atomic_t  usecnt;
 u32  ind_tbl_num;
 u32  log_ind_tbl_size;
 struct ib_wq **ind_tbl;
};

struct ib_rwq_ind_table_init_attr {
 u32  log_ind_tbl_size;
 /* Each entry is a pointer to Receive Work Queue */
 struct ib_wq **ind_tbl;
};

enum port_pkey_state {
 IB_PORT_PKEY_NOT_VALID = 0,
 IB_PORT_PKEY_VALID = 1,
 IB_PORT_PKEY_LISTED = 2,
};

struct ib_qp_security;

struct ib_port_pkey {
 enum port_pkey_state state;
 u16   pkey_index;
 u32   port_num;
 struct list_head qp_list;
 struct list_head to_error_list;
 struct ib_qp_security  *sec;
};

struct ib_ports_pkeys {
 struct ib_port_pkey main;
 struct ib_port_pkey alt;
};

struct ib_qp_security {
 struct ib_qp        *qp;
 struct ib_device       *dev;
 /* Hold this mutex when changing port and pkey settings. */
 struct mutex  mutex;
 struct ib_ports_pkeys  *ports_pkeys;
 /* A list of all open shared QP handles.  Required to enforce security
 * properly for all users of a shared QP.
 */
 struct list_head        shared_qp_list;
 void                   *security;
 bool   destroying;
 atomic_t  error_list_count;
 struct completion error_complete;
 int   error_comps_pending;
};

/*
 * @max_write_sge: Maximum SGE elements per RDMA WRITE request.
 * @max_read_sge:  Maximum SGE elements per RDMA READ request.
 */
struct ib_qp {
 struct ib_device       *device;
 struct ib_pd        *pd;
 struct ib_cq        *send_cq;
 struct ib_cq        *recv_cq;
 spinlock_t  mr_lock;
 int   mrs_used;
 struct list_head rdma_mrs;
 struct list_head sig_mrs;
 struct ib_srq        *srq;
 struct completion srq_completion;
 struct ib_xrcd        *xrcd; /* XRC TGT QPs only */
 struct list_head xrcd_list;

 /* count times opened, mcast attaches, flow attaches */
 atomic_t  usecnt;
 struct list_head open_list;
 struct ib_qp           *real_qp;
 struct ib_uqp_object   *uobject;
 void                  (*event_handler)(struct ib_event *, void *);
 void                  (*registered_event_handler)(struct ib_event *, void *);
 void         *qp_context;
 /* sgid_attrs associated with the AV's */
 const struct ib_gid_attr *av_sgid_attr;
 const struct ib_gid_attr *alt_path_sgid_attr;
 u32   qp_num;
 u32   max_write_sge;
 u32   max_read_sge;
 enum ib_qp_type  qp_type;
 struct ib_rwq_ind_table *rwq_ind_tbl;
 struct ib_qp_security  *qp_sec;
 u32   port;

 bool   integrity_en;
 /*
 * Implementation details of the RDMA core, don't use in drivers:
 */
 struct rdma_restrack_entry     res;

 /* The counter the qp is bind to */
 struct rdma_counter    *counter;
};

struct ib_dm {
 struct ib_device  *device;
 u32     length;
 u32     flags;
 struct ib_uobject *uobject;
 atomic_t    usecnt;
};

/* bit values to mark existence of ib_dmah fields */
enum {
 IB_DMAH_CPU_ID_EXISTS,
 IB_DMAH_MEM_TYPE_EXISTS,
 IB_DMAH_PH_EXISTS,
};

struct ib_dmah {
 struct ib_device *device;
 struct ib_uobject *uobject;
 /*
 * Implementation details of the RDMA core, don't use in drivers:
 */
 struct rdma_restrack_entry res;
 u32 cpu_id;
 enum tph_mem_type mem_type;
 atomic_t usecnt;
 u8 ph;
 u8 valid_fields; /* use IB_DMAH_XXX_EXISTS */
};

struct ib_mr {
 struct ib_device  *device;
 struct ib_pd   *pd;
 u32     lkey;
 u32     rkey;
 u64     iova;
 u64     length;
 unsigned int    page_size;
 enum ib_mr_type    type;
 bool     need_inval;
 union {
  struct ib_uobject *uobject; /* user */
  struct list_head qp_entry; /* FR */
 };

 struct ib_dm      *dm;
 struct ib_sig_attrs *sig_attrs; /* only for IB_MR_TYPE_INTEGRITY MRs */
 struct ib_dmah *dmah;
 /*
 * Implementation details of the RDMA core, don't use in drivers:
 */
 struct rdma_restrack_entry res;
};

struct ib_mw {
 struct ib_device *device;
 struct ib_pd  *pd;
 struct ib_uobject *uobject;
 u32   rkey;
 enum ib_mw_type         type;
};

/* Supported steering options */
enum ib_flow_attr_type {
 /* steering according to rule specifications */
 IB_FLOW_ATTR_NORMAL  = 0x0,
 /* default unicast and multicast rule -
 * receive all Eth traffic which isn't steered to any QP
 */
 IB_FLOW_ATTR_ALL_DEFAULT = 0x1,
 /* default multicast rule -
 * receive all Eth multicast traffic which isn't steered to any QP
 */
 IB_FLOW_ATTR_MC_DEFAULT  = 0x2,
 /* sniffer rule - receive all port traffic */
 IB_FLOW_ATTR_SNIFFER  = 0x3
};

/* Supported steering header types */
enum ib_flow_spec_type {
 /* L2 headers*/
 IB_FLOW_SPEC_ETH  = 0x20,
 IB_FLOW_SPEC_IB   = 0x22,
 /* L3 header*/
 IB_FLOW_SPEC_IPV4  = 0x30,
 IB_FLOW_SPEC_IPV6  = 0x31,
 IB_FLOW_SPEC_ESP                = 0x34,
 /* L4 headers*/
 IB_FLOW_SPEC_TCP  = 0x40,
 IB_FLOW_SPEC_UDP  = 0x41,
 IB_FLOW_SPEC_VXLAN_TUNNEL = 0x50,
 IB_FLOW_SPEC_GRE  = 0x51,
 IB_FLOW_SPEC_MPLS  = 0x60,
 IB_FLOW_SPEC_INNER  = 0x100,
 /* Actions */
 IB_FLOW_SPEC_ACTION_TAG         = 0x1000,
 IB_FLOW_SPEC_ACTION_DROP        = 0x1001,
 IB_FLOW_SPEC_ACTION_HANDLE = 0x1002,
 IB_FLOW_SPEC_ACTION_COUNT       = 0x1003,
};
#define IB_FLOW_SPEC_LAYER_MASK 0xF0
#define IB_FLOW_SPEC_SUPPORT_LAYERS 10

enum ib_flow_flags {
 IB_FLOW_ATTR_FLAGS_DONT_TRAP = 1UL << 1, /* Continue match, no steal */
 IB_FLOW_ATTR_FLAGS_EGRESS = 1UL << 2, /* Egress flow */
 IB_FLOW_ATTR_FLAGS_RESERVED  = 1UL << 3  /* Must be last */
};

struct ib_flow_eth_filter {
 u8 dst_mac[6];
 u8 src_mac[6];
 __be16 ether_type;
 __be16 vlan_tag;
};

struct ib_flow_spec_eth {
 u32     type;
 u16     size;
 struct ib_flow_eth_filter val;
 struct ib_flow_eth_filter mask;
};

struct ib_flow_ib_filter {
 __be16 dlid;
 __u8   sl;
};

struct ib_flow_spec_ib {
 u32    type;
 u16    size;
 struct ib_flow_ib_filter val;
 struct ib_flow_ib_filter mask;
};

/* IPv4 header flags */
enum ib_ipv4_flags {
 IB_IPV4_DONT_FRAG = 0x2, /* Don't enable packet fragmentation */
 IB_IPV4_MORE_FRAG = 0X4  /* For All fragmented packets except the
    last have this flag set */
};

struct ib_flow_ipv4_filter {
 __be32 src_ip;
 __be32 dst_ip;
 u8 proto;
 u8 tos;
 u8 ttl;
 u8 flags;
};

struct ib_flow_spec_ipv4 {
 u32      type;
 u16      size;
 struct ib_flow_ipv4_filter val;
 struct ib_flow_ipv4_filter mask;
};

struct ib_flow_ipv6_filter {
 u8 src_ip[16];
 u8 dst_ip[16];
 __be32 flow_label;
 u8 next_hdr;
 u8 traffic_class;
 u8 hop_limit;
} __packed;

struct ib_flow_spec_ipv6 {
 u32      type;
 u16      size;
 struct ib_flow_ipv6_filter val;
 struct ib_flow_ipv6_filter mask;
};

struct ib_flow_tcp_udp_filter {
 __be16 dst_port;
 __be16 src_port;
};

struct ib_flow_spec_tcp_udp {
 u32         type;
 u16         size;
 struct ib_flow_tcp_udp_filter val;
 struct ib_flow_tcp_udp_filter mask;
};

struct ib_flow_tunnel_filter {
 __be32 tunnel_id;
};

/* ib_flow_spec_tunnel describes the Vxlan tunnel
 * the tunnel_id from val has the vni value
 */
struct ib_flow_spec_tunnel {
 u32         type;
 u16         size;
 struct ib_flow_tunnel_filter  val;
 struct ib_flow_tunnel_filter  mask;
};

struct ib_flow_esp_filter {
 __be32 spi;
 __be32  seq;
};

struct ib_flow_spec_esp {
 u32                           type;
 u16         size;
 struct ib_flow_esp_filter     val;
 struct ib_flow_esp_filter     mask;
};

struct ib_flow_gre_filter {
 __be16 c_ks_res0_ver;
 __be16 protocol;
 __be32 key;
};

struct ib_flow_spec_gre {
 u32                           type;
 u16         size;
 struct ib_flow_gre_filter     val;
 struct ib_flow_gre_filter     mask;
};

struct ib_flow_mpls_filter {
 __be32 tag;
};

struct ib_flow_spec_mpls {
 u32                           type;
 u16         size;
 struct ib_flow_mpls_filter     val;
 struct ib_flow_mpls_filter     mask;
};

struct ib_flow_spec_action_tag {
 enum ib_flow_spec_type       type;
 u16         size;
 u32                           tag_id;
};

struct ib_flow_spec_action_drop {
 enum ib_flow_spec_type       type;
 u16         size;
};

struct ib_flow_spec_action_handle {
 enum ib_flow_spec_type       type;
 u16         size;
 struct ib_flow_action      *act;
};

enum ib_counters_description {
 IB_COUNTER_PACKETS,
 IB_COUNTER_BYTES,
};

struct ib_flow_spec_action_count {
 enum ib_flow_spec_type type;
 u16 size;
 struct ib_counters *counters;
};

union ib_flow_spec {
 struct {
  u32   type;
  u16   size;
 };
 struct ib_flow_spec_eth  eth;
 struct ib_flow_spec_ib  ib;
 struct ib_flow_spec_ipv4        ipv4;
 struct ib_flow_spec_tcp_udp tcp_udp;
 struct ib_flow_spec_ipv6        ipv6;
 struct ib_flow_spec_tunnel      tunnel;
 struct ib_flow_spec_esp  esp;
 struct ib_flow_spec_gre  gre;
 struct ib_flow_spec_mpls mpls;
 struct ib_flow_spec_action_tag  flow_tag;
 struct ib_flow_spec_action_drop drop;
 struct ib_flow_spec_action_handle action;
 struct ib_flow_spec_action_count flow_count;
};

struct ib_flow_attr {
 enum ib_flow_attr_type type;
 u16      size;
 u16      priority;
 u32      flags;
 u8      num_of_specs;
 u32      port;
 union ib_flow_spec flows[];
};

struct ib_flow {
 struct ib_qp  *qp;
 struct ib_device *device;
 struct ib_uobject *uobject;
};

enum ib_flow_action_type {
 IB_FLOW_ACTION_UNSPECIFIED,
 IB_FLOW_ACTION_ESP = 1,
};

struct ib_flow_action_attrs_esp_keymats {
 enum ib_uverbs_flow_action_esp_keymat   protocol;
 union {
  struct ib_uverbs_flow_action_esp_keymat_aes_gcm aes_gcm;
 } keymat;
};

struct ib_flow_action_attrs_esp_replays {
 enum ib_uverbs_flow_action_esp_replay   protocol;
 union {
  struct ib_uverbs_flow_action_esp_replay_bmp bmp;
 } replay;
};

enum ib_flow_action_attrs_esp_flags {
 /* All user-space flags at the top: Use enum ib_uverbs_flow_action_esp_flags
 * This is done in order to share the same flags between user-space and
 * kernel and spare an unnecessary translation.
 */

 /* Kernel flags */
 IB_FLOW_ACTION_ESP_FLAGS_ESN_TRIGGERED = 1ULL << 32,
 IB_FLOW_ACTION_ESP_FLAGS_MOD_ESP_ATTRS = 1ULL << 33,
};

struct ib_flow_spec_list {
 struct ib_flow_spec_list *next;
 union ib_flow_spec  spec;
};

struct ib_flow_action_attrs_esp {
 struct ib_flow_action_attrs_esp_keymats  *keymat;
 struct ib_flow_action_attrs_esp_replays  *replay;
 struct ib_flow_spec_list   *encap;
 /* Used only if IB_FLOW_ACTION_ESP_FLAGS_ESN_TRIGGERED is enabled.
 * Value of 0 is a valid value.
 */
 u32      esn;
 u32      spi;
 u32      seq;
 u32      tfc_pad;
 /* Use enum ib_flow_action_attrs_esp_flags */
 u64      flags;
 u64      hard_limit_pkts;
};

struct ib_flow_action {
 struct ib_device  *device;
 struct ib_uobject  *uobject;
 enum ib_flow_action_type type;
 atomic_t   usecnt;
};

struct ib_mad;

enum ib_process_mad_flags {
 IB_MAD_IGNORE_MKEY = 1,
 IB_MAD_IGNORE_BKEY = 2,
 IB_MAD_IGNORE_ALL = IB_MAD_IGNORE_MKEY | IB_MAD_IGNORE_BKEY
};

enum ib_mad_result {
 IB_MAD_RESULT_FAILURE  = 0,      /* (!SUCCESS is the important flag) */
 IB_MAD_RESULT_SUCCESS  = 1 << 0, /* MAD was successfully processed   */
 IB_MAD_RESULT_REPLY    = 1 << 1, /* Reply packet needs to be sent    */
 IB_MAD_RESULT_CONSUMED = 1 << 2  /* Packet consumed: stop processing */
};

struct ib_port_cache {
 u64        subnet_prefix;
 struct ib_pkey_cache  *pkey;
 struct ib_gid_table   *gid;
 u8                     lmc;
 enum ib_port_state     port_state;
 enum ib_port_state     last_port_state;
};

struct ib_port_immutable {
 int                           pkey_tbl_len;
 int                           gid_tbl_len;
 u32                           core_cap_flags;
 u32                           max_mad_size;
};

struct ib_port_data {
 struct ib_device *ib_dev;

 struct ib_port_immutable immutable;

 spinlock_t pkey_list_lock;

 spinlock_t netdev_lock;

 struct list_head pkey_list;

 struct ib_port_cache cache;

 struct net_device __rcu *netdev;
 netdevice_tracker netdev_tracker;
 struct hlist_node ndev_hash_link;
 struct rdma_port_counter port_counter;
 struct ib_port *sysfs;
};

/* rdma netdev type - specifies protocol type */
enum rdma_netdev_t {
 RDMA_NETDEV_OPA_VNIC,
 RDMA_NETDEV_IPOIB,
};

/**
 * struct rdma_netdev - rdma netdev
 * For cases where netstack interfacing is required.
 */
struct rdma_netdev {
 void              *clnt_priv;
 struct ib_device  *hca;
 u32     port_num;
 int                mtu;

 /*
 * cleanup function must be specified.
 * FIXME: This is only used for OPA_VNIC and that usage should be
 * removed too.
 */
 void (*free_rdma_netdev)(struct net_device *netdev);

 /* control functions */
 void (*set_id)(struct net_device *netdev, int id);
 /* send packet */
 int (*send)(struct net_device *dev, struct sk_buff *skb,
      struct ib_ah *address, u32 dqpn);
 /* multicast */
 int (*attach_mcast)(struct net_device *dev, struct ib_device *hca,
       union ib_gid *gid, u16 mlid,
       int set_qkey, u32 qkey);
 int (*detach_mcast)(struct net_device *dev, struct ib_device *hca,
       union ib_gid *gid, u16 mlid);
 /* timeout */
 void (*tx_timeout)(struct net_device *dev, unsigned int txqueue);
};

struct rdma_netdev_alloc_params {
 size_t sizeof_priv;
 unsigned int txqs;
 unsigned int rxqs;
 void *param;

 int (*initialize_rdma_netdev)(struct ib_device *device, u32 port_num,
          struct net_device *netdev, void *param);
};

struct ib_odp_counters {
 atomic64_t faults;
 atomic64_t faults_handled;
 atomic64_t invalidations;
 atomic64_t invalidations_handled;
 atomic64_t prefetch;
};

struct ib_counters {
 struct ib_device *device;
 struct ib_uobject *uobject;
 /* num of objects attached */
 atomic_t usecnt;
};

struct ib_counters_read_attr {
 u64 *counters_buff;
 u32 ncounters;
 u32 flags; /* use enum ib_read_counters_flags */
};

struct uverbs_attr_bundle;
struct iw_cm_id;
struct iw_cm_conn_param;

#define INIT_RDMA_OBJ_SIZE(ib_struct, drv_struct, member)                      \
 .size_##ib_struct =                                                    \
  (sizeof(struct drv_struct) +                                   \
   BUILD_BUG_ON_ZERO(offsetof(struct drv_struct, member)) +      \
   BUILD_BUG_ON_ZERO(                                            \
    !__same_type(((struct drv_struct *)NULL)->member,     \
          struct ib_struct)))

#define rdma_zalloc_drv_obj_gfp(ib_dev, ib_type, gfp)                          \
 ((struct ib_type *)rdma_zalloc_obj(ib_dev, ib_dev->ops.size_##ib_type, \
        gfp, false))

#define rdma_zalloc_drv_obj_numa(ib_dev, ib_type)                              \
 ((struct ib_type *)rdma_zalloc_obj(ib_dev, ib_dev->ops.size_##ib_type, \
        GFP_KERNEL, true))

#define rdma_zalloc_drv_obj(ib_dev, ib_type)                                   \
 rdma_zalloc_drv_obj_gfp(ib_dev, ib_type, GFP_KERNEL)

#define DECLARE_RDMA_OBJ_SIZE(ib_struct) size_t size_##ib_struct

struct rdma_user_mmap_entry {
 struct kref ref;
 struct ib_ucontext *ucontext;
 unsigned long start_pgoff;
 size_t npages;
 bool driver_removed;
};

/* Return the offset (in bytes) the user should pass to libc's mmap() */
static inline u64
rdma_user_mmap_get_offset(const struct rdma_user_mmap_entry *entry)
{
 return (u64)entry->start_pgoff << PAGE_SHIFT;
}

/**
 * struct ib_device_ops - InfiniBand device operations
 * This structure defines all the InfiniBand device operations, providers will
 * need to define the supported operations, otherwise they will be set to null.
 */
struct ib_device_ops {
 struct module *owner;
 enum rdma_driver_id driver_id;
 u32 uverbs_abi_ver;
 unsigned int uverbs_no_driver_id_binding:1;

 /*
 * NOTE: New drivers should not make use of device_group; instead new
 * device parameter should be exposed via netlink command. This
 * mechanism exists only for existing drivers.
 */
 const struct attribute_group *device_group;
 const struct attribute_group **port_groups;

 int (*post_send)(struct ib_qp *qp, const struct ib_send_wr *send_wr,
    const struct ib_send_wr **bad_send_wr);
 int (*post_recv)(struct ib_qp *qp, const struct ib_recv_wr *recv_wr,
    const struct ib_recv_wr **bad_recv_wr);
 void (*drain_rq)(struct ib_qp *qp);
 void (*drain_sq)(struct ib_qp *qp);
 int (*poll_cq)(struct ib_cq *cq, int num_entries, struct ib_wc *wc);
 int (*peek_cq)(struct ib_cq *cq, int wc_cnt);
 int (*req_notify_cq)(struct ib_cq *cq, enum ib_cq_notify_flags flags);
 int (*post_srq_recv)(struct ib_srq *srq,
        const struct ib_recv_wr *recv_wr,
        const struct ib_recv_wr **bad_recv_wr);
 int (*process_mad)(struct ib_device *device, int process_mad_flags,
      u32 port_num, const struct ib_wc *in_wc,
      const struct ib_grh *in_grh,
      const struct ib_mad *in_mad, struct ib_mad *out_mad,
      size_t *out_mad_size, u16 *out_mad_pkey_index);
 int (*query_device)(struct ib_device *device,
       struct ib_device_attr *device_attr,
       struct ib_udata *udata);
 int (*modify_device)(struct ib_device *device, int device_modify_mask,
        struct ib_device_modify *device_modify);
 void (*get_dev_fw_str)(struct ib_device *device, char *str);
 const struct cpumask *(*get_vector_affinity)(struct ib_device *ibdev,
           int comp_vector);
 int (*query_port)(struct ib_device *device, u32 port_num,
     struct ib_port_attr *port_attr);
 int (*modify_port)(struct ib_device *device, u32 port_num,
      int port_modify_mask,
      struct ib_port_modify *port_modify);
 /**
 * The following mandatory functions are used only at device
 * registration.  Keep functions such as these at the end of this
 * structure to avoid cache line misses when accessing struct ib_device
 * in fast paths.
 */
 int (*get_port_immutable)(struct ib_device *device, u32 port_num,
      struct ib_port_immutable *immutable);
 enum rdma_link_layer (*get_link_layer)(struct ib_device *device,
            u32 port_num);
 /**
 * When calling get_netdev, the HW vendor's driver should return the
 * net device of device @device at port @port_num or NULL if such
 * a net device doesn't exist. The vendor driver should call dev_hold
 * on this net device. The HW vendor's device driver must guarantee
 * that this function returns NULL before the net device has finished
 * NETDEV_UNREGISTER state.
 */
 struct net_device *(*get_netdev)(struct ib_device *device,
      u32 port_num);
 /**
 * rdma netdev operation
 *
 * Driver implementing alloc_rdma_netdev or rdma_netdev_get_params
 * must return -EOPNOTSUPP if it doesn't support the specified type.
 */
 struct net_device *(*alloc_rdma_netdev)(
  struct ib_device *device, u32 port_num, enum rdma_netdev_t type,
  const char *name, unsigned char name_assign_type,
  void (*setup)(struct net_device *));

 int (*rdma_netdev_get_params)(struct ib_device *device, u32 port_num,
          enum rdma_netdev_t type,
          struct rdma_netdev_alloc_params *params);
 /**
 * query_gid should be return GID value for @device, when @port_num
 * link layer is either IB or iWarp. It is no-op if @port_num port
 * is RoCE link layer.
 */
 int (*query_gid)(struct ib_device *device, u32 port_num, int index,
    union ib_gid *gid);
 /**
 * When calling add_gid, the HW vendor's driver should add the gid
 * of device of port at gid index available at @attr. Meta-info of
 * that gid (for example, the network device related to this gid) is
 * available at @attr. @context allows the HW vendor driver to store
 * extra information together with a GID entry. The HW vendor driver may
 * allocate memory to contain this information and store it in @context
 * when a new GID entry is written to. Params are consistent until the
 * next call of add_gid or delete_gid. The function should return 0 on
 * success or error otherwise. The function could be called
 * concurrently for different ports. This function is only called when
 * roce_gid_table is used.
 */
 int (*add_gid)(const struct ib_gid_attr *attr, void **context);
 /**
 * When calling del_gid, the HW vendor's driver should delete the
 * gid of device @device at gid index gid_index of port port_num
 * available in @attr.
 * Upon the deletion of a GID entry, the HW vendor must free any
 * allocated memory. The caller will clear @context afterwards.
 * This function is only called when roce_gid_table is used.
 */
--> --------------------

--> maximum size reached

--> --------------------