contrib/ofed/libibverbs/verbs.h

   1 /*
   2  * Copyright (c) 2004, 2005 Topspin Communications.  All rights reserved.
   3  * Copyright (c) 2004, 2011-2012 Intel Corporation.  All rights reserved.
   4  * Copyright (c) 2005, 2006, 2007 Cisco Systems, Inc.  All rights reserved.
   5  * Copyright (c) 2005 PathScale, Inc.  All rights reserved.
   6  *
   7  * This software is available to you under a choice of one of two
   8  * licenses.  You may choose to be licensed under the terms of the GNU
   9  * General Public License (GPL) Version 2, available from the file
  10  * COPYING in the main directory of this source tree, or the
  11  * OpenIB.org BSD license below:
  12  *
  13  *     Redistribution and use in source and binary forms, with or
  14  *     without modification, are permitted provided that the following
  15  *     conditions are met:
  16  *
  17  *      - Redistributions of source code must retain the above
  18  *        copyright notice, this list of conditions and the following
  19  *        disclaimer.
  20  *
  21  *      - Redistributions in binary form must reproduce the above
  22  *        copyright notice, this list of conditions and the following
  23  *        disclaimer in the documentation and/or other materials
  24  *        provided with the distribution.
  25  *
  26  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  30  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  31  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  32  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  33  * SOFTWARE.
  34  */
  35
  36 #ifndef INFINIBAND_VERBS_H
  37 #define INFINIBAND_VERBS_H
  38
  39 #include <stdint.h>
  40 #include <pthread.h>
  41 #include <stddef.h>
  42 #include <errno.h>
  43 #include <string.h>
  44 #include <infiniband/types.h>
  45
  46 #ifdef __cplusplus
  47 #  define BEGIN_C_DECLS extern "C" {
  48 #  define END_C_DECLS   }
  49 #else /* !__cplusplus */
  50 #  define BEGIN_C_DECLS
  51 #  define END_C_DECLS
  52 #endif /* __cplusplus */
  53
  54 #if __GNUC__ >= 3
  55 #  define __attribute_const __attribute__((const))
  56 #else
  57 #  define __attribute_const
  58 #endif
  59
  60 BEGIN_C_DECLS
  61
  62 union ibv_gid {
  63         uint8_t                 raw[16];
  64         struct {
  65                 __be64  subnet_prefix;
  66                 __be64  interface_id;
  67         } global;
  68 };
  69
  70 #ifndef container_of
  71 /**
  72   * container_of - cast a member of a structure out to the containing structure
  73   * @ptr:        the pointer to the member.
  74   * @type:       the type of the container struct this is embedded in.
  75   * @member:     the name of the member within the struct.
  76   *
  77  */
  78 #define container_of(ptr, type, member) \
  79         ((type *) ((uint8_t *)(ptr) - offsetof(type, member)))
  80 #endif
  81
  82 #define vext_field_avail(type, fld, sz) (offsetof(type, fld) < (sz))
  83
  84 static void *__VERBS_ABI_IS_EXTENDED = ((uint8_t *) NULL) - 1;
  85
  86 enum ibv_node_type {
  87         IBV_NODE_UNKNOWN        = -1,
  88         IBV_NODE_CA             = 1,
  89         IBV_NODE_SWITCH,
  90         IBV_NODE_ROUTER,
  91         IBV_NODE_RNIC,
  92         IBV_NODE_USNIC,
  93         IBV_NODE_USNIC_UDP,
  94 };
  95
  96 enum ibv_transport_type {
  97         IBV_TRANSPORT_UNKNOWN   = -1,
  98         IBV_TRANSPORT_IB        = 0,
  99         IBV_TRANSPORT_IWARP,
 100         IBV_TRANSPORT_USNIC,
 101         IBV_TRANSPORT_USNIC_UDP,
 102 };
 103
 104 enum ibv_device_cap_flags {
 105         IBV_DEVICE_RESIZE_MAX_WR        = 1,
 106         IBV_DEVICE_BAD_PKEY_CNTR        = 1 <<  1,
 107         IBV_DEVICE_BAD_QKEY_CNTR        = 1 <<  2,
 108         IBV_DEVICE_RAW_MULTI            = 1 <<  3,
 109         IBV_DEVICE_AUTO_PATH_MIG        = 1 <<  4,
 110         IBV_DEVICE_CHANGE_PHY_PORT      = 1 <<  5,
 111         IBV_DEVICE_UD_AV_PORT_ENFORCE   = 1 <<  6,
 112         IBV_DEVICE_CURR_QP_STATE_MOD    = 1 <<  7,
 113         IBV_DEVICE_SHUTDOWN_PORT        = 1 <<  8,
 114         IBV_DEVICE_INIT_TYPE            = 1 <<  9,
 115         IBV_DEVICE_PORT_ACTIVE_EVENT    = 1 << 10,
 116         IBV_DEVICE_SYS_IMAGE_GUID       = 1 << 11,
 117         IBV_DEVICE_RC_RNR_NAK_GEN       = 1 << 12,
 118         IBV_DEVICE_SRQ_RESIZE           = 1 << 13,
 119         IBV_DEVICE_N_NOTIFY_CQ          = 1 << 14,
 120         IBV_DEVICE_MEM_WINDOW           = 1 << 17,
 121         IBV_DEVICE_UD_IP_CSUM           = 1 << 18,
 122         IBV_DEVICE_XRC                  = 1 << 20,
 123         IBV_DEVICE_MEM_MGT_EXTENSIONS   = 1 << 21,
 124         IBV_DEVICE_MEM_WINDOW_TYPE_2A   = 1 << 23,
 125         IBV_DEVICE_MEM_WINDOW_TYPE_2B   = 1 << 24,
 126         IBV_DEVICE_RC_IP_CSUM           = 1 << 25,
 127         IBV_DEVICE_RAW_IP_CSUM          = 1 << 26,
 128         IBV_DEVICE_MANAGED_FLOW_STEERING = 1 << 29
 129 };
 130
 131 /*
 132  * Can't extended above ibv_device_cap_flags enum as in some systems/compilers
 133  * enum range is limited to 4 bytes.
 134  */
 135 #define IBV_DEVICE_RAW_SCATTER_FCS (1ULL << 34)
 136
 137 enum ibv_atomic_cap {
 138         IBV_ATOMIC_NONE,
 139         IBV_ATOMIC_HCA,
 140         IBV_ATOMIC_GLOB
 141 };
 142
 143 struct ibv_device_attr {
 144         char                    fw_ver[64];
 145         __be64                  node_guid;
 146         __be64                  sys_image_guid;
 147         uint64_t                max_mr_size;
 148         uint64_t                page_size_cap;
 149         uint32_t                vendor_id;
 150         uint32_t                vendor_part_id;
 151         uint32_t                hw_ver;
 152         int                     max_qp;
 153         int                     max_qp_wr;
 154         int                     device_cap_flags;
 155         int                     max_sge;
 156         int                     max_sge_rd;
 157         int                     max_cq;
 158         int                     max_cqe;
 159         int                     max_mr;
 160         int                     max_pd;
 161         int                     max_qp_rd_atom;
 162         int                     max_ee_rd_atom;
 163         int                     max_res_rd_atom;
 164         int                     max_qp_init_rd_atom;
 165         int                     max_ee_init_rd_atom;
 166         enum ibv_atomic_cap     atomic_cap;
 167         int                     max_ee;
 168         int                     max_rdd;
 169         int                     max_mw;
 170         int                     max_raw_ipv6_qp;
 171         int                     max_raw_ethy_qp;
 172         int                     max_mcast_grp;
 173         int                     max_mcast_qp_attach;
 174         int                     max_total_mcast_qp_attach;
 175         int                     max_ah;
 176         int                     max_fmr;
 177         int                     max_map_per_fmr;
 178         int                     max_srq;
 179         int                     max_srq_wr;
 180         int                     max_srq_sge;
 181         uint16_t                max_pkeys;
 182         uint8_t                 local_ca_ack_delay;
 183         uint8_t                 phys_port_cnt;
 184 };
 185
 186 /* An extensible input struct for possible future extensions of the
 187  * ibv_query_device_ex verb. */
 188 struct ibv_query_device_ex_input {
 189         uint32_t                comp_mask;
 190 };
 191
 192 enum ibv_odp_transport_cap_bits {
 193         IBV_ODP_SUPPORT_SEND     = 1 << 0,
 194         IBV_ODP_SUPPORT_RECV     = 1 << 1,
 195         IBV_ODP_SUPPORT_WRITE    = 1 << 2,
 196         IBV_ODP_SUPPORT_READ     = 1 << 3,
 197         IBV_ODP_SUPPORT_ATOMIC   = 1 << 4,
 198 };
 199
 200 struct ibv_odp_caps {
 201         uint64_t general_caps;
 202         struct {
 203                 uint32_t rc_odp_caps;
 204                 uint32_t uc_odp_caps;
 205                 uint32_t ud_odp_caps;
 206         } per_transport_caps;
 207 };
 208
 209 enum ibv_odp_general_caps {
 210         IBV_ODP_SUPPORT = 1 << 0,
 211 };
 212
 213 struct ibv_tso_caps {
 214         uint32_t max_tso;
 215         uint32_t supported_qpts;
 216 };
 217
 218 /* RX Hash function flags */
 219 enum ibv_rx_hash_function_flags {
 220         IBV_RX_HASH_FUNC_TOEPLITZ       = 1 << 0,
 221 };
 222
 223 /*
 224  * RX Hash fields enable to set which incoming packet's field should
 225  * participates in RX Hash. Each flag represent certain packet's field,
 226  * when the flag is set the field that is represented by the flag will
 227  * participate in RX Hash calculation.
 228  * Note: *IPV4 and *IPV6 flags can't be enabled together on the same QP
 229  * and *TCP and *UDP flags can't be enabled together on the same QP.
 230 */
 231 enum ibv_rx_hash_fields {
 232         IBV_RX_HASH_SRC_IPV4    = 1 << 0,
 233         IBV_RX_HASH_DST_IPV4    = 1 << 1,
 234         IBV_RX_HASH_SRC_IPV6    = 1 << 2,
 235         IBV_RX_HASH_DST_IPV6    = 1 << 3,
 236         IBV_RX_HASH_SRC_PORT_TCP        = 1 << 4,
 237         IBV_RX_HASH_DST_PORT_TCP        = 1 << 5,
 238         IBV_RX_HASH_SRC_PORT_UDP        = 1 << 6,
 239         IBV_RX_HASH_DST_PORT_UDP        = 1 << 7
 240 };
 241
 242 struct ibv_rss_caps {
 243         uint32_t supported_qpts;
 244         uint32_t max_rwq_indirection_tables;
 245         uint32_t max_rwq_indirection_table_size;
 246         uint64_t rx_hash_fields_mask; /* enum ibv_rx_hash_fields */
 247         uint8_t  rx_hash_function; /* enum ibv_rx_hash_function_flags */
 248 };
 249
 250 struct ibv_packet_pacing_caps {
 251         uint32_t qp_rate_limit_min;
 252         uint32_t qp_rate_limit_max; /* In kbps */
 253         uint32_t supported_qpts;
 254 };
 255
 256 enum ibv_raw_packet_caps {
 257         IBV_RAW_PACKET_CAP_CVLAN_STRIPPING      = 1 << 0,
 258         IBV_RAW_PACKET_CAP_SCATTER_FCS          = 1 << 1,
 259         IBV_RAW_PACKET_CAP_IP_CSUM              = 1 << 2,
 260 };
 261
 262 struct ibv_device_attr_ex {
 263         struct ibv_device_attr  orig_attr;
 264         uint32_t                comp_mask;
 265         struct ibv_odp_caps     odp_caps;
 266         uint64_t                completion_timestamp_mask;
 267         uint64_t                hca_core_clock;
 268         uint64_t                device_cap_flags_ex;
 269         struct ibv_tso_caps     tso_caps;
 270         struct ibv_rss_caps     rss_caps;
 271         uint32_t                max_wq_type_rq;
 272         struct ibv_packet_pacing_caps packet_pacing_caps;
 273         uint32_t                raw_packet_caps; /* Use ibv_raw_packet_caps */
 274 };
 275
 276 enum ibv_mtu {
 277         IBV_MTU_256  = 1,
 278         IBV_MTU_512  = 2,
 279         IBV_MTU_1024 = 3,
 280         IBV_MTU_2048 = 4,
 281         IBV_MTU_4096 = 5
 282 };
 283
 284 enum ibv_port_state {
 285         IBV_PORT_NOP            = 0,
 286         IBV_PORT_DOWN           = 1,
 287         IBV_PORT_INIT           = 2,
 288         IBV_PORT_ARMED          = 3,
 289         IBV_PORT_ACTIVE         = 4,
 290         IBV_PORT_ACTIVE_DEFER   = 5
 291 };
 292
 293 enum {
 294         IBV_LINK_LAYER_UNSPECIFIED,
 295         IBV_LINK_LAYER_INFINIBAND,
 296         IBV_LINK_LAYER_ETHERNET,
 297 };
 298
 299 enum ibv_port_cap_flags {
 300         IBV_PORT_SM                             = 1 <<  1,
 301         IBV_PORT_NOTICE_SUP                     = 1 <<  2,
 302         IBV_PORT_TRAP_SUP                       = 1 <<  3,
 303         IBV_PORT_OPT_IPD_SUP                    = 1 <<  4,
 304         IBV_PORT_AUTO_MIGR_SUP                  = 1 <<  5,
 305         IBV_PORT_SL_MAP_SUP                     = 1 <<  6,
 306         IBV_PORT_MKEY_NVRAM                     = 1 <<  7,
 307         IBV_PORT_PKEY_NVRAM                     = 1 <<  8,
 308         IBV_PORT_LED_INFO_SUP                   = 1 <<  9,
 309         IBV_PORT_SYS_IMAGE_GUID_SUP             = 1 << 11,
 310         IBV_PORT_PKEY_SW_EXT_PORT_TRAP_SUP      = 1 << 12,
 311         IBV_PORT_EXTENDED_SPEEDS_SUP            = 1 << 14,
 312         IBV_PORT_CM_SUP                         = 1 << 16,
 313         IBV_PORT_SNMP_TUNNEL_SUP                = 1 << 17,
 314         IBV_PORT_REINIT_SUP                     = 1 << 18,
 315         IBV_PORT_DEVICE_MGMT_SUP                = 1 << 19,
 316         IBV_PORT_VENDOR_CLASS_SUP               = 1 << 20,
 317         IBV_PORT_DR_NOTICE_SUP                  = 1 << 21,
 318         IBV_PORT_CAP_MASK_NOTICE_SUP            = 1 << 22,
 319         IBV_PORT_BOOT_MGMT_SUP                  = 1 << 23,
 320         IBV_PORT_LINK_LATENCY_SUP               = 1 << 24,
 321         IBV_PORT_CLIENT_REG_SUP                 = 1 << 25,
 322         IBV_PORT_IP_BASED_GIDS                  = 1 << 26
 323 };
 324
 325 struct ibv_port_attr {
 326         enum ibv_port_state     state;
 327         enum ibv_mtu            max_mtu;
 328         enum ibv_mtu            active_mtu;
 329         int                     gid_tbl_len;
 330         uint32_t                port_cap_flags;
 331         uint32_t                max_msg_sz;
 332         uint32_t                bad_pkey_cntr;
 333         uint32_t                qkey_viol_cntr;
 334         uint16_t                pkey_tbl_len;
 335         uint16_t                lid;
 336         uint16_t                sm_lid;
 337         uint8_t                 lmc;
 338         uint8_t                 max_vl_num;
 339         uint8_t                 sm_sl;
 340         uint8_t                 subnet_timeout;
 341         uint8_t                 init_type_reply;
 342         uint8_t                 active_width;
 343         uint8_t                 active_speed;
 344         uint8_t                 phys_state;
 345         uint8_t                 link_layer;
 346         uint8_t                 reserved;
 347 };
 348
 349 enum ibv_event_type {
 350         IBV_EVENT_CQ_ERR,
 351         IBV_EVENT_QP_FATAL,
 352         IBV_EVENT_QP_REQ_ERR,
 353         IBV_EVENT_QP_ACCESS_ERR,
 354         IBV_EVENT_COMM_EST,
 355         IBV_EVENT_SQ_DRAINED,
 356         IBV_EVENT_PATH_MIG,
 357         IBV_EVENT_PATH_MIG_ERR,
 358         IBV_EVENT_DEVICE_FATAL,
 359         IBV_EVENT_PORT_ACTIVE,
 360         IBV_EVENT_PORT_ERR,
 361         IBV_EVENT_LID_CHANGE,
 362         IBV_EVENT_PKEY_CHANGE,
 363         IBV_EVENT_SM_CHANGE,
 364         IBV_EVENT_SRQ_ERR,
 365         IBV_EVENT_SRQ_LIMIT_REACHED,
 366         IBV_EVENT_QP_LAST_WQE_REACHED,
 367         IBV_EVENT_CLIENT_REREGISTER,
 368         IBV_EVENT_GID_CHANGE,
 369         IBV_EVENT_WQ_FATAL,
 370 };
 371
 372 struct ibv_async_event {
 373         union {
 374                 struct ibv_cq  *cq;
 375                 struct ibv_qp  *qp;
 376                 struct ibv_srq *srq;
 377                 struct ibv_wq  *wq;
 378                 int             port_num;
 379         } element;
 380         enum ibv_event_type     event_type;
 381 };
 382
 383 enum ibv_wc_status {
 384         IBV_WC_SUCCESS,
 385         IBV_WC_LOC_LEN_ERR,
 386         IBV_WC_LOC_QP_OP_ERR,
 387         IBV_WC_LOC_EEC_OP_ERR,
 388         IBV_WC_LOC_PROT_ERR,
 389         IBV_WC_WR_FLUSH_ERR,
 390         IBV_WC_MW_BIND_ERR,
 391         IBV_WC_BAD_RESP_ERR,
 392         IBV_WC_LOC_ACCESS_ERR,
 393         IBV_WC_REM_INV_REQ_ERR,
 394         IBV_WC_REM_ACCESS_ERR,
 395         IBV_WC_REM_OP_ERR,
 396         IBV_WC_RETRY_EXC_ERR,
 397         IBV_WC_RNR_RETRY_EXC_ERR,
 398         IBV_WC_LOC_RDD_VIOL_ERR,
 399         IBV_WC_REM_INV_RD_REQ_ERR,
 400         IBV_WC_REM_ABORT_ERR,
 401         IBV_WC_INV_EECN_ERR,
 402         IBV_WC_INV_EEC_STATE_ERR,
 403         IBV_WC_FATAL_ERR,
 404         IBV_WC_RESP_TIMEOUT_ERR,
 405         IBV_WC_GENERAL_ERR
 406 };
 407 const char *ibv_wc_status_str(enum ibv_wc_status status);
 408
 409 enum ibv_wc_opcode {
 410         IBV_WC_SEND,
 411         IBV_WC_RDMA_WRITE,
 412         IBV_WC_RDMA_READ,
 413         IBV_WC_COMP_SWAP,
 414         IBV_WC_FETCH_ADD,
 415         IBV_WC_BIND_MW,
 416         IBV_WC_LOCAL_INV,
 417         IBV_WC_TSO,
 418 /*
 419  * Set value of IBV_WC_RECV so consumers can test if a completion is a
 420  * receive by testing (opcode & IBV_WC_RECV).
 421  */
 422         IBV_WC_RECV                     = 1 << 7,
 423         IBV_WC_RECV_RDMA_WITH_IMM
 424 };
 425
 426 enum {
 427         IBV_WC_IP_CSUM_OK_SHIFT = 2
 428 };
 429
 430 enum ibv_create_cq_wc_flags {
 431         IBV_WC_EX_WITH_BYTE_LEN         = 1 << 0,
 432         IBV_WC_EX_WITH_IMM              = 1 << 1,
 433         IBV_WC_EX_WITH_QP_NUM           = 1 << 2,
 434         IBV_WC_EX_WITH_SRC_QP           = 1 << 3,
 435         IBV_WC_EX_WITH_SLID             = 1 << 4,
 436         IBV_WC_EX_WITH_SL               = 1 << 5,
 437         IBV_WC_EX_WITH_DLID_PATH_BITS   = 1 << 6,
 438         IBV_WC_EX_WITH_COMPLETION_TIMESTAMP     = 1 << 7,
 439         IBV_WC_EX_WITH_CVLAN            = 1 << 8,
 440         IBV_WC_EX_WITH_FLOW_TAG         = 1 << 9,
 441 };
 442
 443 enum {
 444         IBV_WC_STANDARD_FLAGS = IBV_WC_EX_WITH_BYTE_LEN         |
 445                                  IBV_WC_EX_WITH_IMM             |
 446                                  IBV_WC_EX_WITH_QP_NUM          |
 447                                  IBV_WC_EX_WITH_SRC_QP          |
 448                                  IBV_WC_EX_WITH_SLID            |
 449                                  IBV_WC_EX_WITH_SL              |
 450                                  IBV_WC_EX_WITH_DLID_PATH_BITS
 451 };
 452
 453 enum {
 454         IBV_CREATE_CQ_SUP_WC_FLAGS = IBV_WC_STANDARD_FLAGS |
 455                                 IBV_WC_EX_WITH_COMPLETION_TIMESTAMP |
 456                                 IBV_WC_EX_WITH_CVLAN |
 457                                 IBV_WC_EX_WITH_FLOW_TAG
 458 };
 459
 460 enum ibv_wc_flags {
 461         IBV_WC_GRH              = 1 << 0,
 462         IBV_WC_WITH_IMM         = 1 << 1,
 463         IBV_WC_IP_CSUM_OK       = 1 << IBV_WC_IP_CSUM_OK_SHIFT,
 464         IBV_WC_WITH_INV         = 1 << 3
 465 };
 466
 467 struct ibv_wc {
 468         uint64_t                wr_id;
 469         enum ibv_wc_status      status;
 470         enum ibv_wc_opcode      opcode;
 471         uint32_t                vendor_err;
 472         uint32_t                byte_len;
 473         /* When (wc_flags & IBV_WC_WITH_IMM): Immediate data in network byte order.
 474          * When (wc_flags & IBV_WC_WITH_INV): Stores the invalidated rkey.
 475          */
 476         union {
 477                 __be32          imm_data;
 478                 uint32_t        invalidated_rkey;
 479         };
 480         uint32_t                qp_num;
 481         uint32_t                src_qp;
 482         int                     wc_flags;
 483         uint16_t                pkey_index;
 484         uint16_t                slid;
 485         uint8_t                 sl;
 486         uint8_t                 dlid_path_bits;
 487 };
 488
 489 enum ibv_access_flags {
 490         IBV_ACCESS_LOCAL_WRITE          = 1,
 491         IBV_ACCESS_REMOTE_WRITE         = (1<<1),
 492         IBV_ACCESS_REMOTE_READ          = (1<<2),
 493         IBV_ACCESS_REMOTE_ATOMIC        = (1<<3),
 494         IBV_ACCESS_MW_BIND              = (1<<4),
 495         IBV_ACCESS_ZERO_BASED           = (1<<5),
 496         IBV_ACCESS_ON_DEMAND            = (1<<6),
 497 };
 498
 499 struct ibv_mw_bind_info {
 500         struct ibv_mr   *mr;
 501         uint64_t         addr;
 502         uint64_t         length;
 503         int              mw_access_flags; /* use ibv_access_flags */
 504 };
 505
 506 struct ibv_pd {
 507         struct ibv_context     *context;
 508         uint32_t                handle;
 509 };
 510
 511 enum ibv_xrcd_init_attr_mask {
 512         IBV_XRCD_INIT_ATTR_FD       = 1 << 0,
 513         IBV_XRCD_INIT_ATTR_OFLAGS   = 1 << 1,
 514         IBV_XRCD_INIT_ATTR_RESERVED = 1 << 2
 515 };
 516
 517 struct ibv_xrcd_init_attr {
 518         uint32_t comp_mask;
 519         int      fd;
 520         int      oflags;
 521 };
 522
 523 struct ibv_xrcd {
 524         struct ibv_context     *context;
 525 };
 526
 527 enum ibv_rereg_mr_flags {
 528         IBV_REREG_MR_CHANGE_TRANSLATION = (1 << 0),
 529         IBV_REREG_MR_CHANGE_PD          = (1 << 1),
 530         IBV_REREG_MR_CHANGE_ACCESS      = (1 << 2),
 531         IBV_REREG_MR_KEEP_VALID         = (1 << 3),
 532         IBV_REREG_MR_FLAGS_SUPPORTED    = ((IBV_REREG_MR_KEEP_VALID << 1) - 1)
 533 };
 534
 535 struct ibv_mr {
 536         struct ibv_context     *context;
 537         struct ibv_pd          *pd;
 538         void                   *addr;
 539         size_t                  length;
 540         uint32_t                handle;
 541         uint32_t                lkey;
 542         uint32_t                rkey;
 543 };
 544
 545 enum ibv_mw_type {
 546         IBV_MW_TYPE_1                   = 1,
 547         IBV_MW_TYPE_2                   = 2
 548 };
 549
 550 struct ibv_mw {
 551         struct ibv_context     *context;
 552         struct ibv_pd          *pd;
 553         uint32_t                rkey;
 554         uint32_t                handle;
 555         enum ibv_mw_type        type;
 556 };
 557
 558 struct ibv_global_route {
 559         union ibv_gid           dgid;
 560         uint32_t                flow_label;
 561         uint8_t                 sgid_index;
 562         uint8_t                 hop_limit;
 563         uint8_t                 traffic_class;
 564 };
 565
 566 struct ibv_grh {
 567         __be32                  version_tclass_flow;
 568         __be16                  paylen;
 569         uint8_t                 next_hdr;
 570         uint8_t                 hop_limit;
 571         union ibv_gid           sgid;
 572         union ibv_gid           dgid;
 573 };
 574
 575 enum ibv_rate {
 576         IBV_RATE_MAX      = 0,
 577         IBV_RATE_2_5_GBPS = 2,
 578         IBV_RATE_5_GBPS   = 5,
 579         IBV_RATE_10_GBPS  = 3,
 580         IBV_RATE_20_GBPS  = 6,
 581         IBV_RATE_30_GBPS  = 4,
 582         IBV_RATE_40_GBPS  = 7,
 583         IBV_RATE_60_GBPS  = 8,
 584         IBV_RATE_80_GBPS  = 9,
 585         IBV_RATE_120_GBPS = 10,
 586         IBV_RATE_14_GBPS  = 11,
 587         IBV_RATE_56_GBPS  = 12,
 588         IBV_RATE_112_GBPS = 13,
 589         IBV_RATE_168_GBPS = 14,
 590         IBV_RATE_25_GBPS  = 15,
 591         IBV_RATE_100_GBPS = 16,
 592         IBV_RATE_200_GBPS = 17,
 593         IBV_RATE_300_GBPS = 18
 594 };
 595
 596 /**
 597  * ibv_rate_to_mult - Convert the IB rate enum to a multiple of the
 598  * base rate of 2.5 Gbit/sec.  For example, IBV_RATE_5_GBPS will be
 599  * converted to 2, since 5 Gbit/sec is 2 * 2.5 Gbit/sec.
 600  * @rate: rate to convert.
 601  */
 602 int  __attribute_const ibv_rate_to_mult(enum ibv_rate rate);
 603
 604 /**
 605  * mult_to_ibv_rate - Convert a multiple of 2.5 Gbit/sec to an IB rate enum.
 606  * @mult: multiple to convert.
 607  */
 608 enum ibv_rate __attribute_const mult_to_ibv_rate(int mult);
 609
 610 /**
 611  * ibv_rate_to_mbps - Convert the IB rate enum to Mbit/sec.
 612  * For example, IBV_RATE_5_GBPS will return the value 5000.
 613  * @rate: rate to convert.
 614  */
 615 int __attribute_const ibv_rate_to_mbps(enum ibv_rate rate);
 616
 617 /**
 618  * mbps_to_ibv_rate - Convert a Mbit/sec value to an IB rate enum.
 619  * @mbps: value to convert.
 620  */
 621 enum ibv_rate __attribute_const mbps_to_ibv_rate(int mbps) __attribute_const;
 622
 623 struct ibv_ah_attr {
 624         struct ibv_global_route grh;
 625         uint16_t                dlid;
 626         uint8_t                 sl;
 627         uint8_t                 src_path_bits;
 628         uint8_t                 static_rate;
 629         uint8_t                 is_global;
 630         uint8_t                 port_num;
 631 };
 632
 633 enum ibv_srq_attr_mask {
 634         IBV_SRQ_MAX_WR  = 1 << 0,
 635         IBV_SRQ_LIMIT   = 1 << 1
 636 };
 637
 638 struct ibv_srq_attr {
 639         uint32_t                max_wr;
 640         uint32_t                max_sge;
 641         uint32_t                srq_limit;
 642 };
 643
 644 struct ibv_srq_init_attr {
 645         void                   *srq_context;
 646         struct ibv_srq_attr     attr;
 647 };
 648
 649 enum ibv_srq_type {
 650         IBV_SRQT_BASIC,
 651         IBV_SRQT_XRC
 652 };
 653
 654 enum ibv_srq_init_attr_mask {
 655         IBV_SRQ_INIT_ATTR_TYPE          = 1 << 0,
 656         IBV_SRQ_INIT_ATTR_PD            = 1 << 1,
 657         IBV_SRQ_INIT_ATTR_XRCD          = 1 << 2,
 658         IBV_SRQ_INIT_ATTR_CQ            = 1 << 3,
 659         IBV_SRQ_INIT_ATTR_RESERVED      = 1 << 4
 660 };
 661
 662 struct ibv_srq_init_attr_ex {
 663         void                   *srq_context;
 664         struct ibv_srq_attr     attr;
 665
 666         uint32_t                comp_mask;
 667         enum ibv_srq_type       srq_type;
 668         struct ibv_pd          *pd;
 669         struct ibv_xrcd        *xrcd;
 670         struct ibv_cq          *cq;
 671 };
 672
 673 enum ibv_wq_type {
 674         IBV_WQT_RQ
 675 };
 676
 677 enum ibv_wq_init_attr_mask {
 678         IBV_WQ_INIT_ATTR_FLAGS          = 1 << 0,
 679         IBV_WQ_INIT_ATTR_RESERVED       = 1 << 1,
 680 };
 681
 682 enum ibv_wq_flags {
 683         IBV_WQ_FLAGS_CVLAN_STRIPPING            = 1 << 0,
 684         IBV_WQ_FLAGS_SCATTER_FCS                = 1 << 1,
 685         IBV_WQ_FLAGS_RESERVED                   = 1 << 2,
 686 };
 687
 688 struct ibv_wq_init_attr {
 689         void                   *wq_context;
 690         enum ibv_wq_type        wq_type;
 691         uint32_t                max_wr;
 692         uint32_t                max_sge;
 693         struct  ibv_pd         *pd;
 694         struct  ibv_cq         *cq;
 695         uint32_t                comp_mask; /* Use ibv_wq_init_attr_mask */
 696         uint32_t                create_flags; /* use ibv_wq_flags */
 697 };
 698
 699 enum ibv_wq_state {
 700         IBV_WQS_RESET,
 701         IBV_WQS_RDY,
 702         IBV_WQS_ERR,
 703         IBV_WQS_UNKNOWN
 704 };
 705
 706 enum ibv_wq_attr_mask {
 707         IBV_WQ_ATTR_STATE       = 1 << 0,
 708         IBV_WQ_ATTR_CURR_STATE  = 1 << 1,
 709         IBV_WQ_ATTR_FLAGS       = 1 << 2,
 710         IBV_WQ_ATTR_RESERVED    = 1 << 3,
 711 };
 712
 713 struct ibv_wq_attr {
 714         /* enum ibv_wq_attr_mask */
 715         uint32_t                attr_mask;
 716         /* Move the WQ to this state */
 717         enum    ibv_wq_state    wq_state;
 718         /* Assume this is the current WQ state */
 719         enum    ibv_wq_state    curr_wq_state;
 720         uint32_t                flags; /* Use ibv_wq_flags */
 721         uint32_t                flags_mask; /* Use ibv_wq_flags */
 722 };
 723
 724 /*
 725  * Receive Work Queue Indirection Table.
 726  * It's used in order to distribute incoming packets between different
 727  * Receive Work Queues. Associating Receive WQs with different CPU cores
 728  * allows to workload the traffic between different CPU cores.
 729  * The Indirection Table can contain only WQs of type IBV_WQT_RQ.
 730 */
 731 struct ibv_rwq_ind_table {
 732         struct ibv_context *context;
 733         int ind_tbl_handle;
 734         int ind_tbl_num;
 735         uint32_t comp_mask;
 736 };
 737
 738 enum ibv_ind_table_init_attr_mask {
 739         IBV_CREATE_IND_TABLE_RESERVED = (1 << 0)
 740 };
 741
 742 /*
 743  * Receive Work Queue Indirection Table attributes
 744  */
 745 struct ibv_rwq_ind_table_init_attr {
 746         uint32_t log_ind_tbl_size;
 747         /* Each entry is a pointer to a Receive Work Queue */
 748         struct ibv_wq **ind_tbl;
 749         uint32_t comp_mask;
 750 };
 751
 752 enum ibv_qp_type {
 753         IBV_QPT_RC = 2,
 754         IBV_QPT_UC,
 755         IBV_QPT_UD,
 756         IBV_QPT_RAW_PACKET = 8,
 757         IBV_QPT_XRC_SEND = 9,
 758         IBV_QPT_XRC_RECV
 759 };
 760
 761 struct ibv_qp_cap {
 762         uint32_t                max_send_wr;
 763         uint32_t                max_recv_wr;
 764         uint32_t                max_send_sge;
 765         uint32_t                max_recv_sge;
 766         uint32_t                max_inline_data;
 767 };
 768
 769 struct ibv_qp_init_attr {
 770         void                   *qp_context;
 771         struct ibv_cq          *send_cq;
 772         struct ibv_cq          *recv_cq;
 773         struct ibv_srq         *srq;
 774         struct ibv_qp_cap       cap;
 775         enum ibv_qp_type        qp_type;
 776         int                     sq_sig_all;
 777 };
 778
 779 enum ibv_qp_init_attr_mask {
 780         IBV_QP_INIT_ATTR_PD             = 1 << 0,
 781         IBV_QP_INIT_ATTR_XRCD           = 1 << 1,
 782         IBV_QP_INIT_ATTR_CREATE_FLAGS   = 1 << 2,
 783         IBV_QP_INIT_ATTR_MAX_TSO_HEADER = 1 << 3,
 784         IBV_QP_INIT_ATTR_IND_TABLE      = 1 << 4,
 785         IBV_QP_INIT_ATTR_RX_HASH        = 1 << 5,
 786         IBV_QP_INIT_ATTR_RESERVED       = 1 << 6
 787 };
 788
 789 enum ibv_qp_create_flags {
 790         IBV_QP_CREATE_BLOCK_SELF_MCAST_LB       = 1 << 1,
 791         IBV_QP_CREATE_SCATTER_FCS               = 1 << 8,
 792         IBV_QP_CREATE_CVLAN_STRIPPING           = 1 << 9,
 793 };
 794
 795 struct ibv_rx_hash_conf {
 796         /* enum ibv_rx_hash_function_flags */
 797         uint8_t rx_hash_function;
 798         uint8_t rx_hash_key_len;
 799         uint8_t *rx_hash_key;
 800         /* enum ibv_rx_hash_fields */
 801         uint64_t        rx_hash_fields_mask;
 802 };
 803
 804 struct ibv_qp_init_attr_ex {
 805         void                   *qp_context;
 806         struct ibv_cq          *send_cq;
 807         struct ibv_cq          *recv_cq;
 808         struct ibv_srq         *srq;
 809         struct ibv_qp_cap       cap;
 810         enum ibv_qp_type        qp_type;
 811         int                     sq_sig_all;
 812
 813         uint32_t                comp_mask;
 814         struct ibv_pd          *pd;
 815         struct ibv_xrcd        *xrcd;
 816         uint32_t                create_flags;
 817         uint16_t                max_tso_header;
 818         struct ibv_rwq_ind_table       *rwq_ind_tbl;
 819         struct ibv_rx_hash_conf rx_hash_conf;
 820 };
 821
 822 enum ibv_qp_open_attr_mask {
 823         IBV_QP_OPEN_ATTR_NUM            = 1 << 0,
 824         IBV_QP_OPEN_ATTR_XRCD           = 1 << 1,
 825         IBV_QP_OPEN_ATTR_CONTEXT        = 1 << 2,
 826         IBV_QP_OPEN_ATTR_TYPE           = 1 << 3,
 827         IBV_QP_OPEN_ATTR_RESERVED       = 1 << 4
 828 };
 829
 830 struct ibv_qp_open_attr {
 831         uint32_t                comp_mask;
 832         uint32_t                qp_num;
 833         struct ibv_xrcd        *xrcd;
 834         void                   *qp_context;
 835         enum ibv_qp_type        qp_type;
 836 };
 837
 838 enum ibv_qp_attr_mask {
 839         IBV_QP_STATE                    = 1 <<  0,
 840         IBV_QP_CUR_STATE                = 1 <<  1,
 841         IBV_QP_EN_SQD_ASYNC_NOTIFY      = 1 <<  2,
 842         IBV_QP_ACCESS_FLAGS             = 1 <<  3,
 843         IBV_QP_PKEY_INDEX               = 1 <<  4,
 844         IBV_QP_PORT                     = 1 <<  5,
 845         IBV_QP_QKEY                     = 1 <<  6,
 846         IBV_QP_AV                       = 1 <<  7,
 847         IBV_QP_PATH_MTU                 = 1 <<  8,
 848         IBV_QP_TIMEOUT                  = 1 <<  9,
 849         IBV_QP_RETRY_CNT                = 1 << 10,
 850         IBV_QP_RNR_RETRY                = 1 << 11,
 851         IBV_QP_RQ_PSN                   = 1 << 12,
 852         IBV_QP_MAX_QP_RD_ATOMIC         = 1 << 13,
 853         IBV_QP_ALT_PATH                 = 1 << 14,
 854         IBV_QP_MIN_RNR_TIMER            = 1 << 15,
 855         IBV_QP_SQ_PSN                   = 1 << 16,
 856         IBV_QP_MAX_DEST_RD_ATOMIC       = 1 << 17,
 857         IBV_QP_PATH_MIG_STATE           = 1 << 18,
 858         IBV_QP_CAP                      = 1 << 19,
 859         IBV_QP_DEST_QPN                 = 1 << 20,
 860         IBV_QP_RATE_LIMIT               = 1 << 25,
 861 };
 862
 863 enum ibv_qp_state {
 864         IBV_QPS_RESET,
 865         IBV_QPS_INIT,
 866         IBV_QPS_RTR,
 867         IBV_QPS_RTS,
 868         IBV_QPS_SQD,
 869         IBV_QPS_SQE,
 870         IBV_QPS_ERR,
 871         IBV_QPS_UNKNOWN
 872 };
 873
 874 enum ibv_mig_state {
 875         IBV_MIG_MIGRATED,
 876         IBV_MIG_REARM,
 877         IBV_MIG_ARMED
 878 };
 879
 880 struct ibv_qp_attr {
 881         enum ibv_qp_state       qp_state;
 882         enum ibv_qp_state       cur_qp_state;
 883         enum ibv_mtu            path_mtu;
 884         enum ibv_mig_state      path_mig_state;
 885         uint32_t                qkey;
 886         uint32_t                rq_psn;
 887         uint32_t                sq_psn;
 888         uint32_t                dest_qp_num;
 889         int                     qp_access_flags;
 890         struct ibv_qp_cap       cap;
 891         struct ibv_ah_attr      ah_attr;
 892         struct ibv_ah_attr      alt_ah_attr;
 893         uint16_t                pkey_index;
 894         uint16_t                alt_pkey_index;
 895         uint8_t                 en_sqd_async_notify;
 896         uint8_t                 sq_draining;
 897         uint8_t                 max_rd_atomic;
 898         uint8_t                 max_dest_rd_atomic;
 899         uint8_t                 min_rnr_timer;
 900         uint8_t                 port_num;
 901         uint8_t                 timeout;
 902         uint8_t                 retry_cnt;
 903         uint8_t                 rnr_retry;
 904         uint8_t                 alt_port_num;
 905         uint8_t                 alt_timeout;
 906         uint32_t                rate_limit;
 907 };
 908
 909 enum ibv_wr_opcode {
 910         IBV_WR_RDMA_WRITE,
 911         IBV_WR_RDMA_WRITE_WITH_IMM,
 912         IBV_WR_SEND,
 913         IBV_WR_SEND_WITH_IMM,
 914         IBV_WR_RDMA_READ,
 915         IBV_WR_ATOMIC_CMP_AND_SWP,
 916         IBV_WR_ATOMIC_FETCH_AND_ADD,
 917         IBV_WR_LOCAL_INV,
 918         IBV_WR_BIND_MW,
 919         IBV_WR_SEND_WITH_INV,
 920         IBV_WR_TSO,
 921 };
 922
 923 enum ibv_send_flags {
 924         IBV_SEND_FENCE          = 1 << 0,
 925         IBV_SEND_SIGNALED       = 1 << 1,
 926         IBV_SEND_SOLICITED      = 1 << 2,
 927         IBV_SEND_INLINE         = 1 << 3,
 928         IBV_SEND_IP_CSUM        = 1 << 4
 929 };
 930
 931 struct ibv_sge {
 932         uint64_t                addr;
 933         uint32_t                length;
 934         uint32_t                lkey;
 935 };
 936
 937 struct ibv_send_wr {
 938         uint64_t                wr_id;
 939         struct ibv_send_wr     *next;
 940         struct ibv_sge         *sg_list;
 941         int                     num_sge;
 942         enum ibv_wr_opcode      opcode;
 943         int                     send_flags;
 944         __be32                  imm_data;
 945         union {
 946                 struct {
 947                         uint64_t        remote_addr;
 948                         uint32_t        rkey;
 949                 } rdma;
 950                 struct {
 951                         uint64_t        remote_addr;
 952                         uint64_t        compare_add;
 953                         uint64_t        swap;
 954                         uint32_t        rkey;
 955                 } atomic;
 956                 struct {
 957                         struct ibv_ah  *ah;
 958                         uint32_t        remote_qpn;
 959                         uint32_t        remote_qkey;
 960                 } ud;
 961         } wr;
 962         union {
 963                 struct {
 964                         uint32_t    remote_srqn;
 965                 } xrc;
 966         } qp_type;
 967         union {
 968                 struct {
 969                         struct ibv_mw   *mw;
 970                         uint32_t                rkey;
 971                         struct ibv_mw_bind_info bind_info;
 972                 } bind_mw;
 973                 struct {
 974                         void                   *hdr;
 975                         uint16_t                hdr_sz;
 976                         uint16_t                mss;
 977                 } tso;
 978         };
 979 };
 980
 981 struct ibv_recv_wr {
 982         uint64_t                wr_id;
 983         struct ibv_recv_wr     *next;
 984         struct ibv_sge         *sg_list;
 985         int                     num_sge;
 986 };
 987
 988 struct ibv_mw_bind {
 989         uint64_t                wr_id;
 990         int                     send_flags;
 991         struct ibv_mw_bind_info bind_info;
 992 };
 993
 994 struct ibv_srq {
 995         struct ibv_context     *context;
 996         void                   *srq_context;
 997         struct ibv_pd          *pd;
 998         uint32_t                handle;
 999
1000         pthread_mutex_t         mutex;
1001         pthread_cond_t          cond;
1002         uint32_t                events_completed;
1003 };
1004
1005 /*
1006  * Work Queue. QP can be created without internal WQs "packaged" inside it,
1007  * this QP can be configured to use "external" WQ object as its
1008  * receive/send queue.
1009  * WQ associated (many to one) with Completion Queue it owns WQ properties
1010  * (PD, WQ size etc).
1011  * WQ of type IBV_WQT_RQ:
1012  * - Contains receive WQEs, in this case its PD serves as scatter as well.
1013  * - Exposes post receive function to be used to post a list of work
1014  *   requests (WRs) to its receive queue.
1015  */
1016 struct ibv_wq {
1017         struct ibv_context     *context;
1018         void                   *wq_context;
1019         struct  ibv_pd         *pd;
1020         struct  ibv_cq         *cq;
1021         uint32_t                wq_num;
1022         uint32_t                handle;
1023         enum ibv_wq_state       state;
1024         enum ibv_wq_type        wq_type;
1025         int (*post_recv)(struct ibv_wq *current,
1026                          struct ibv_recv_wr *recv_wr,
1027                          struct ibv_recv_wr **bad_recv_wr);
1028         pthread_mutex_t         mutex;
1029         pthread_cond_t          cond;
1030         uint32_t                events_completed;
1031         uint32_t                comp_mask;
1032 };
1033
1034 struct ibv_qp {
1035         struct ibv_context     *context;
1036         void                   *qp_context;
1037         struct ibv_pd          *pd;
1038         struct ibv_cq          *send_cq;
1039         struct ibv_cq          *recv_cq;
1040         struct ibv_srq         *srq;
1041         uint32_t                handle;
1042         uint32_t                qp_num;
1043         enum ibv_qp_state       state;
1044         enum ibv_qp_type        qp_type;
1045
1046         pthread_mutex_t         mutex;
1047         pthread_cond_t          cond;
1048         uint32_t                events_completed;
1049 };
1050
1051 struct ibv_comp_channel {
1052         struct ibv_context     *context;
1053         int                     fd;
1054         int                     refcnt;
1055 };
1056
1057 struct ibv_cq {
1058         struct ibv_context     *context;
1059         struct ibv_comp_channel *channel;
1060         void                   *cq_context;
1061         uint32_t                handle;
1062         int                     cqe;
1063
1064         pthread_mutex_t         mutex;
1065         pthread_cond_t          cond;
1066         uint32_t                comp_events_completed;
1067         uint32_t                async_events_completed;
1068 };
1069
1070 struct ibv_poll_cq_attr {
1071         uint32_t comp_mask;
1072 };
1073
1074 struct ibv_cq_ex {
1075         struct ibv_context     *context;
1076         struct ibv_comp_channel *channel;
1077         void                   *cq_context;
1078         uint32_t                handle;
1079         int                     cqe;
1080
1081         pthread_mutex_t         mutex;
1082         pthread_cond_t          cond;
1083         uint32_t                comp_events_completed;
1084         uint32_t                async_events_completed;
1085
1086         uint32_t                comp_mask;
1087         enum ibv_wc_status status;
1088         uint64_t wr_id;
1089         int (*start_poll)(struct ibv_cq_ex *current,
1090                              struct ibv_poll_cq_attr *attr);
1091         int (*next_poll)(struct ibv_cq_ex *current);
1092         void (*end_poll)(struct ibv_cq_ex *current);
1093         enum ibv_wc_opcode (*read_opcode)(struct ibv_cq_ex *current);
1094         uint32_t (*read_vendor_err)(struct ibv_cq_ex *current);
1095         uint32_t (*read_byte_len)(struct ibv_cq_ex *current);
1096         uint32_t (*read_imm_data)(struct ibv_cq_ex *current);
1097         uint32_t (*read_qp_num)(struct ibv_cq_ex *current);
1098         uint32_t (*read_src_qp)(struct ibv_cq_ex *current);
1099         int (*read_wc_flags)(struct ibv_cq_ex *current);
1100         uint32_t (*read_slid)(struct ibv_cq_ex *current);
1101         uint8_t (*read_sl)(struct ibv_cq_ex *current);
1102         uint8_t (*read_dlid_path_bits)(struct ibv_cq_ex *current);
1103         uint64_t (*read_completion_ts)(struct ibv_cq_ex *current);
1104         uint16_t (*read_cvlan)(struct ibv_cq_ex *current);
1105         uint32_t (*read_flow_tag)(struct ibv_cq_ex *current);
1106 };
1107
1108 static inline struct ibv_cq *ibv_cq_ex_to_cq(struct ibv_cq_ex *cq)
1109 {
1110         return (struct ibv_cq *)cq;
1111 }
1112
1113 static inline int ibv_start_poll(struct ibv_cq_ex *cq,
1114                                     struct ibv_poll_cq_attr *attr)
1115 {
1116         return cq->start_poll(cq, attr);
1117 }
1118
1119 static inline int ibv_next_poll(struct ibv_cq_ex *cq)
1120 {
1121         return cq->next_poll(cq);
1122 }
1123
1124 static inline void ibv_end_poll(struct ibv_cq_ex *cq)
1125 {
1126         cq->end_poll(cq);
1127 }
1128
1129 static inline enum ibv_wc_opcode ibv_wc_read_opcode(struct ibv_cq_ex *cq)
1130 {
1131         return cq->read_opcode(cq);
1132 }
1133
1134 static inline uint32_t ibv_wc_read_vendor_err(struct ibv_cq_ex *cq)
1135 {
1136         return cq->read_vendor_err(cq);
1137 }
1138
1139 static inline uint32_t ibv_wc_read_byte_len(struct ibv_cq_ex *cq)
1140 {
1141         return cq->read_byte_len(cq);
1142 }
1143
1144 static inline uint32_t ibv_wc_read_imm_data(struct ibv_cq_ex *cq)
1145 {
1146         return cq->read_imm_data(cq);
1147 }
1148
1149 static inline uint32_t ibv_wc_read_qp_num(struct ibv_cq_ex *cq)
1150 {
1151         return cq->read_qp_num(cq);
1152 }
1153
1154 static inline uint32_t ibv_wc_read_src_qp(struct ibv_cq_ex *cq)
1155 {
1156         return cq->read_src_qp(cq);
1157 }
1158
1159 static inline int ibv_wc_read_wc_flags(struct ibv_cq_ex *cq)
1160 {
1161         return cq->read_wc_flags(cq);
1162 }
1163
1164 static inline uint32_t ibv_wc_read_slid(struct ibv_cq_ex *cq)
1165 {
1166         return cq->read_slid(cq);
1167 }
1168
1169 static inline uint8_t ibv_wc_read_sl(struct ibv_cq_ex *cq)
1170 {
1171         return cq->read_sl(cq);
1172 }
1173
1174 static inline uint8_t ibv_wc_read_dlid_path_bits(struct ibv_cq_ex *cq)
1175 {
1176         return cq->read_dlid_path_bits(cq);
1177 }
1178
1179 static inline uint64_t ibv_wc_read_completion_ts(struct ibv_cq_ex *cq)
1180 {
1181         return cq->read_completion_ts(cq);
1182 }
1183
1184 static inline uint16_t ibv_wc_read_cvlan(struct ibv_cq_ex *cq)
1185 {
1186         return cq->read_cvlan(cq);
1187 }
1188
1189 static inline uint32_t ibv_wc_read_flow_tag(struct ibv_cq_ex *cq)
1190 {
1191         return cq->read_flow_tag(cq);
1192 }
1193
1194 static inline int ibv_post_wq_recv(struct ibv_wq *wq,
1195                                    struct ibv_recv_wr *recv_wr,
1196                                    struct ibv_recv_wr **bad_recv_wr)
1197 {
1198         return wq->post_recv(wq, recv_wr, bad_recv_wr);
1199 }
1200
1201 struct ibv_ah {
1202         struct ibv_context     *context;
1203         struct ibv_pd          *pd;
1204         uint32_t                handle;
1205 };
1206
1207 enum ibv_flow_flags {
1208         IBV_FLOW_ATTR_FLAGS_ALLOW_LOOP_BACK = 1 << 0,
1209         IBV_FLOW_ATTR_FLAGS_DONT_TRAP = 1 << 1,
1210 };
1211
1212 enum ibv_flow_attr_type {
1213         /* steering according to rule specifications */
1214         IBV_FLOW_ATTR_NORMAL            = 0x0,
1215         /* default unicast and multicast rule -
1216          * receive all Eth traffic which isn't steered to any QP
1217          */
1218         IBV_FLOW_ATTR_ALL_DEFAULT       = 0x1,
1219         /* default multicast rule -
1220          * receive all Eth multicast traffic which isn't steered to any QP
1221          */
1222         IBV_FLOW_ATTR_MC_DEFAULT        = 0x2,
1223         /* sniffer rule - receive all port traffic */
1224         IBV_FLOW_ATTR_SNIFFER           = 0x3,
1225 };
1226
1227 enum ibv_flow_spec_type {
1228         IBV_FLOW_SPEC_ETH               = 0x20,
1229         IBV_FLOW_SPEC_IPV4              = 0x30,
1230         IBV_FLOW_SPEC_IPV6              = 0x31,
1231         IBV_FLOW_SPEC_IPV4_EXT          = 0x32,
1232         IBV_FLOW_SPEC_TCP               = 0x40,
1233         IBV_FLOW_SPEC_UDP               = 0x41,
1234         IBV_FLOW_SPEC_VXLAN_TUNNEL      = 0x50,
1235         IBV_FLOW_SPEC_INNER             = 0x100,
1236         IBV_FLOW_SPEC_ACTION_TAG        = 0x1000,
1237         IBV_FLOW_SPEC_ACTION_DROP       = 0x1001,
1238 };
1239
1240 struct ibv_flow_eth_filter {
1241         uint8_t         dst_mac[6];
1242         uint8_t         src_mac[6];
1243         uint16_t        ether_type;
1244         /*
1245          * same layout as 802.1q: prio 3, cfi 1, vlan id 12
1246          */
1247         uint16_t        vlan_tag;
1248 };
1249
1250 struct ibv_flow_spec_eth {
1251         enum ibv_flow_spec_type  type;
1252         uint16_t  size;
1253         struct ibv_flow_eth_filter val;
1254         struct ibv_flow_eth_filter mask;
1255 };
1256
1257 struct ibv_flow_ipv4_filter {
1258         uint32_t src_ip;
1259         uint32_t dst_ip;
1260 };
1261
1262 struct ibv_flow_spec_ipv4 {
1263         enum ibv_flow_spec_type  type;
1264         uint16_t  size;
1265         struct ibv_flow_ipv4_filter val;
1266         struct ibv_flow_ipv4_filter mask;
1267 };
1268
1269 struct ibv_flow_ipv4_ext_filter {
1270         uint32_t src_ip;
1271         uint32_t dst_ip;
1272         uint8_t  proto;
1273         uint8_t  tos;
1274         uint8_t  ttl;
1275         uint8_t  flags;
1276 };
1277
1278 struct ibv_flow_spec_ipv4_ext {
1279         enum ibv_flow_spec_type  type;
1280         uint16_t  size;
1281         struct ibv_flow_ipv4_ext_filter val;
1282         struct ibv_flow_ipv4_ext_filter mask;
1283 };
1284
1285 struct ibv_flow_ipv6_filter {
1286         uint8_t  src_ip[16];
1287         uint8_t  dst_ip[16];
1288         uint32_t flow_label;
1289         uint8_t  next_hdr;
1290         uint8_t  traffic_class;
1291         uint8_t  hop_limit;
1292 };
1293
1294 struct ibv_flow_spec_ipv6 {
1295         enum ibv_flow_spec_type  type;
1296         uint16_t  size;
1297         struct ibv_flow_ipv6_filter val;
1298         struct ibv_flow_ipv6_filter mask;
1299 };
1300
1301 struct ibv_flow_tcp_udp_filter {
1302         uint16_t dst_port;
1303         uint16_t src_port;
1304 };
1305
1306 struct ibv_flow_spec_tcp_udp {
1307         enum ibv_flow_spec_type  type;
1308         uint16_t  size;
1309         struct ibv_flow_tcp_udp_filter val;
1310         struct ibv_flow_tcp_udp_filter mask;
1311 };
1312
1313 struct ibv_flow_tunnel_filter {
1314         uint32_t tunnel_id;
1315 };
1316
1317 struct ibv_flow_spec_tunnel {
1318         enum ibv_flow_spec_type  type;
1319         uint16_t  size;
1320         struct ibv_flow_tunnel_filter val;
1321         struct ibv_flow_tunnel_filter mask;
1322 };
1323
1324 struct ibv_flow_spec_action_tag {
1325         enum ibv_flow_spec_type  type;
1326         uint16_t  size;
1327         uint32_t  tag_id;
1328 };
1329
1330 struct ibv_flow_spec_action_drop {
1331         enum ibv_flow_spec_type  type;
1332         uint16_t  size;
1333 };
1334
1335 struct ibv_flow_spec {
1336         union {
1337                 struct {
1338                         enum ibv_flow_spec_type type;
1339                         uint16_t                size;
1340                 } hdr;
1341                 struct ibv_flow_spec_eth eth;
1342                 struct ibv_flow_spec_ipv4 ipv4;
1343                 struct ibv_flow_spec_tcp_udp tcp_udp;
1344                 struct ibv_flow_spec_ipv4_ext ipv4_ext;
1345                 struct ibv_flow_spec_ipv6 ipv6;
1346                 struct ibv_flow_spec_tunnel tunnel;
1347                 struct ibv_flow_spec_action_tag flow_tag;
1348                 struct ibv_flow_spec_action_drop drop;
1349         };
1350 };
1351
1352 struct ibv_flow_attr {
1353         uint32_t comp_mask;
1354         enum ibv_flow_attr_type type;
1355         uint16_t size;
1356         uint16_t priority;
1357         uint8_t num_of_specs;
1358         uint8_t port;
1359         uint32_t flags;
1360         /* Following are the optional layers according to user request
1361          * struct ibv_flow_spec_xxx [L2]
1362          * struct ibv_flow_spec_yyy [L3/L4]
1363          */
1364 };
1365
1366 struct ibv_flow {
1367         uint32_t           comp_mask;
1368         struct ibv_context *context;
1369         uint32_t           handle;
1370 };
1371
1372 struct ibv_device;
1373 struct ibv_context;
1374
1375 /* Obsolete, never used, do not touch */
1376 struct _ibv_device_ops {
1377         struct ibv_context *    (*_dummy1)(struct ibv_device *device, int cmd_fd);
1378         void                    (*_dummy2)(struct ibv_context *context);
1379 };
1380
1381 enum {
1382         IBV_SYSFS_NAME_MAX      = 64,
1383         IBV_SYSFS_PATH_MAX      = 256
1384 };
1385
1386 struct ibv_device {
1387         struct _ibv_device_ops  _ops;
1388         enum ibv_node_type      node_type;
1389         enum ibv_transport_type transport_type;
1390         /* Name of underlying kernel IB device, eg "mthca0" */
1391         char                    name[IBV_SYSFS_NAME_MAX];
1392         /* Name of uverbs device, eg "uverbs0" */
1393         char                    dev_name[IBV_SYSFS_NAME_MAX];
1394         /* Path to infiniband_verbs class device in sysfs */
1395         char                    dev_path[IBV_SYSFS_PATH_MAX];
1396         /* Path to infiniband class device in sysfs */
1397         char                    ibdev_path[IBV_SYSFS_PATH_MAX];
1398 };
1399
1400 struct ibv_context_ops {
1401         int                     (*query_device)(struct ibv_context *context,
1402                                               struct ibv_device_attr *device_attr);
1403         int                     (*query_port)(struct ibv_context *context, uint8_t port_num,
1404                                               struct ibv_port_attr *port_attr);
1405         struct ibv_pd *         (*alloc_pd)(struct ibv_context *context);
1406         int                     (*dealloc_pd)(struct ibv_pd *pd);
1407         struct ibv_mr *         (*reg_mr)(struct ibv_pd *pd, void *addr, size_t length,
1408                                           int access);
1409         int                     (*rereg_mr)(struct ibv_mr *mr,
1410                                             int flags,
1411                                             struct ibv_pd *pd, void *addr,
1412                                             size_t length,
1413                                             int access);
1414         int                     (*dereg_mr)(struct ibv_mr *mr);
1415         struct ibv_mw *         (*alloc_mw)(struct ibv_pd *pd, enum ibv_mw_type type);
1416         int                     (*bind_mw)(struct ibv_qp *qp, struct ibv_mw *mw,
1417                                            struct ibv_mw_bind *mw_bind);
1418         int                     (*dealloc_mw)(struct ibv_mw *mw);
1419         struct ibv_cq *         (*create_cq)(struct ibv_context *context, int cqe,
1420                                              struct ibv_comp_channel *channel,
1421                                              int comp_vector);
1422         int                     (*poll_cq)(struct ibv_cq *cq, int num_entries, struct ibv_wc *wc);
1423         int                     (*req_notify_cq)(struct ibv_cq *cq, int solicited_only);
1424         void                    (*cq_event)(struct ibv_cq *cq);
1425         int                     (*resize_cq)(struct ibv_cq *cq, int cqe);
1426         int                     (*destroy_cq)(struct ibv_cq *cq);
1427         struct ibv_srq *        (*create_srq)(struct ibv_pd *pd,
1428                                               struct ibv_srq_init_attr *srq_init_attr);
1429         int                     (*modify_srq)(struct ibv_srq *srq,
1430                                               struct ibv_srq_attr *srq_attr,
1431                                               int srq_attr_mask);
1432         int                     (*query_srq)(struct ibv_srq *srq,
1433                                              struct ibv_srq_attr *srq_attr);
1434         int                     (*destroy_srq)(struct ibv_srq *srq);
1435         int                     (*post_srq_recv)(struct ibv_srq *srq,
1436                                                  struct ibv_recv_wr *recv_wr,
1437                                                  struct ibv_recv_wr **bad_recv_wr);
1438         struct ibv_qp *         (*create_qp)(struct ibv_pd *pd, struct ibv_qp_init_attr *attr);
1439         int                     (*query_qp)(struct ibv_qp *qp, struct ibv_qp_attr *attr,
1440                                             int attr_mask,
1441                                             struct ibv_qp_init_attr *init_attr);
1442         int                     (*modify_qp)(struct ibv_qp *qp, struct ibv_qp_attr *attr,
1443                                              int attr_mask);
1444         int                     (*destroy_qp)(struct ibv_qp *qp);
1445         int                     (*post_send)(struct ibv_qp *qp, struct ibv_send_wr *wr,
1446                                              struct ibv_send_wr **bad_wr);
1447         int                     (*post_recv)(struct ibv_qp *qp, struct ibv_recv_wr *wr,
1448                                              struct ibv_recv_wr **bad_wr);
1449         struct ibv_ah *         (*create_ah)(struct ibv_pd *pd, struct ibv_ah_attr *attr);
1450         int                     (*destroy_ah)(struct ibv_ah *ah);
1451         int                     (*attach_mcast)(struct ibv_qp *qp, const union ibv_gid *gid,
1452                                                 uint16_t lid);
1453         int                     (*detach_mcast)(struct ibv_qp *qp, const union ibv_gid *gid,
1454                                                 uint16_t lid);
1455         void                    (*async_event)(struct ibv_async_event *event);
1456 };
1457
1458 struct ibv_context {
1459         struct ibv_device      *device;
1460         struct ibv_context_ops  ops;
1461         int                     cmd_fd;
1462         int                     async_fd;
1463         int                     num_comp_vectors;
1464         pthread_mutex_t         mutex;
1465         void                   *abi_compat;
1466 };
1467
1468 enum ibv_cq_init_attr_mask {
1469         IBV_CQ_INIT_ATTR_MASK_FLAGS     = 1 << 0,
1470         IBV_CQ_INIT_ATTR_MASK_RESERVED  = 1 << 1
1471 };
1472
1473 enum ibv_create_cq_attr_flags {
1474         IBV_CREATE_CQ_ATTR_SINGLE_THREADED = 1 << 0,
1475         IBV_CREATE_CQ_ATTR_RESERVED = 1 << 1,
1476 };
1477
1478 struct ibv_cq_init_attr_ex {
1479         /* Minimum number of entries required for CQ */
1480         uint32_t                        cqe;
1481         /* Consumer-supplied context returned for completion events */
1482         void                    *cq_context;
1483         /* Completion channel where completion events will be queued.
1484          * May be NULL if completion events will not be used.
1485          */
1486         struct ibv_comp_channel *channel;
1487         /* Completion vector used to signal completion events.
1488          *  Must be < context->num_comp_vectors.
1489          */
1490         uint32_t                        comp_vector;
1491          /* Or'ed bit of enum ibv_create_cq_wc_flags. */
1492         uint64_t                wc_flags;
1493         /* compatibility mask (extended verb). Or'd flags of
1494          * enum ibv_cq_init_attr_mask
1495          */
1496         uint32_t                comp_mask;
1497         /* create cq attr flags - one or more flags from
1498          * enum ibv_create_cq_attr_flags
1499          */
1500         uint32_t                flags;
1501 };
1502
1503 enum ibv_values_mask {
1504         IBV_VALUES_MASK_RAW_CLOCK       = 1 << 0,
1505         IBV_VALUES_MASK_RESERVED        = 1 << 1
1506 };
1507
1508 struct ibv_values_ex {
1509         uint32_t        comp_mask;
1510         struct timespec raw_clock;
1511 };
1512
1513 enum verbs_context_mask {
1514         VERBS_CONTEXT_XRCD      = 1 << 0,
1515         VERBS_CONTEXT_SRQ       = 1 << 1,
1516         VERBS_CONTEXT_QP        = 1 << 2,
1517         VERBS_CONTEXT_CREATE_FLOW = 1 << 3,
1518         VERBS_CONTEXT_DESTROY_FLOW = 1 << 4,
1519         VERBS_CONTEXT_RESERVED  = 1 << 5
1520 };
1521
1522 struct verbs_context {
1523         /*  "grows up" - new fields go here */
1524         int (*destroy_rwq_ind_table)(struct ibv_rwq_ind_table *rwq_ind_table);
1525         struct ibv_rwq_ind_table *(*create_rwq_ind_table)(struct ibv_context *context,
1526                                                           struct ibv_rwq_ind_table_init_attr *init_attr);
1527         int (*destroy_wq)(struct ibv_wq *wq);
1528         int (*modify_wq)(struct ibv_wq *wq, struct ibv_wq_attr *wq_attr);
1529         struct ibv_wq * (*create_wq)(struct ibv_context *context,
1530                                      struct ibv_wq_init_attr *wq_init_attr);
1531         int (*query_rt_values)(struct ibv_context *context,
1532                                struct ibv_values_ex *values);
1533         struct ibv_cq_ex *(*create_cq_ex)(struct ibv_context *context,
1534                                           struct ibv_cq_init_attr_ex *init_attr);
1535         struct verbs_ex_private *priv;
1536         int (*query_device_ex)(struct ibv_context *context,
1537                                const struct ibv_query_device_ex_input *input,
1538                                struct ibv_device_attr_ex *attr,
1539                                size_t attr_size);
1540         int (*ibv_destroy_flow) (struct ibv_flow *flow);
1541         void (*ABI_placeholder2) (void); /* DO NOT COPY THIS GARBAGE */
1542         struct ibv_flow * (*ibv_create_flow) (struct ibv_qp *qp,
1543                                               struct ibv_flow_attr *flow_attr);
1544         void (*ABI_placeholder1) (void); /* DO NOT COPY THIS GARBAGE */
1545         struct ibv_qp *(*open_qp)(struct ibv_context *context,
1546                         struct ibv_qp_open_attr *attr);
1547         struct ibv_qp *(*create_qp_ex)(struct ibv_context *context,
1548                         struct ibv_qp_init_attr_ex *qp_init_attr_ex);
1549         int (*get_srq_num)(struct ibv_srq *srq, uint32_t *srq_num);
1550         struct ibv_srq *        (*create_srq_ex)(struct ibv_context *context,
1551                                                  struct ibv_srq_init_attr_ex *srq_init_attr_ex);
1552         struct ibv_xrcd *       (*open_xrcd)(struct ibv_context *context,
1553                                              struct ibv_xrcd_init_attr *xrcd_init_attr);
1554         int                     (*close_xrcd)(struct ibv_xrcd *xrcd);
1555         uint64_t has_comp_mask;
1556         size_t   sz;                    /* Must be immediately before struct ibv_context */
1557         struct ibv_context context;     /* Must be last field in the struct */
1558 };
1559
1560 static inline struct verbs_context *verbs_get_ctx(struct ibv_context *ctx)
1561 {
1562         return (ctx->abi_compat != __VERBS_ABI_IS_EXTENDED) ?
1563                 NULL : container_of(ctx, struct verbs_context, context);
1564 }
1565
1566 #define verbs_get_ctx_op(ctx, op) ({ \
1567         struct verbs_context *__vctx = verbs_get_ctx(ctx); \
1568         (!__vctx || (__vctx->sz < sizeof(*__vctx) - offsetof(struct verbs_context, op)) || \
1569          !__vctx->op) ? NULL : __vctx; })
1570
1571 #define verbs_set_ctx_op(_vctx, op, ptr) ({ \
1572         struct verbs_context *vctx = _vctx; \
1573         if (vctx && (vctx->sz >= sizeof(*vctx) - offsetof(struct verbs_context, op))) \
1574                 vctx->op = ptr; })
1575
1576 /**
1577  * ibv_get_device_list - Get list of IB devices currently available
1578  * @num_devices: optional.  if non-NULL, set to the number of devices
1579  * returned in the array.
1580  *
1581  * Return a NULL-terminated array of IB devices.  The array can be
1582  * released with ibv_free_device_list().
1583  */
1584 struct ibv_device **ibv_get_device_list(int *num_devices);
1585
1586 /**
1587  * ibv_free_device_list - Free list from ibv_get_device_list()
1588  *
1589  * Free an array of devices returned from ibv_get_device_list().  Once
1590  * the array is freed, pointers to devices that were not opened with
1591  * ibv_open_device() are no longer valid.  Client code must open all
1592  * devices it intends to use before calling ibv_free_device_list().
1593  */
1594 void ibv_free_device_list(struct ibv_device **list);
1595
1596 /**
1597  * ibv_get_device_name - Return kernel device name
1598  */
1599 const char *ibv_get_device_name(struct ibv_device *device);
1600
1601 /**
1602  * ibv_get_device_guid - Return device's node GUID
1603  */
1604 __be64 ibv_get_device_guid(struct ibv_device *device);
1605
1606 /**
1607  * ibv_open_device - Initialize device for use
1608  */
1609 struct ibv_context *ibv_open_device(struct ibv_device *device);
1610
1611 /**
1612  * ibv_close_device - Release device
1613  */
1614 int ibv_close_device(struct ibv_context *context);
1615
1616 /**
1617  * ibv_get_async_event - Get next async event
1618  * @event: Pointer to use to return async event
1619  *
1620  * All async events returned by ibv_get_async_event() must eventually
1621  * be acknowledged with ibv_ack_async_event().
1622  */
1623 int ibv_get_async_event(struct ibv_context *context,
1624                         struct ibv_async_event *event);
1625
1626 /**
1627  * ibv_ack_async_event - Acknowledge an async event
1628  * @event: Event to be acknowledged.
1629  *
1630  * All async events which are returned by ibv_get_async_event() must
1631  * be acknowledged.  To avoid races, destroying an object (CQ, SRQ or
1632  * QP) will wait for all affiliated events to be acknowledged, so
1633  * there should be a one-to-one correspondence between acks and
1634  * successful gets.
1635  */
1636 void ibv_ack_async_event(struct ibv_async_event *event);
1637
1638 /**
1639  * ibv_query_device - Get device properties
1640  */
1641 int ibv_query_device(struct ibv_context *context,
1642                      struct ibv_device_attr *device_attr);
1643
1644 /**
1645  * ibv_query_port - Get port properties
1646  */
1647 int ibv_query_port(struct ibv_context *context, uint8_t port_num,
1648                    struct ibv_port_attr *port_attr);
1649
1650 static inline int ___ibv_query_port(struct ibv_context *context,
1651                                     uint8_t port_num,
1652                                     struct ibv_port_attr *port_attr)
1653 {
1654         /* For compatibility when running with old libibverbs */
1655         port_attr->link_layer = IBV_LINK_LAYER_UNSPECIFIED;
1656         port_attr->reserved   = 0;
1657
1658         return ibv_query_port(context, port_num, port_attr);
1659 }
1660
1661 #define ibv_query_port(context, port_num, port_attr) \
1662         ___ibv_query_port(context, port_num, port_attr)
1663
1664 /**
1665  * ibv_query_gid - Get a GID table entry
1666  */
1667 int ibv_query_gid(struct ibv_context *context, uint8_t port_num,
1668                   int index, union ibv_gid *gid);
1669
1670 /**
1671  * ibv_query_pkey - Get a P_Key table entry
1672  */
1673 int ibv_query_pkey(struct ibv_context *context, uint8_t port_num,
1674                    int index, __be16 *pkey);
1675
1676 /**
1677  * ibv_alloc_pd - Allocate a protection domain
1678  */
1679 struct ibv_pd *ibv_alloc_pd(struct ibv_context *context);
1680
1681 /**
1682  * ibv_dealloc_pd - Free a protection domain
1683  */
1684 int ibv_dealloc_pd(struct ibv_pd *pd);
1685
1686 static inline struct ibv_flow *ibv_create_flow(struct ibv_qp *qp,
1687                                                struct ibv_flow_attr *flow)
1688 {
1689         struct verbs_context *vctx = verbs_get_ctx_op(qp->context,
1690                                                       ibv_create_flow);
1691         if (!vctx || !vctx->ibv_create_flow) {
1692                 errno = ENOSYS;
1693                 return NULL;
1694         }
1695
1696         return vctx->ibv_create_flow(qp, flow);
1697 }
1698
1699 static inline int ibv_destroy_flow(struct ibv_flow *flow_id)
1700 {
1701         struct verbs_context *vctx = verbs_get_ctx_op(flow_id->context,
1702                                                       ibv_destroy_flow);
1703         if (!vctx || !vctx->ibv_destroy_flow)
1704                 return -ENOSYS;
1705         return vctx->ibv_destroy_flow(flow_id);
1706 }
1707
1708 /**
1709  * ibv_open_xrcd - Open an extended connection domain
1710  */
1711 static inline struct ibv_xrcd *
1712 ibv_open_xrcd(struct ibv_context *context, struct ibv_xrcd_init_attr *xrcd_init_attr)
1713 {
1714         struct verbs_context *vctx = verbs_get_ctx_op(context, open_xrcd);
1715         if (!vctx) {
1716                 errno = ENOSYS;
1717                 return NULL;
1718         }
1719         return vctx->open_xrcd(context, xrcd_init_attr);
1720 }
1721
1722 /**
1723  * ibv_close_xrcd - Close an extended connection domain
1724  */
1725 static inline int ibv_close_xrcd(struct ibv_xrcd *xrcd)
1726 {
1727         struct verbs_context *vctx = verbs_get_ctx(xrcd->context);
1728         return vctx->close_xrcd(xrcd);
1729 }
1730
1731 /**
1732  * ibv_reg_mr - Register a memory region
1733  */
1734 struct ibv_mr *ibv_reg_mr(struct ibv_pd *pd, void *addr,
1735                           size_t length, int access);
1736
1737
1738 enum ibv_rereg_mr_err_code {
1739         /* Old MR is valid, invalid input */
1740         IBV_REREG_MR_ERR_INPUT = -1,
1741         /* Old MR is valid, failed via don't fork on new address range */
1742         IBV_REREG_MR_ERR_DONT_FORK_NEW = -2,
1743         /* New MR is valid, failed via do fork on old address range */
1744         IBV_REREG_MR_ERR_DO_FORK_OLD = -3,
1745         /* MR shouldn't be used, command error */
1746         IBV_REREG_MR_ERR_CMD = -4,
1747         /* MR shouldn't be used, command error, invalid fork state on new address range */
1748         IBV_REREG_MR_ERR_CMD_AND_DO_FORK_NEW = -5,
1749 };
1750
1751 /**
1752  * ibv_rereg_mr - Re-Register a memory region
1753  */
1754 int ibv_rereg_mr(struct ibv_mr *mr, int flags,
1755                  struct ibv_pd *pd, void *addr,
1756                  size_t length, int access);
1757 /**
1758  * ibv_dereg_mr - Deregister a memory region
1759  */
1760 int ibv_dereg_mr(struct ibv_mr *mr);
1761
1762 /**
1763  * ibv_alloc_mw - Allocate a memory window
1764  */
1765 static inline struct ibv_mw *ibv_alloc_mw(struct ibv_pd *pd,
1766                                           enum ibv_mw_type type)
1767 {
1768         struct ibv_mw *mw;
1769
1770         if (!pd->context->ops.alloc_mw) {
1771                 errno = ENOSYS;
1772                 return NULL;
1773         }
1774
1775         mw = pd->context->ops.alloc_mw(pd, type);
1776         return mw;
1777 }
1778
1779 /**
1780  * ibv_dealloc_mw - Free a memory window
1781  */
1782 static inline int ibv_dealloc_mw(struct ibv_mw *mw)
1783 {
1784         return mw->context->ops.dealloc_mw(mw);
1785 }
1786
1787 /**
1788  * ibv_inc_rkey - Increase the 8 lsb in the given rkey
1789  */
1790 static inline uint32_t ibv_inc_rkey(uint32_t rkey)
1791 {
1792         const uint32_t mask = 0x000000ff;
1793         uint8_t newtag = (uint8_t)((rkey + 1) & mask);
1794
1795         return (rkey & ~mask) | newtag;
1796 }
1797
1798 /**
1799  * ibv_bind_mw - Bind a memory window to a region
1800  */
1801 static inline int ibv_bind_mw(struct ibv_qp *qp, struct ibv_mw *mw,
1802                               struct ibv_mw_bind *mw_bind)
1803 {
1804         if (mw->type != IBV_MW_TYPE_1)
1805                 return EINVAL;
1806
1807         return mw->context->ops.bind_mw(qp, mw, mw_bind);
1808 }
1809
1810 /**
1811  * ibv_create_comp_channel - Create a completion event channel
1812  */
1813 struct ibv_comp_channel *ibv_create_comp_channel(struct ibv_context *context);
1814
1815 /**
1816  * ibv_destroy_comp_channel - Destroy a completion event channel
1817  */
1818 int ibv_destroy_comp_channel(struct ibv_comp_channel *channel);
1819
1820 /**
1821  * ibv_create_cq - Create a completion queue
1822  * @context - Context CQ will be attached to
1823  * @cqe - Minimum number of entries required for CQ
1824  * @cq_context - Consumer-supplied context returned for completion events
1825  * @channel - Completion channel where completion events will be queued.
1826  *     May be NULL if completion events will not be used.
1827  * @comp_vector - Completion vector used to signal completion events.
1828  *     Must be >= 0 and < context->num_comp_vectors.
1829  */
1830 struct ibv_cq *ibv_create_cq(struct ibv_context *context, int cqe,
1831                              void *cq_context,
1832                              struct ibv_comp_channel *channel,
1833                              int comp_vector);
1834
1835 /**
1836  * ibv_create_cq_ex - Create a completion queue
1837  * @context - Context CQ will be attached to
1838  * @cq_attr - Attributes to create the CQ with
1839  */
1840 static inline
1841 struct ibv_cq_ex *ibv_create_cq_ex(struct ibv_context *context,
1842                                    struct ibv_cq_init_attr_ex *cq_attr)
1843 {
1844         struct verbs_context *vctx = verbs_get_ctx_op(context, create_cq_ex);
1845
1846         if (!vctx) {
1847                 errno = ENOSYS;
1848                 return NULL;
1849         }
1850
1851         if (cq_attr->comp_mask & ~(IBV_CQ_INIT_ATTR_MASK_RESERVED - 1)) {
1852                 errno = EINVAL;
1853                 return NULL;
1854         }
1855
1856         return vctx->create_cq_ex(context, cq_attr);
1857 }
1858
1859 /**
1860  * ibv_resize_cq - Modifies the capacity of the CQ.
1861  * @cq: The CQ to resize.
1862  * @cqe: The minimum size of the CQ.
1863  *
1864  * Users can examine the cq structure to determine the actual CQ size.
1865  */
1866 int ibv_resize_cq(struct ibv_cq *cq, int cqe);
1867
1868 /**
1869  * ibv_destroy_cq - Destroy a completion queue
1870  */
1871 int ibv_destroy_cq(struct ibv_cq *cq);
1872
1873 /**
1874  * ibv_get_cq_event - Read next CQ event
1875  * @channel: Channel to get next event from.
1876  * @cq: Used to return pointer to CQ.
1877  * @cq_context: Used to return consumer-supplied CQ context.
1878  *
1879  * All completion events returned by ibv_get_cq_event() must
1880  * eventually be acknowledged with ibv_ack_cq_events().
1881  */
1882 int ibv_get_cq_event(struct ibv_comp_channel *channel,
1883                      struct ibv_cq **cq, void **cq_context);
1884
1885 /**
1886  * ibv_ack_cq_events - Acknowledge CQ completion events
1887  * @cq: CQ to acknowledge events for
1888  * @nevents: Number of events to acknowledge.
1889  *
1890  * All completion events which are returned by ibv_get_cq_event() must
1891  * be acknowledged.  To avoid races, ibv_destroy_cq() will wait for
1892  * all completion events to be acknowledged, so there should be a
1893  * one-to-one correspondence between acks and successful gets.  An
1894  * application may accumulate multiple completion events and
1895  * acknowledge them in a single call to ibv_ack_cq_events() by passing
1896  * the number of events to ack in @nevents.
1897  */
1898 void ibv_ack_cq_events(struct ibv_cq *cq, unsigned int nevents);
1899
1900 /**
1901  * ibv_poll_cq - Poll a CQ for work completions
1902  * @cq:the CQ being polled
1903  * @num_entries:maximum number of completions to return
1904  * @wc:array of at least @num_entries of &struct ibv_wc where completions
1905  *   will be returned
1906  *
1907  * Poll a CQ for (possibly multiple) completions.  If the return value
1908  * is < 0, an error occurred.  If the return value is >= 0, it is the
1909  * number of completions returned.  If the return value is
1910  * non-negative and strictly less than num_entries, then the CQ was
1911  * emptied.
1912  */
1913 static inline int ibv_poll_cq(struct ibv_cq *cq, int num_entries, struct ibv_wc *wc)
1914 {
1915         return cq->context->ops.poll_cq(cq, num_entries, wc);
1916 }
1917
1918 /**
1919  * ibv_req_notify_cq - Request completion notification on a CQ.  An
1920  *   event will be added to the completion channel associated with the
1921  *   CQ when an entry is added to the CQ.
1922  * @cq: The completion queue to request notification for.
1923  * @solicited_only: If non-zero, an event will be generated only for
1924  *   the next solicited CQ entry.  If zero, any CQ entry, solicited or
1925  *   not, will generate an event.
1926  */
1927 static inline int ibv_req_notify_cq(struct ibv_cq *cq, int solicited_only)
1928 {
1929         return cq->context->ops.req_notify_cq(cq, solicited_only);
1930 }
1931
1932 /**
1933  * ibv_create_srq - Creates a SRQ associated with the specified protection
1934  *   domain.
1935  * @pd: The protection domain associated with the SRQ.
1936  * @srq_init_attr: A list of initial attributes required to create the SRQ.
1937  *
1938  * srq_attr->max_wr and srq_attr->max_sge are read the determine the
1939  * requested size of the SRQ, and set to the actual values allocated
1940  * on return.  If ibv_create_srq() succeeds, then max_wr and max_sge
1941  * will always be at least as large as the requested values.
1942  */
1943 struct ibv_srq *ibv_create_srq(struct ibv_pd *pd,
1944                                struct ibv_srq_init_attr *srq_init_attr);
1945
1946 static inline struct ibv_srq *
1947 ibv_create_srq_ex(struct ibv_context *context,
1948                   struct ibv_srq_init_attr_ex *srq_init_attr_ex)
1949 {
1950         struct verbs_context *vctx;
1951         uint32_t mask = srq_init_attr_ex->comp_mask;
1952
1953         if (!(mask & ~(IBV_SRQ_INIT_ATTR_PD | IBV_SRQ_INIT_ATTR_TYPE)) &&
1954             (mask & IBV_SRQ_INIT_ATTR_PD) &&
1955             (!(mask & IBV_SRQ_INIT_ATTR_TYPE) ||
1956              (srq_init_attr_ex->srq_type == IBV_SRQT_BASIC)))
1957                 return ibv_create_srq(srq_init_attr_ex->pd,
1958                                       (struct ibv_srq_init_attr *)srq_init_attr_ex);
1959
1960         vctx = verbs_get_ctx_op(context, create_srq_ex);
1961         if (!vctx) {
1962                 errno = ENOSYS;
1963                 return NULL;
1964         }
1965         return vctx->create_srq_ex(context, srq_init_attr_ex);
1966 }
1967
1968 /**
1969  * ibv_modify_srq - Modifies the attributes for the specified SRQ.
1970  * @srq: The SRQ to modify.
1971  * @srq_attr: On input, specifies the SRQ attributes to modify.  On output,
1972  *   the current values of selected SRQ attributes are returned.
1973  * @srq_attr_mask: A bit-mask used to specify which attributes of the SRQ
1974  *   are being modified.
1975  *
1976  * The mask may contain IBV_SRQ_MAX_WR to resize the SRQ and/or
1977  * IBV_SRQ_LIMIT to set the SRQ's limit and request notification when
1978  * the number of receives queued drops below the limit.
1979  */
1980 int ibv_modify_srq(struct ibv_srq *srq,
1981                    struct ibv_srq_attr *srq_attr,
1982                    int srq_attr_mask);
1983
1984 /**
1985  * ibv_query_srq - Returns the attribute list and current values for the
1986  *   specified SRQ.
1987  * @srq: The SRQ to query.
1988  * @srq_attr: The attributes of the specified SRQ.
1989  */
1990 int ibv_query_srq(struct ibv_srq *srq, struct ibv_srq_attr *srq_attr);
1991
1992 static inline int ibv_get_srq_num(struct ibv_srq *srq, uint32_t *srq_num)
1993 {
1994         struct verbs_context *vctx = verbs_get_ctx_op(srq->context, get_srq_num);
1995
1996         if (!vctx)
1997                 return ENOSYS;
1998
1999         return vctx->get_srq_num(srq, srq_num);
2000 }
2001
2002 /**
2003  * ibv_destroy_srq - Destroys the specified SRQ.
2004  * @srq: The SRQ to destroy.
2005  */
2006 int ibv_destroy_srq(struct ibv_srq *srq);
2007
2008 /**
2009  * ibv_post_srq_recv - Posts a list of work requests to the specified SRQ.
2010  * @srq: The SRQ to post the work request on.
2011  * @recv_wr: A list of work requests to post on the receive queue.
2012  * @bad_recv_wr: On an immediate failure, this parameter will reference
2013  *   the work request that failed to be posted on the QP.
2014  */
2015 static inline int ibv_post_srq_recv(struct ibv_srq *srq,
2016                                     struct ibv_recv_wr *recv_wr,
2017                                     struct ibv_recv_wr **bad_recv_wr)
2018 {
2019         return srq->context->ops.post_srq_recv(srq, recv_wr, bad_recv_wr);
2020 }
2021
2022 /**
2023  * ibv_create_qp - Create a queue pair.
2024  */
2025 struct ibv_qp *ibv_create_qp(struct ibv_pd *pd,
2026                              struct ibv_qp_init_attr *qp_init_attr);
2027
2028 static inline struct ibv_qp *
2029 ibv_create_qp_ex(struct ibv_context *context, struct ibv_qp_init_attr_ex *qp_init_attr_ex)
2030 {
2031         struct verbs_context *vctx;
2032         uint32_t mask = qp_init_attr_ex->comp_mask;
2033
2034         if (mask == IBV_QP_INIT_ATTR_PD)
2035                 return ibv_create_qp(qp_init_attr_ex->pd,
2036                                      (struct ibv_qp_init_attr *)qp_init_attr_ex);
2037
2038         vctx = verbs_get_ctx_op(context, create_qp_ex);
2039         if (!vctx) {
2040                 errno = ENOSYS;
2041                 return NULL;
2042         }
2043         return vctx->create_qp_ex(context, qp_init_attr_ex);
2044 }
2045
2046 /**
2047  * ibv_query_rt_values_ex - Get current real time @values of a device.
2048  * @values - in/out - defines the attributes we need to query/queried.
2049  * (Or's bits of enum ibv_values_mask on values->comp_mask field)
2050  */
2051 static inline int
2052 ibv_query_rt_values_ex(struct ibv_context *context,
2053                        struct ibv_values_ex *values)
2054 {
2055         struct verbs_context *vctx;
2056
2057         vctx = verbs_get_ctx_op(context, query_rt_values);
2058         if (!vctx)
2059                 return ENOSYS;
2060
2061         if (values->comp_mask & ~(IBV_VALUES_MASK_RESERVED - 1))
2062                 return EINVAL;
2063
2064         return vctx->query_rt_values(context, values);
2065 }
2066
2067 /**
2068  * ibv_query_device_ex - Get extended device properties
2069  */
2070 static inline int
2071 ibv_query_device_ex(struct ibv_context *context,
2072                     const struct ibv_query_device_ex_input *input,
2073                     struct ibv_device_attr_ex *attr)
2074 {
2075         struct verbs_context *vctx;
2076         int ret;
2077
2078         vctx = verbs_get_ctx_op(context, query_device_ex);
2079         if (!vctx)
2080                 goto legacy;
2081
2082         ret = vctx->query_device_ex(context, input, attr, sizeof(*attr));
2083         if (ret == ENOSYS)
2084                 goto legacy;
2085
2086         return ret;
2087
2088 legacy:
2089         memset(attr, 0, sizeof(*attr));
2090         ret = ibv_query_device(context, &attr->orig_attr);
2091
2092         return ret;
2093 }
2094
2095 /**
2096  * ibv_open_qp - Open a shareable queue pair.
2097  */
2098 static inline struct ibv_qp *
2099 ibv_open_qp(struct ibv_context *context, struct ibv_qp_open_attr *qp_open_attr)
2100 {
2101         struct verbs_context *vctx = verbs_get_ctx_op(context, open_qp);
2102         if (!vctx) {
2103                 errno = ENOSYS;
2104                 return NULL;
2105         }
2106         return vctx->open_qp(context, qp_open_attr);
2107 }
2108
2109 /**
2110  * ibv_modify_qp - Modify a queue pair.
2111  */
2112 int ibv_modify_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr,
2113                   int attr_mask);
2114
2115 /**
2116  * ibv_query_qp - Returns the attribute list and current values for the
2117  *   specified QP.
2118  * @qp: The QP to query.
2119  * @attr: The attributes of the specified QP.
2120  * @attr_mask: A bit-mask used to select specific attributes to query.
2121  * @init_attr: Additional attributes of the selected QP.
2122  *
2123  * The qp_attr_mask may be used to limit the query to gathering only the
2124  * selected attributes.
2125  */
2126 int ibv_query_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr,
2127                  int attr_mask,
2128                  struct ibv_qp_init_attr *init_attr);
2129
2130 /**
2131  * ibv_destroy_qp - Destroy a queue pair.
2132  */
2133 int ibv_destroy_qp(struct ibv_qp *qp);
2134
2135 /*
2136  * ibv_create_wq - Creates a WQ associated with the specified protection
2137  * domain.
2138  * @context: ibv_context.
2139  * @wq_init_attr: A list of initial attributes required to create the
2140  * WQ. If WQ creation succeeds, then the attributes are updated to
2141  * the actual capabilities of the created WQ.
2142  *
2143  * wq_init_attr->max_wr and wq_init_attr->max_sge determine
2144  * the requested size of the WQ, and set to the actual values allocated
2145  * on return.
2146  * If ibv_create_wq() succeeds, then max_wr and max_sge will always be
2147  * at least as large as the requested values.
2148  *
2149  * Return Value
2150  * ibv_create_wq() returns a pointer to the created WQ, or NULL if the request
2151  * fails.
2152  */
2153 static inline struct ibv_wq *ibv_create_wq(struct ibv_context *context,
2154                                            struct ibv_wq_init_attr *wq_init_attr)
2155 {
2156         struct verbs_context *vctx = verbs_get_ctx_op(context, create_wq);
2157         struct ibv_wq *wq;
2158
2159         if (!vctx) {
2160                 errno = ENOSYS;
2161                 return NULL;
2162         }
2163
2164         wq = vctx->create_wq(context, wq_init_attr);
2165         if (wq) {
2166                 wq->events_completed = 0;
2167                 pthread_mutex_init(&wq->mutex, NULL);
2168                 pthread_cond_init(&wq->cond, NULL);
2169         }
2170
2171         return wq;
2172 }
2173
2174 /*
2175  * ibv_modify_wq - Modifies the attributes for the specified WQ.
2176  * @wq: The WQ to modify.
2177  * @wq_attr: On input, specifies the WQ attributes to modify.
2178  *    wq_attr->attr_mask: A bit-mask used to specify which attributes of the WQ
2179  *    are being modified.
2180  * On output, the current values of selected WQ attributes are returned.
2181  *
2182  * Return Value
2183  * ibv_modify_wq() returns 0 on success, or the value of errno
2184  * on failure (which indicates the failure reason).
2185  *
2186 */
2187 static inline int ibv_modify_wq(struct ibv_wq *wq, struct ibv_wq_attr *wq_attr)
2188 {
2189         struct verbs_context *vctx = verbs_get_ctx_op(wq->context, modify_wq);
2190
2191         if (!vctx)
2192                 return ENOSYS;
2193
2194         return vctx->modify_wq(wq, wq_attr);
2195 }
2196
2197 /*
2198  * ibv_destroy_wq - Destroys the specified WQ.
2199  * @ibv_wq: The WQ to destroy.
2200  * Return Value
2201  * ibv_destroy_wq() returns 0 on success, or the value of errno
2202  * on failure (which indicates the failure reason).
2203 */
2204 static inline int ibv_destroy_wq(struct ibv_wq *wq)
2205 {
2206         struct verbs_context *vctx;
2207
2208         vctx = verbs_get_ctx_op(wq->context, destroy_wq);
2209         if (!vctx)
2210                 return ENOSYS;
2211
2212         return vctx->destroy_wq(wq);
2213 }
2214
2215 /*
2216  * ibv_create_rwq_ind_table - Creates a receive work queue Indirection Table
2217  * @context: ibv_context.
2218  * @init_attr: A list of initial attributes required to create the Indirection Table.
2219  * Return Value
2220  * ibv_create_rwq_ind_table returns a pointer to the created
2221  * Indirection Table, or NULL if the request fails.
2222  */
2223 static inline struct ibv_rwq_ind_table *ibv_create_rwq_ind_table(struct ibv_context *context,
2224                                                                  struct ibv_rwq_ind_table_init_attr *init_attr)
2225 {
2226         struct verbs_context *vctx;
2227
2228         vctx = verbs_get_ctx_op(context, create_rwq_ind_table);
2229         if (!vctx) {
2230                 errno = ENOSYS;
2231                 return NULL;
2232         }
2233
2234         return vctx->create_rwq_ind_table(context, init_attr);
2235 }
2236
2237 /*
2238  * ibv_destroy_rwq_ind_table - Destroys the specified Indirection Table.
2239  * @rwq_ind_table: The Indirection Table to destroy.
2240  * Return Value
2241  * ibv_destroy_rwq_ind_table() returns 0 on success, or the value of errno
2242  * on failure (which indicates the failure reason).
2243 */
2244 static inline int ibv_destroy_rwq_ind_table(struct ibv_rwq_ind_table *rwq_ind_table)
2245 {
2246         struct verbs_context *vctx;
2247
2248         vctx = verbs_get_ctx_op(rwq_ind_table->context, destroy_rwq_ind_table);
2249         if (!vctx)
2250                 return ENOSYS;
2251
2252         return vctx->destroy_rwq_ind_table(rwq_ind_table);
2253 }
2254
2255 /**
2256  * ibv_post_send - Post a list of work requests to a send queue.
2257  *
2258  * If IBV_SEND_INLINE flag is set, the data buffers can be reused
2259  * immediately after the call returns.
2260  */
2261 static inline int ibv_post_send(struct ibv_qp *qp, struct ibv_send_wr *wr,
2262                                 struct ibv_send_wr **bad_wr)
2263 {
2264         return qp->context->ops.post_send(qp, wr, bad_wr);
2265 }
2266
2267 /**
2268  * ibv_post_recv - Post a list of work requests to a receive queue.
2269  */
2270 static inline int ibv_post_recv(struct ibv_qp *qp, struct ibv_recv_wr *wr,
2271                                 struct ibv_recv_wr **bad_wr)
2272 {
2273         return qp->context->ops.post_recv(qp, wr, bad_wr);
2274 }
2275
2276 /**
2277  * ibv_create_ah - Create an address handle.
2278  */
2279 struct ibv_ah *ibv_create_ah(struct ibv_pd *pd, struct ibv_ah_attr *attr);
2280
2281 /**
2282  * ibv_init_ah_from_wc - Initializes address handle attributes from a
2283  *   work completion.
2284  * @context: Device context on which the received message arrived.
2285  * @port_num: Port on which the received message arrived.
2286  * @wc: Work completion associated with the received message.
2287  * @grh: References the received global route header.  This parameter is
2288  *   ignored unless the work completion indicates that the GRH is valid.
2289  * @ah_attr: Returned attributes that can be used when creating an address
2290  *   handle for replying to the message.
2291  */
2292 int ibv_init_ah_from_wc(struct ibv_context *context, uint8_t port_num,
2293                         struct ibv_wc *wc, struct ibv_grh *grh,
2294                         struct ibv_ah_attr *ah_attr);
2295
2296 /**
2297  * ibv_create_ah_from_wc - Creates an address handle associated with the
2298  *   sender of the specified work completion.
2299  * @pd: The protection domain associated with the address handle.
2300  * @wc: Work completion information associated with a received message.
2301  * @grh: References the received global route header.  This parameter is
2302  *   ignored unless the work completion indicates that the GRH is valid.
2303  * @port_num: The outbound port number to associate with the address.
2304  *
2305  * The address handle is used to reference a local or global destination
2306  * in all UD QP post sends.
2307  */
2308 struct ibv_ah *ibv_create_ah_from_wc(struct ibv_pd *pd, struct ibv_wc *wc,
2309                                      struct ibv_grh *grh, uint8_t port_num);
2310
2311 /**
2312  * ibv_destroy_ah - Destroy an address handle.
2313  */
2314 int ibv_destroy_ah(struct ibv_ah *ah);
2315
2316 /**
2317  * ibv_attach_mcast - Attaches the specified QP to a multicast group.
2318  * @qp: QP to attach to the multicast group.  The QP must be a UD QP.
2319  * @gid: Multicast group GID.
2320  * @lid: Multicast group LID in host byte order.
2321  *
2322  * In order to route multicast packets correctly, subnet
2323  * administration must have created the multicast group and configured
2324  * the fabric appropriately.  The port associated with the specified
2325  * QP must also be a member of the multicast group.
2326  */
2327 int ibv_attach_mcast(struct ibv_qp *qp, const union ibv_gid *gid, uint16_t lid);
2328
2329 /**
2330  * ibv_detach_mcast - Detaches the specified QP from a multicast group.
2331  * @qp: QP to detach from the multicast group.
2332  * @gid: Multicast group GID.
2333  * @lid: Multicast group LID in host byte order.
2334  */
2335 int ibv_detach_mcast(struct ibv_qp *qp, const union ibv_gid *gid, uint16_t lid);
2336
2337 /**
2338  * ibv_fork_init - Prepare data structures so that fork() may be used
2339  * safely.  If this function is not called or returns a non-zero
2340  * status, then libibverbs data structures are not fork()-safe and the
2341  * effect of an application calling fork() is undefined.
2342  */
2343 int ibv_fork_init(void);
2344
2345 /**
2346  * ibv_node_type_str - Return string describing node_type enum value
2347  */
2348 const char *ibv_node_type_str(enum ibv_node_type node_type);
2349
2350 /**
2351  * ibv_port_state_str - Return string describing port_state enum value
2352  */
2353 const char *ibv_port_state_str(enum ibv_port_state port_state);
2354
2355 /**
2356  * ibv_event_type_str - Return string describing event_type enum value
2357  */
2358 const char *ibv_event_type_str(enum ibv_event_type event);
2359
2360 #define ETHERNET_LL_SIZE 6
2361 int ibv_resolve_eth_l2_from_gid(struct ibv_context *context,
2362                                 struct ibv_ah_attr *attr,
2363                                 uint8_t eth_mac[ETHERNET_LL_SIZE],
2364                                 uint16_t *vid);
2365
2366 static inline int ibv_is_qpt_supported(uint32_t caps, enum ibv_qp_type qpt)
2367 {
2368         return !!(caps & (1 << qpt));
2369 }
2370
2371 END_C_DECLS
2372
2373 #  undef __attribute_const
2374
2375
2376 #endif /* INFINIBAND_VERBS_H */