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 IBV_RATE_28_GBPS = 19, 595 IBV_RATE_50_GBPS = 20, 596 IBV_RATE_400_GBPS = 21, 597 IBV_RATE_600_GBPS = 22, 598 }; 599 600 /** 601 * ibv_rate_to_mult - Convert the IB rate enum to a multiple of the 602 * base rate of 2.5 Gbit/sec. For example, IBV_RATE_5_GBPS will be 603 * converted to 2, since 5 Gbit/sec is 2 * 2.5 Gbit/sec. 604 * @rate: rate to convert. 605 */ 606 int __attribute_const ibv_rate_to_mult(enum ibv_rate rate); 607 608 /** 609 * mult_to_ibv_rate - Convert a multiple of 2.5 Gbit/sec to an IB rate enum. 610 * @mult: multiple to convert. 611 */ 612 enum ibv_rate __attribute_const mult_to_ibv_rate(int mult); 613 614 /** 615 * ibv_rate_to_mbps - Convert the IB rate enum to Mbit/sec. 616 * For example, IBV_RATE_5_GBPS will return the value 5000. 617 * @rate: rate to convert. 618 */ 619 int __attribute_const ibv_rate_to_mbps(enum ibv_rate rate); 620 621 /** 622 * mbps_to_ibv_rate - Convert a Mbit/sec value to an IB rate enum. 623 * @mbps: value to convert. 624 */ 625 enum ibv_rate __attribute_const mbps_to_ibv_rate(int mbps) __attribute_const; 626 627 struct ibv_ah_attr { 628 struct ibv_global_route grh; 629 uint16_t dlid; 630 uint8_t sl; 631 uint8_t src_path_bits; 632 uint8_t static_rate; 633 uint8_t is_global; 634 uint8_t port_num; 635 }; 636 637 enum ibv_srq_attr_mask { 638 IBV_SRQ_MAX_WR = 1 << 0, 639 IBV_SRQ_LIMIT = 1 << 1 640 }; 641 642 struct ibv_srq_attr { 643 uint32_t max_wr; 644 uint32_t max_sge; 645 uint32_t srq_limit; 646 }; 647 648 struct ibv_srq_init_attr { 649 void *srq_context; 650 struct ibv_srq_attr attr; 651 }; 652 653 enum ibv_srq_type { 654 IBV_SRQT_BASIC, 655 IBV_SRQT_XRC 656 }; 657 658 enum ibv_srq_init_attr_mask { 659 IBV_SRQ_INIT_ATTR_TYPE = 1 << 0, 660 IBV_SRQ_INIT_ATTR_PD = 1 << 1, 661 IBV_SRQ_INIT_ATTR_XRCD = 1 << 2, 662 IBV_SRQ_INIT_ATTR_CQ = 1 << 3, 663 IBV_SRQ_INIT_ATTR_RESERVED = 1 << 4 664 }; 665 666 struct ibv_srq_init_attr_ex { 667 void *srq_context; 668 struct ibv_srq_attr attr; 669 670 uint32_t comp_mask; 671 enum ibv_srq_type srq_type; 672 struct ibv_pd *pd; 673 struct ibv_xrcd *xrcd; 674 struct ibv_cq *cq; 675 }; 676 677 enum ibv_wq_type { 678 IBV_WQT_RQ 679 }; 680 681 enum ibv_wq_init_attr_mask { 682 IBV_WQ_INIT_ATTR_FLAGS = 1 << 0, 683 IBV_WQ_INIT_ATTR_RESERVED = 1 << 1, 684 }; 685 686 enum ibv_wq_flags { 687 IBV_WQ_FLAGS_CVLAN_STRIPPING = 1 << 0, 688 IBV_WQ_FLAGS_SCATTER_FCS = 1 << 1, 689 IBV_WQ_FLAGS_RESERVED = 1 << 2, 690 }; 691 692 struct ibv_wq_init_attr { 693 void *wq_context; 694 enum ibv_wq_type wq_type; 695 uint32_t max_wr; 696 uint32_t max_sge; 697 struct ibv_pd *pd; 698 struct ibv_cq *cq; 699 uint32_t comp_mask; /* Use ibv_wq_init_attr_mask */ 700 uint32_t create_flags; /* use ibv_wq_flags */ 701 }; 702 703 enum ibv_wq_state { 704 IBV_WQS_RESET, 705 IBV_WQS_RDY, 706 IBV_WQS_ERR, 707 IBV_WQS_UNKNOWN 708 }; 709 710 enum ibv_wq_attr_mask { 711 IBV_WQ_ATTR_STATE = 1 << 0, 712 IBV_WQ_ATTR_CURR_STATE = 1 << 1, 713 IBV_WQ_ATTR_FLAGS = 1 << 2, 714 IBV_WQ_ATTR_RESERVED = 1 << 3, 715 }; 716 717 struct ibv_wq_attr { 718 /* enum ibv_wq_attr_mask */ 719 uint32_t attr_mask; 720 /* Move the WQ to this state */ 721 enum ibv_wq_state wq_state; 722 /* Assume this is the current WQ state */ 723 enum ibv_wq_state curr_wq_state; 724 uint32_t flags; /* Use ibv_wq_flags */ 725 uint32_t flags_mask; /* Use ibv_wq_flags */ 726 }; 727 728 /* 729 * Receive Work Queue Indirection Table. 730 * It's used in order to distribute incoming packets between different 731 * Receive Work Queues. Associating Receive WQs with different CPU cores 732 * allows to workload the traffic between different CPU cores. 733 * The Indirection Table can contain only WQs of type IBV_WQT_RQ. 734 */ 735 struct ibv_rwq_ind_table { 736 struct ibv_context *context; 737 int ind_tbl_handle; 738 int ind_tbl_num; 739 uint32_t comp_mask; 740 }; 741 742 enum ibv_ind_table_init_attr_mask { 743 IBV_CREATE_IND_TABLE_RESERVED = (1 << 0) 744 }; 745 746 /* 747 * Receive Work Queue Indirection Table attributes 748 */ 749 struct ibv_rwq_ind_table_init_attr { 750 uint32_t log_ind_tbl_size; 751 /* Each entry is a pointer to a Receive Work Queue */ 752 struct ibv_wq **ind_tbl; 753 uint32_t comp_mask; 754 }; 755 756 enum ibv_qp_type { 757 IBV_QPT_RC = 2, 758 IBV_QPT_UC, 759 IBV_QPT_UD, 760 IBV_QPT_RAW_PACKET = 8, 761 IBV_QPT_XRC_SEND = 9, 762 IBV_QPT_XRC_RECV 763 }; 764 765 struct ibv_qp_cap { 766 uint32_t max_send_wr; 767 uint32_t max_recv_wr; 768 uint32_t max_send_sge; 769 uint32_t max_recv_sge; 770 uint32_t max_inline_data; 771 }; 772 773 struct ibv_qp_init_attr { 774 void *qp_context; 775 struct ibv_cq *send_cq; 776 struct ibv_cq *recv_cq; 777 struct ibv_srq *srq; 778 struct ibv_qp_cap cap; 779 enum ibv_qp_type qp_type; 780 int sq_sig_all; 781 }; 782 783 enum ibv_qp_init_attr_mask { 784 IBV_QP_INIT_ATTR_PD = 1 << 0, 785 IBV_QP_INIT_ATTR_XRCD = 1 << 1, 786 IBV_QP_INIT_ATTR_CREATE_FLAGS = 1 << 2, 787 IBV_QP_INIT_ATTR_MAX_TSO_HEADER = 1 << 3, 788 IBV_QP_INIT_ATTR_IND_TABLE = 1 << 4, 789 IBV_QP_INIT_ATTR_RX_HASH = 1 << 5, 790 IBV_QP_INIT_ATTR_RESERVED = 1 << 6 791 }; 792 793 enum ibv_qp_create_flags { 794 IBV_QP_CREATE_BLOCK_SELF_MCAST_LB = 1 << 1, 795 IBV_QP_CREATE_SCATTER_FCS = 1 << 8, 796 IBV_QP_CREATE_CVLAN_STRIPPING = 1 << 9, 797 }; 798 799 struct ibv_rx_hash_conf { 800 /* enum ibv_rx_hash_function_flags */ 801 uint8_t rx_hash_function; 802 uint8_t rx_hash_key_len; 803 uint8_t *rx_hash_key; 804 /* enum ibv_rx_hash_fields */ 805 uint64_t rx_hash_fields_mask; 806 }; 807 808 struct ibv_qp_init_attr_ex { 809 void *qp_context; 810 struct ibv_cq *send_cq; 811 struct ibv_cq *recv_cq; 812 struct ibv_srq *srq; 813 struct ibv_qp_cap cap; 814 enum ibv_qp_type qp_type; 815 int sq_sig_all; 816 817 uint32_t comp_mask; 818 struct ibv_pd *pd; 819 struct ibv_xrcd *xrcd; 820 uint32_t create_flags; 821 uint16_t max_tso_header; 822 struct ibv_rwq_ind_table *rwq_ind_tbl; 823 struct ibv_rx_hash_conf rx_hash_conf; 824 }; 825 826 enum ibv_qp_open_attr_mask { 827 IBV_QP_OPEN_ATTR_NUM = 1 << 0, 828 IBV_QP_OPEN_ATTR_XRCD = 1 << 1, 829 IBV_QP_OPEN_ATTR_CONTEXT = 1 << 2, 830 IBV_QP_OPEN_ATTR_TYPE = 1 << 3, 831 IBV_QP_OPEN_ATTR_RESERVED = 1 << 4 832 }; 833 834 struct ibv_qp_open_attr { 835 uint32_t comp_mask; 836 uint32_t qp_num; 837 struct ibv_xrcd *xrcd; 838 void *qp_context; 839 enum ibv_qp_type qp_type; 840 }; 841 842 enum ibv_qp_attr_mask { 843 IBV_QP_STATE = 1 << 0, 844 IBV_QP_CUR_STATE = 1 << 1, 845 IBV_QP_EN_SQD_ASYNC_NOTIFY = 1 << 2, 846 IBV_QP_ACCESS_FLAGS = 1 << 3, 847 IBV_QP_PKEY_INDEX = 1 << 4, 848 IBV_QP_PORT = 1 << 5, 849 IBV_QP_QKEY = 1 << 6, 850 IBV_QP_AV = 1 << 7, 851 IBV_QP_PATH_MTU = 1 << 8, 852 IBV_QP_TIMEOUT = 1 << 9, 853 IBV_QP_RETRY_CNT = 1 << 10, 854 IBV_QP_RNR_RETRY = 1 << 11, 855 IBV_QP_RQ_PSN = 1 << 12, 856 IBV_QP_MAX_QP_RD_ATOMIC = 1 << 13, 857 IBV_QP_ALT_PATH = 1 << 14, 858 IBV_QP_MIN_RNR_TIMER = 1 << 15, 859 IBV_QP_SQ_PSN = 1 << 16, 860 IBV_QP_MAX_DEST_RD_ATOMIC = 1 << 17, 861 IBV_QP_PATH_MIG_STATE = 1 << 18, 862 IBV_QP_CAP = 1 << 19, 863 IBV_QP_DEST_QPN = 1 << 20, 864 IBV_QP_RATE_LIMIT = 1 << 25, 865 }; 866 867 enum ibv_qp_state { 868 IBV_QPS_RESET, 869 IBV_QPS_INIT, 870 IBV_QPS_RTR, 871 IBV_QPS_RTS, 872 IBV_QPS_SQD, 873 IBV_QPS_SQE, 874 IBV_QPS_ERR, 875 IBV_QPS_UNKNOWN 876 }; 877 878 enum ibv_mig_state { 879 IBV_MIG_MIGRATED, 880 IBV_MIG_REARM, 881 IBV_MIG_ARMED 882 }; 883 884 struct ibv_qp_attr { 885 enum ibv_qp_state qp_state; 886 enum ibv_qp_state cur_qp_state; 887 enum ibv_mtu path_mtu; 888 enum ibv_mig_state path_mig_state; 889 uint32_t qkey; 890 uint32_t rq_psn; 891 uint32_t sq_psn; 892 uint32_t dest_qp_num; 893 int qp_access_flags; 894 struct ibv_qp_cap cap; 895 struct ibv_ah_attr ah_attr; 896 struct ibv_ah_attr alt_ah_attr; 897 uint16_t pkey_index; 898 uint16_t alt_pkey_index; 899 uint8_t en_sqd_async_notify; 900 uint8_t sq_draining; 901 uint8_t max_rd_atomic; 902 uint8_t max_dest_rd_atomic; 903 uint8_t min_rnr_timer; 904 uint8_t port_num; 905 uint8_t timeout; 906 uint8_t retry_cnt; 907 uint8_t rnr_retry; 908 uint8_t alt_port_num; 909 uint8_t alt_timeout; 910 uint32_t rate_limit; 911 }; 912 913 enum ibv_wr_opcode { 914 IBV_WR_RDMA_WRITE, 915 IBV_WR_RDMA_WRITE_WITH_IMM, 916 IBV_WR_SEND, 917 IBV_WR_SEND_WITH_IMM, 918 IBV_WR_RDMA_READ, 919 IBV_WR_ATOMIC_CMP_AND_SWP, 920 IBV_WR_ATOMIC_FETCH_AND_ADD, 921 IBV_WR_LOCAL_INV, 922 IBV_WR_BIND_MW, 923 IBV_WR_SEND_WITH_INV, 924 IBV_WR_TSO, 925 }; 926 927 enum ibv_send_flags { 928 IBV_SEND_FENCE = 1 << 0, 929 IBV_SEND_SIGNALED = 1 << 1, 930 IBV_SEND_SOLICITED = 1 << 2, 931 IBV_SEND_INLINE = 1 << 3, 932 IBV_SEND_IP_CSUM = 1 << 4 933 }; 934 935 struct ibv_sge { 936 uint64_t addr; 937 uint32_t length; 938 uint32_t lkey; 939 }; 940 941 struct ibv_send_wr { 942 uint64_t wr_id; 943 struct ibv_send_wr *next; 944 struct ibv_sge *sg_list; 945 int num_sge; 946 enum ibv_wr_opcode opcode; 947 int send_flags; 948 __be32 imm_data; 949 union { 950 struct { 951 uint64_t remote_addr; 952 uint32_t rkey; 953 } rdma; 954 struct { 955 uint64_t remote_addr; 956 uint64_t compare_add; 957 uint64_t swap; 958 uint32_t rkey; 959 } atomic; 960 struct { 961 struct ibv_ah *ah; 962 uint32_t remote_qpn; 963 uint32_t remote_qkey; 964 } ud; 965 } wr; 966 union { 967 struct { 968 uint32_t remote_srqn; 969 } xrc; 970 } qp_type; 971 union { 972 struct { 973 struct ibv_mw *mw; 974 uint32_t rkey; 975 struct ibv_mw_bind_info bind_info; 976 } bind_mw; 977 struct { 978 void *hdr; 979 uint16_t hdr_sz; 980 uint16_t mss; 981 } tso; 982 }; 983 }; 984 985 struct ibv_recv_wr { 986 uint64_t wr_id; 987 struct ibv_recv_wr *next; 988 struct ibv_sge *sg_list; 989 int num_sge; 990 }; 991 992 struct ibv_mw_bind { 993 uint64_t wr_id; 994 int send_flags; 995 struct ibv_mw_bind_info bind_info; 996 }; 997 998 struct ibv_srq { 999 struct ibv_context *context; 1000 void *srq_context; 1001 struct ibv_pd *pd; 1002 uint32_t handle; 1003 1004 pthread_mutex_t mutex; 1005 pthread_cond_t cond; 1006 uint32_t events_completed; 1007 }; 1008 1009 /* 1010 * Work Queue. QP can be created without internal WQs "packaged" inside it, 1011 * this QP can be configured to use "external" WQ object as its 1012 * receive/send queue. 1013 * WQ associated (many to one) with Completion Queue it owns WQ properties 1014 * (PD, WQ size etc). 1015 * WQ of type IBV_WQT_RQ: 1016 * - Contains receive WQEs, in this case its PD serves as scatter as well. 1017 * - Exposes post receive function to be used to post a list of work 1018 * requests (WRs) to its receive queue. 1019 */ 1020 struct ibv_wq { 1021 struct ibv_context *context; 1022 void *wq_context; 1023 struct ibv_pd *pd; 1024 struct ibv_cq *cq; 1025 uint32_t wq_num; 1026 uint32_t handle; 1027 enum ibv_wq_state state; 1028 enum ibv_wq_type wq_type; 1029 int (*post_recv)(struct ibv_wq *current, 1030 struct ibv_recv_wr *recv_wr, 1031 struct ibv_recv_wr **bad_recv_wr); 1032 pthread_mutex_t mutex; 1033 pthread_cond_t cond; 1034 uint32_t events_completed; 1035 uint32_t comp_mask; 1036 }; 1037 1038 struct ibv_qp { 1039 struct ibv_context *context; 1040 void *qp_context; 1041 struct ibv_pd *pd; 1042 struct ibv_cq *send_cq; 1043 struct ibv_cq *recv_cq; 1044 struct ibv_srq *srq; 1045 uint32_t handle; 1046 uint32_t qp_num; 1047 enum ibv_qp_state state; 1048 enum ibv_qp_type qp_type; 1049 1050 pthread_mutex_t mutex; 1051 pthread_cond_t cond; 1052 uint32_t events_completed; 1053 }; 1054 1055 struct ibv_comp_channel { 1056 struct ibv_context *context; 1057 int fd; 1058 int refcnt; 1059 }; 1060 1061 struct ibv_cq { 1062 struct ibv_context *context; 1063 struct ibv_comp_channel *channel; 1064 void *cq_context; 1065 uint32_t handle; 1066 int cqe; 1067 1068 pthread_mutex_t mutex; 1069 pthread_cond_t cond; 1070 uint32_t comp_events_completed; 1071 uint32_t async_events_completed; 1072 }; 1073 1074 struct ibv_poll_cq_attr { 1075 uint32_t comp_mask; 1076 }; 1077 1078 struct ibv_cq_ex { 1079 struct ibv_context *context; 1080 struct ibv_comp_channel *channel; 1081 void *cq_context; 1082 uint32_t handle; 1083 int cqe; 1084 1085 pthread_mutex_t mutex; 1086 pthread_cond_t cond; 1087 uint32_t comp_events_completed; 1088 uint32_t async_events_completed; 1089 1090 uint32_t comp_mask; 1091 enum ibv_wc_status status; 1092 uint64_t wr_id; 1093 int (*start_poll)(struct ibv_cq_ex *current, 1094 struct ibv_poll_cq_attr *attr); 1095 int (*next_poll)(struct ibv_cq_ex *current); 1096 void (*end_poll)(struct ibv_cq_ex *current); 1097 enum ibv_wc_opcode (*read_opcode)(struct ibv_cq_ex *current); 1098 uint32_t (*read_vendor_err)(struct ibv_cq_ex *current); 1099 uint32_t (*read_byte_len)(struct ibv_cq_ex *current); 1100 uint32_t (*read_imm_data)(struct ibv_cq_ex *current); 1101 uint32_t (*read_qp_num)(struct ibv_cq_ex *current); 1102 uint32_t (*read_src_qp)(struct ibv_cq_ex *current); 1103 int (*read_wc_flags)(struct ibv_cq_ex *current); 1104 uint32_t (*read_slid)(struct ibv_cq_ex *current); 1105 uint8_t (*read_sl)(struct ibv_cq_ex *current); 1106 uint8_t (*read_dlid_path_bits)(struct ibv_cq_ex *current); 1107 uint64_t (*read_completion_ts)(struct ibv_cq_ex *current); 1108 uint16_t (*read_cvlan)(struct ibv_cq_ex *current); 1109 uint32_t (*read_flow_tag)(struct ibv_cq_ex *current); 1110 }; 1111 1112 static inline struct ibv_cq *ibv_cq_ex_to_cq(struct ibv_cq_ex *cq) 1113 { 1114 return (struct ibv_cq *)cq; 1115 } 1116 1117 static inline int ibv_start_poll(struct ibv_cq_ex *cq, 1118 struct ibv_poll_cq_attr *attr) 1119 { 1120 return cq->start_poll(cq, attr); 1121 } 1122 1123 static inline int ibv_next_poll(struct ibv_cq_ex *cq) 1124 { 1125 return cq->next_poll(cq); 1126 } 1127 1128 static inline void ibv_end_poll(struct ibv_cq_ex *cq) 1129 { 1130 cq->end_poll(cq); 1131 } 1132 1133 static inline enum ibv_wc_opcode ibv_wc_read_opcode(struct ibv_cq_ex *cq) 1134 { 1135 return cq->read_opcode(cq); 1136 } 1137 1138 static inline uint32_t ibv_wc_read_vendor_err(struct ibv_cq_ex *cq) 1139 { 1140 return cq->read_vendor_err(cq); 1141 } 1142 1143 static inline uint32_t ibv_wc_read_byte_len(struct ibv_cq_ex *cq) 1144 { 1145 return cq->read_byte_len(cq); 1146 } 1147 1148 static inline uint32_t ibv_wc_read_imm_data(struct ibv_cq_ex *cq) 1149 { 1150 return cq->read_imm_data(cq); 1151 } 1152 1153 static inline uint32_t ibv_wc_read_qp_num(struct ibv_cq_ex *cq) 1154 { 1155 return cq->read_qp_num(cq); 1156 } 1157 1158 static inline uint32_t ibv_wc_read_src_qp(struct ibv_cq_ex *cq) 1159 { 1160 return cq->read_src_qp(cq); 1161 } 1162 1163 static inline int ibv_wc_read_wc_flags(struct ibv_cq_ex *cq) 1164 { 1165 return cq->read_wc_flags(cq); 1166 } 1167 1168 static inline uint32_t ibv_wc_read_slid(struct ibv_cq_ex *cq) 1169 { 1170 return cq->read_slid(cq); 1171 } 1172 1173 static inline uint8_t ibv_wc_read_sl(struct ibv_cq_ex *cq) 1174 { 1175 return cq->read_sl(cq); 1176 } 1177 1178 static inline uint8_t ibv_wc_read_dlid_path_bits(struct ibv_cq_ex *cq) 1179 { 1180 return cq->read_dlid_path_bits(cq); 1181 } 1182 1183 static inline uint64_t ibv_wc_read_completion_ts(struct ibv_cq_ex *cq) 1184 { 1185 return cq->read_completion_ts(cq); 1186 } 1187 1188 static inline uint16_t ibv_wc_read_cvlan(struct ibv_cq_ex *cq) 1189 { 1190 return cq->read_cvlan(cq); 1191 } 1192 1193 static inline uint32_t ibv_wc_read_flow_tag(struct ibv_cq_ex *cq) 1194 { 1195 return cq->read_flow_tag(cq); 1196 } 1197 1198 static inline int ibv_post_wq_recv(struct ibv_wq *wq, 1199 struct ibv_recv_wr *recv_wr, 1200 struct ibv_recv_wr **bad_recv_wr) 1201 { 1202 return wq->post_recv(wq, recv_wr, bad_recv_wr); 1203 } 1204 1205 struct ibv_ah { 1206 struct ibv_context *context; 1207 struct ibv_pd *pd; 1208 uint32_t handle; 1209 }; 1210 1211 enum ibv_flow_flags { 1212 IBV_FLOW_ATTR_FLAGS_ALLOW_LOOP_BACK = 1 << 0, 1213 IBV_FLOW_ATTR_FLAGS_DONT_TRAP = 1 << 1, 1214 }; 1215 1216 enum ibv_flow_attr_type { 1217 /* steering according to rule specifications */ 1218 IBV_FLOW_ATTR_NORMAL = 0x0, 1219 /* default unicast and multicast rule - 1220 * receive all Eth traffic which isn't steered to any QP 1221 */ 1222 IBV_FLOW_ATTR_ALL_DEFAULT = 0x1, 1223 /* default multicast rule - 1224 * receive all Eth multicast traffic which isn't steered to any QP 1225 */ 1226 IBV_FLOW_ATTR_MC_DEFAULT = 0x2, 1227 /* sniffer rule - receive all port traffic */ 1228 IBV_FLOW_ATTR_SNIFFER = 0x3, 1229 }; 1230 1231 enum ibv_flow_spec_type { 1232 IBV_FLOW_SPEC_ETH = 0x20, 1233 IBV_FLOW_SPEC_IPV4 = 0x30, 1234 IBV_FLOW_SPEC_IPV6 = 0x31, 1235 IBV_FLOW_SPEC_IPV4_EXT = 0x32, 1236 IBV_FLOW_SPEC_TCP = 0x40, 1237 IBV_FLOW_SPEC_UDP = 0x41, 1238 IBV_FLOW_SPEC_VXLAN_TUNNEL = 0x50, 1239 IBV_FLOW_SPEC_INNER = 0x100, 1240 IBV_FLOW_SPEC_ACTION_TAG = 0x1000, 1241 IBV_FLOW_SPEC_ACTION_DROP = 0x1001, 1242 }; 1243 1244 struct ibv_flow_eth_filter { 1245 uint8_t dst_mac[6]; 1246 uint8_t src_mac[6]; 1247 uint16_t ether_type; 1248 /* 1249 * same layout as 802.1q: prio 3, cfi 1, vlan id 12 1250 */ 1251 uint16_t vlan_tag; 1252 }; 1253 1254 struct ibv_flow_spec_eth { 1255 enum ibv_flow_spec_type type; 1256 uint16_t size; 1257 struct ibv_flow_eth_filter val; 1258 struct ibv_flow_eth_filter mask; 1259 }; 1260 1261 struct ibv_flow_ipv4_filter { 1262 uint32_t src_ip; 1263 uint32_t dst_ip; 1264 }; 1265 1266 struct ibv_flow_spec_ipv4 { 1267 enum ibv_flow_spec_type type; 1268 uint16_t size; 1269 struct ibv_flow_ipv4_filter val; 1270 struct ibv_flow_ipv4_filter mask; 1271 }; 1272 1273 struct ibv_flow_ipv4_ext_filter { 1274 uint32_t src_ip; 1275 uint32_t dst_ip; 1276 uint8_t proto; 1277 uint8_t tos; 1278 uint8_t ttl; 1279 uint8_t flags; 1280 }; 1281 1282 struct ibv_flow_spec_ipv4_ext { 1283 enum ibv_flow_spec_type type; 1284 uint16_t size; 1285 struct ibv_flow_ipv4_ext_filter val; 1286 struct ibv_flow_ipv4_ext_filter mask; 1287 }; 1288 1289 struct ibv_flow_ipv6_filter { 1290 uint8_t src_ip[16]; 1291 uint8_t dst_ip[16]; 1292 uint32_t flow_label; 1293 uint8_t next_hdr; 1294 uint8_t traffic_class; 1295 uint8_t hop_limit; 1296 }; 1297 1298 struct ibv_flow_spec_ipv6 { 1299 enum ibv_flow_spec_type type; 1300 uint16_t size; 1301 struct ibv_flow_ipv6_filter val; 1302 struct ibv_flow_ipv6_filter mask; 1303 }; 1304 1305 struct ibv_flow_tcp_udp_filter { 1306 uint16_t dst_port; 1307 uint16_t src_port; 1308 }; 1309 1310 struct ibv_flow_spec_tcp_udp { 1311 enum ibv_flow_spec_type type; 1312 uint16_t size; 1313 struct ibv_flow_tcp_udp_filter val; 1314 struct ibv_flow_tcp_udp_filter mask; 1315 }; 1316 1317 struct ibv_flow_tunnel_filter { 1318 uint32_t tunnel_id; 1319 }; 1320 1321 struct ibv_flow_spec_tunnel { 1322 enum ibv_flow_spec_type type; 1323 uint16_t size; 1324 struct ibv_flow_tunnel_filter val; 1325 struct ibv_flow_tunnel_filter mask; 1326 }; 1327 1328 struct ibv_flow_spec_action_tag { 1329 enum ibv_flow_spec_type type; 1330 uint16_t size; 1331 uint32_t tag_id; 1332 }; 1333 1334 struct ibv_flow_spec_action_drop { 1335 enum ibv_flow_spec_type type; 1336 uint16_t size; 1337 }; 1338 1339 struct ibv_flow_spec { 1340 union { 1341 struct { 1342 enum ibv_flow_spec_type type; 1343 uint16_t size; 1344 } hdr; 1345 struct ibv_flow_spec_eth eth; 1346 struct ibv_flow_spec_ipv4 ipv4; 1347 struct ibv_flow_spec_tcp_udp tcp_udp; 1348 struct ibv_flow_spec_ipv4_ext ipv4_ext; 1349 struct ibv_flow_spec_ipv6 ipv6; 1350 struct ibv_flow_spec_tunnel tunnel; 1351 struct ibv_flow_spec_action_tag flow_tag; 1352 struct ibv_flow_spec_action_drop drop; 1353 }; 1354 }; 1355 1356 struct ibv_flow_attr { 1357 uint32_t comp_mask; 1358 enum ibv_flow_attr_type type; 1359 uint16_t size; 1360 uint16_t priority; 1361 uint8_t num_of_specs; 1362 uint8_t port; 1363 uint32_t flags; 1364 /* Following are the optional layers according to user request 1365 * struct ibv_flow_spec_xxx [L2] 1366 * struct ibv_flow_spec_yyy [L3/L4] 1367 */ 1368 }; 1369 1370 struct ibv_flow { 1371 uint32_t comp_mask; 1372 struct ibv_context *context; 1373 uint32_t handle; 1374 }; 1375 1376 struct ibv_device; 1377 struct ibv_context; 1378 1379 /* Obsolete, never used, do not touch */ 1380 struct _ibv_device_ops { 1381 struct ibv_context * (*_dummy1)(struct ibv_device *device, int cmd_fd); 1382 void (*_dummy2)(struct ibv_context *context); 1383 }; 1384 1385 enum { 1386 IBV_SYSFS_NAME_MAX = 64, 1387 IBV_SYSFS_PATH_MAX = 256 1388 }; 1389 1390 struct ibv_device { 1391 struct _ibv_device_ops _ops; 1392 enum ibv_node_type node_type; 1393 enum ibv_transport_type transport_type; 1394 /* Name of underlying kernel IB device, eg "mthca0" */ 1395 char name[IBV_SYSFS_NAME_MAX]; 1396 /* Name of uverbs device, eg "uverbs0" */ 1397 char dev_name[IBV_SYSFS_NAME_MAX]; 1398 /* Path to infiniband_verbs class device in sysfs */ 1399 char dev_path[IBV_SYSFS_PATH_MAX]; 1400 /* Path to infiniband class device in sysfs */ 1401 char ibdev_path[IBV_SYSFS_PATH_MAX]; 1402 }; 1403 1404 struct ibv_context_ops { 1405 int (*query_device)(struct ibv_context *context, 1406 struct ibv_device_attr *device_attr); 1407 int (*query_port)(struct ibv_context *context, uint8_t port_num, 1408 struct ibv_port_attr *port_attr); 1409 struct ibv_pd * (*alloc_pd)(struct ibv_context *context); 1410 int (*dealloc_pd)(struct ibv_pd *pd); 1411 struct ibv_mr * (*reg_mr)(struct ibv_pd *pd, void *addr, size_t length, 1412 int access); 1413 int (*rereg_mr)(struct ibv_mr *mr, 1414 int flags, 1415 struct ibv_pd *pd, void *addr, 1416 size_t length, 1417 int access); 1418 int (*dereg_mr)(struct ibv_mr *mr); 1419 struct ibv_mw * (*alloc_mw)(struct ibv_pd *pd, enum ibv_mw_type type); 1420 int (*bind_mw)(struct ibv_qp *qp, struct ibv_mw *mw, 1421 struct ibv_mw_bind *mw_bind); 1422 int (*dealloc_mw)(struct ibv_mw *mw); 1423 struct ibv_cq * (*create_cq)(struct ibv_context *context, int cqe, 1424 struct ibv_comp_channel *channel, 1425 int comp_vector); 1426 int (*poll_cq)(struct ibv_cq *cq, int num_entries, struct ibv_wc *wc); 1427 int (*req_notify_cq)(struct ibv_cq *cq, int solicited_only); 1428 void (*cq_event)(struct ibv_cq *cq); 1429 int (*resize_cq)(struct ibv_cq *cq, int cqe); 1430 int (*destroy_cq)(struct ibv_cq *cq); 1431 struct ibv_srq * (*create_srq)(struct ibv_pd *pd, 1432 struct ibv_srq_init_attr *srq_init_attr); 1433 int (*modify_srq)(struct ibv_srq *srq, 1434 struct ibv_srq_attr *srq_attr, 1435 int srq_attr_mask); 1436 int (*query_srq)(struct ibv_srq *srq, 1437 struct ibv_srq_attr *srq_attr); 1438 int (*destroy_srq)(struct ibv_srq *srq); 1439 int (*post_srq_recv)(struct ibv_srq *srq, 1440 struct ibv_recv_wr *recv_wr, 1441 struct ibv_recv_wr **bad_recv_wr); 1442 struct ibv_qp * (*create_qp)(struct ibv_pd *pd, struct ibv_qp_init_attr *attr); 1443 int (*query_qp)(struct ibv_qp *qp, struct ibv_qp_attr *attr, 1444 int attr_mask, 1445 struct ibv_qp_init_attr *init_attr); 1446 int (*modify_qp)(struct ibv_qp *qp, struct ibv_qp_attr *attr, 1447 int attr_mask); 1448 int (*destroy_qp)(struct ibv_qp *qp); 1449 int (*post_send)(struct ibv_qp *qp, struct ibv_send_wr *wr, 1450 struct ibv_send_wr **bad_wr); 1451 int (*post_recv)(struct ibv_qp *qp, struct ibv_recv_wr *wr, 1452 struct ibv_recv_wr **bad_wr); 1453 struct ibv_ah * (*create_ah)(struct ibv_pd *pd, struct ibv_ah_attr *attr); 1454 int (*destroy_ah)(struct ibv_ah *ah); 1455 int (*attach_mcast)(struct ibv_qp *qp, const union ibv_gid *gid, 1456 uint16_t lid); 1457 int (*detach_mcast)(struct ibv_qp *qp, const union ibv_gid *gid, 1458 uint16_t lid); 1459 void (*async_event)(struct ibv_async_event *event); 1460 }; 1461 1462 struct ibv_context { 1463 struct ibv_device *device; 1464 struct ibv_context_ops ops; 1465 int cmd_fd; 1466 int async_fd; 1467 int num_comp_vectors; 1468 pthread_mutex_t mutex; 1469 void *abi_compat; 1470 }; 1471 1472 enum ibv_cq_init_attr_mask { 1473 IBV_CQ_INIT_ATTR_MASK_FLAGS = 1 << 0, 1474 IBV_CQ_INIT_ATTR_MASK_RESERVED = 1 << 1 1475 }; 1476 1477 enum ibv_create_cq_attr_flags { 1478 IBV_CREATE_CQ_ATTR_SINGLE_THREADED = 1 << 0, 1479 IBV_CREATE_CQ_ATTR_RESERVED = 1 << 1, 1480 }; 1481 1482 struct ibv_cq_init_attr_ex { 1483 /* Minimum number of entries required for CQ */ 1484 uint32_t cqe; 1485 /* Consumer-supplied context returned for completion events */ 1486 void *cq_context; 1487 /* Completion channel where completion events will be queued. 1488 * May be NULL if completion events will not be used. 1489 */ 1490 struct ibv_comp_channel *channel; 1491 /* Completion vector used to signal completion events. 1492 * Must be < context->num_comp_vectors. 1493 */ 1494 uint32_t comp_vector; 1495 /* Or'ed bit of enum ibv_create_cq_wc_flags. */ 1496 uint64_t wc_flags; 1497 /* compatibility mask (extended verb). Or'd flags of 1498 * enum ibv_cq_init_attr_mask 1499 */ 1500 uint32_t comp_mask; 1501 /* create cq attr flags - one or more flags from 1502 * enum ibv_create_cq_attr_flags 1503 */ 1504 uint32_t flags; 1505 }; 1506 1507 enum ibv_values_mask { 1508 IBV_VALUES_MASK_RAW_CLOCK = 1 << 0, 1509 IBV_VALUES_MASK_RESERVED = 1 << 1 1510 }; 1511 1512 struct ibv_values_ex { 1513 uint32_t comp_mask; 1514 struct timespec raw_clock; 1515 }; 1516 1517 enum verbs_context_mask { 1518 VERBS_CONTEXT_XRCD = 1 << 0, 1519 VERBS_CONTEXT_SRQ = 1 << 1, 1520 VERBS_CONTEXT_QP = 1 << 2, 1521 VERBS_CONTEXT_CREATE_FLOW = 1 << 3, 1522 VERBS_CONTEXT_DESTROY_FLOW = 1 << 4, 1523 VERBS_CONTEXT_RESERVED = 1 << 5 1524 }; 1525 1526 struct verbs_context { 1527 /* "grows up" - new fields go here */ 1528 int (*destroy_rwq_ind_table)(struct ibv_rwq_ind_table *rwq_ind_table); 1529 struct ibv_rwq_ind_table *(*create_rwq_ind_table)(struct ibv_context *context, 1530 struct ibv_rwq_ind_table_init_attr *init_attr); 1531 int (*destroy_wq)(struct ibv_wq *wq); 1532 int (*modify_wq)(struct ibv_wq *wq, struct ibv_wq_attr *wq_attr); 1533 struct ibv_wq * (*create_wq)(struct ibv_context *context, 1534 struct ibv_wq_init_attr *wq_init_attr); 1535 int (*query_rt_values)(struct ibv_context *context, 1536 struct ibv_values_ex *values); 1537 struct ibv_cq_ex *(*create_cq_ex)(struct ibv_context *context, 1538 struct ibv_cq_init_attr_ex *init_attr); 1539 struct verbs_ex_private *priv; 1540 int (*query_device_ex)(struct ibv_context *context, 1541 const struct ibv_query_device_ex_input *input, 1542 struct ibv_device_attr_ex *attr, 1543 size_t attr_size); 1544 int (*ibv_destroy_flow) (struct ibv_flow *flow); 1545 void (*ABI_placeholder2) (void); /* DO NOT COPY THIS GARBAGE */ 1546 struct ibv_flow * (*ibv_create_flow) (struct ibv_qp *qp, 1547 struct ibv_flow_attr *flow_attr); 1548 void (*ABI_placeholder1) (void); /* DO NOT COPY THIS GARBAGE */ 1549 struct ibv_qp *(*open_qp)(struct ibv_context *context, 1550 struct ibv_qp_open_attr *attr); 1551 struct ibv_qp *(*create_qp_ex)(struct ibv_context *context, 1552 struct ibv_qp_init_attr_ex *qp_init_attr_ex); 1553 int (*get_srq_num)(struct ibv_srq *srq, uint32_t *srq_num); 1554 struct ibv_srq * (*create_srq_ex)(struct ibv_context *context, 1555 struct ibv_srq_init_attr_ex *srq_init_attr_ex); 1556 struct ibv_xrcd * (*open_xrcd)(struct ibv_context *context, 1557 struct ibv_xrcd_init_attr *xrcd_init_attr); 1558 int (*close_xrcd)(struct ibv_xrcd *xrcd); 1559 uint64_t has_comp_mask; 1560 size_t sz; /* Must be immediately before struct ibv_context */ 1561 struct ibv_context context; /* Must be last field in the struct */ 1562 }; 1563 1564 static inline struct verbs_context *verbs_get_ctx(struct ibv_context *ctx) 1565 { 1566 return (ctx->abi_compat != __VERBS_ABI_IS_EXTENDED) ? 1567 NULL : container_of(ctx, struct verbs_context, context); 1568 } 1569 1570 #define verbs_get_ctx_op(ctx, op) ({ \ 1571 struct verbs_context *__vctx = verbs_get_ctx(ctx); \ 1572 (!__vctx || (__vctx->sz < sizeof(*__vctx) - offsetof(struct verbs_context, op)) || \ 1573 !__vctx->op) ? NULL : __vctx; }) 1574 1575 #define verbs_set_ctx_op(_vctx, op, ptr) ({ \ 1576 struct verbs_context *vctx = _vctx; \ 1577 if (vctx && (vctx->sz >= sizeof(*vctx) - offsetof(struct verbs_context, op))) \ 1578 vctx->op = ptr; }) 1579 1580 /** 1581 * ibv_get_device_list - Get list of IB devices currently available 1582 * @num_devices: optional. if non-NULL, set to the number of devices 1583 * returned in the array. 1584 * 1585 * Return a NULL-terminated array of IB devices. The array can be 1586 * released with ibv_free_device_list(). 1587 */ 1588 struct ibv_device **ibv_get_device_list(int *num_devices); 1589 1590 /** 1591 * ibv_free_device_list - Free list from ibv_get_device_list() 1592 * 1593 * Free an array of devices returned from ibv_get_device_list(). Once 1594 * the array is freed, pointers to devices that were not opened with 1595 * ibv_open_device() are no longer valid. Client code must open all 1596 * devices it intends to use before calling ibv_free_device_list(). 1597 */ 1598 void ibv_free_device_list(struct ibv_device **list); 1599 1600 /** 1601 * ibv_get_device_name - Return kernel device name 1602 */ 1603 const char *ibv_get_device_name(struct ibv_device *device); 1604 1605 /** 1606 * ibv_get_device_guid - Return device's node GUID 1607 */ 1608 __be64 ibv_get_device_guid(struct ibv_device *device); 1609 1610 /** 1611 * ibv_open_device - Initialize device for use 1612 */ 1613 struct ibv_context *ibv_open_device(struct ibv_device *device); 1614 1615 /** 1616 * ibv_close_device - Release device 1617 */ 1618 int ibv_close_device(struct ibv_context *context); 1619 1620 /** 1621 * ibv_get_async_event - Get next async event 1622 * @event: Pointer to use to return async event 1623 * 1624 * All async events returned by ibv_get_async_event() must eventually 1625 * be acknowledged with ibv_ack_async_event(). 1626 */ 1627 int ibv_get_async_event(struct ibv_context *context, 1628 struct ibv_async_event *event); 1629 1630 /** 1631 * ibv_ack_async_event - Acknowledge an async event 1632 * @event: Event to be acknowledged. 1633 * 1634 * All async events which are returned by ibv_get_async_event() must 1635 * be acknowledged. To avoid races, destroying an object (CQ, SRQ or 1636 * QP) will wait for all affiliated events to be acknowledged, so 1637 * there should be a one-to-one correspondence between acks and 1638 * successful gets. 1639 */ 1640 void ibv_ack_async_event(struct ibv_async_event *event); 1641 1642 /** 1643 * ibv_query_device - Get device properties 1644 */ 1645 int ibv_query_device(struct ibv_context *context, 1646 struct ibv_device_attr *device_attr); 1647 1648 /** 1649 * ibv_query_port - Get port properties 1650 */ 1651 int ibv_query_port(struct ibv_context *context, uint8_t port_num, 1652 struct ibv_port_attr *port_attr); 1653 1654 static inline int ___ibv_query_port(struct ibv_context *context, 1655 uint8_t port_num, 1656 struct ibv_port_attr *port_attr) 1657 { 1658 /* For compatibility when running with old libibverbs */ 1659 port_attr->link_layer = IBV_LINK_LAYER_UNSPECIFIED; 1660 port_attr->reserved = 0; 1661 1662 return ibv_query_port(context, port_num, port_attr); 1663 } 1664 1665 #define ibv_query_port(context, port_num, port_attr) \ 1666 ___ibv_query_port(context, port_num, port_attr) 1667 1668 /** 1669 * ibv_query_gid - Get a GID table entry 1670 */ 1671 int ibv_query_gid(struct ibv_context *context, uint8_t port_num, 1672 int index, union ibv_gid *gid); 1673 1674 /** 1675 * ibv_query_pkey - Get a P_Key table entry 1676 */ 1677 int ibv_query_pkey(struct ibv_context *context, uint8_t port_num, 1678 int index, __be16 *pkey); 1679 1680 /** 1681 * ibv_alloc_pd - Allocate a protection domain 1682 */ 1683 struct ibv_pd *ibv_alloc_pd(struct ibv_context *context); 1684 1685 /** 1686 * ibv_dealloc_pd - Free a protection domain 1687 */ 1688 int ibv_dealloc_pd(struct ibv_pd *pd); 1689 1690 static inline struct ibv_flow *ibv_create_flow(struct ibv_qp *qp, 1691 struct ibv_flow_attr *flow) 1692 { 1693 struct verbs_context *vctx = verbs_get_ctx_op(qp->context, 1694 ibv_create_flow); 1695 if (!vctx || !vctx->ibv_create_flow) { 1696 errno = ENOSYS; 1697 return NULL; 1698 } 1699 1700 return vctx->ibv_create_flow(qp, flow); 1701 } 1702 1703 static inline int ibv_destroy_flow(struct ibv_flow *flow_id) 1704 { 1705 struct verbs_context *vctx = verbs_get_ctx_op(flow_id->context, 1706 ibv_destroy_flow); 1707 if (!vctx || !vctx->ibv_destroy_flow) 1708 return -ENOSYS; 1709 return vctx->ibv_destroy_flow(flow_id); 1710 } 1711 1712 /** 1713 * ibv_open_xrcd - Open an extended connection domain 1714 */ 1715 static inline struct ibv_xrcd * 1716 ibv_open_xrcd(struct ibv_context *context, struct ibv_xrcd_init_attr *xrcd_init_attr) 1717 { 1718 struct verbs_context *vctx = verbs_get_ctx_op(context, open_xrcd); 1719 if (!vctx) { 1720 errno = ENOSYS; 1721 return NULL; 1722 } 1723 return vctx->open_xrcd(context, xrcd_init_attr); 1724 } 1725 1726 /** 1727 * ibv_close_xrcd - Close an extended connection domain 1728 */ 1729 static inline int ibv_close_xrcd(struct ibv_xrcd *xrcd) 1730 { 1731 struct verbs_context *vctx = verbs_get_ctx(xrcd->context); 1732 return vctx->close_xrcd(xrcd); 1733 } 1734 1735 /** 1736 * ibv_reg_mr - Register a memory region 1737 */ 1738 struct ibv_mr *ibv_reg_mr(struct ibv_pd *pd, void *addr, 1739 size_t length, int access); 1740 1741 1742 enum ibv_rereg_mr_err_code { 1743 /* Old MR is valid, invalid input */ 1744 IBV_REREG_MR_ERR_INPUT = -1, 1745 /* Old MR is valid, failed via don't fork on new address range */ 1746 IBV_REREG_MR_ERR_DONT_FORK_NEW = -2, 1747 /* New MR is valid, failed via do fork on old address range */ 1748 IBV_REREG_MR_ERR_DO_FORK_OLD = -3, 1749 /* MR shouldn't be used, command error */ 1750 IBV_REREG_MR_ERR_CMD = -4, 1751 /* MR shouldn't be used, command error, invalid fork state on new address range */ 1752 IBV_REREG_MR_ERR_CMD_AND_DO_FORK_NEW = -5, 1753 }; 1754 1755 /** 1756 * ibv_rereg_mr - Re-Register a memory region 1757 */ 1758 int ibv_rereg_mr(struct ibv_mr *mr, int flags, 1759 struct ibv_pd *pd, void *addr, 1760 size_t length, int access); 1761 /** 1762 * ibv_dereg_mr - Deregister a memory region 1763 */ 1764 int ibv_dereg_mr(struct ibv_mr *mr); 1765 1766 /** 1767 * ibv_alloc_mw - Allocate a memory window 1768 */ 1769 static inline struct ibv_mw *ibv_alloc_mw(struct ibv_pd *pd, 1770 enum ibv_mw_type type) 1771 { 1772 struct ibv_mw *mw; 1773 1774 if (!pd->context->ops.alloc_mw) { 1775 errno = ENOSYS; 1776 return NULL; 1777 } 1778 1779 mw = pd->context->ops.alloc_mw(pd, type); 1780 return mw; 1781 } 1782 1783 /** 1784 * ibv_dealloc_mw - Free a memory window 1785 */ 1786 static inline int ibv_dealloc_mw(struct ibv_mw *mw) 1787 { 1788 return mw->context->ops.dealloc_mw(mw); 1789 } 1790 1791 /** 1792 * ibv_inc_rkey - Increase the 8 lsb in the given rkey 1793 */ 1794 static inline uint32_t ibv_inc_rkey(uint32_t rkey) 1795 { 1796 const uint32_t mask = 0x000000ff; 1797 uint8_t newtag = (uint8_t)((rkey + 1) & mask); 1798 1799 return (rkey & ~mask) | newtag; 1800 } 1801 1802 /** 1803 * ibv_bind_mw - Bind a memory window to a region 1804 */ 1805 static inline int ibv_bind_mw(struct ibv_qp *qp, struct ibv_mw *mw, 1806 struct ibv_mw_bind *mw_bind) 1807 { 1808 if (mw->type != IBV_MW_TYPE_1) 1809 return EINVAL; 1810 1811 return mw->context->ops.bind_mw(qp, mw, mw_bind); 1812 } 1813 1814 /** 1815 * ibv_create_comp_channel - Create a completion event channel 1816 */ 1817 struct ibv_comp_channel *ibv_create_comp_channel(struct ibv_context *context); 1818 1819 /** 1820 * ibv_destroy_comp_channel - Destroy a completion event channel 1821 */ 1822 int ibv_destroy_comp_channel(struct ibv_comp_channel *channel); 1823 1824 /** 1825 * ibv_create_cq - Create a completion queue 1826 * @context - Context CQ will be attached to 1827 * @cqe - Minimum number of entries required for CQ 1828 * @cq_context - Consumer-supplied context returned for completion events 1829 * @channel - Completion channel where completion events will be queued. 1830 * May be NULL if completion events will not be used. 1831 * @comp_vector - Completion vector used to signal completion events. 1832 * Must be >= 0 and < context->num_comp_vectors. 1833 */ 1834 struct ibv_cq *ibv_create_cq(struct ibv_context *context, int cqe, 1835 void *cq_context, 1836 struct ibv_comp_channel *channel, 1837 int comp_vector); 1838 1839 /** 1840 * ibv_create_cq_ex - Create a completion queue 1841 * @context - Context CQ will be attached to 1842 * @cq_attr - Attributes to create the CQ with 1843 */ 1844 static inline 1845 struct ibv_cq_ex *ibv_create_cq_ex(struct ibv_context *context, 1846 struct ibv_cq_init_attr_ex *cq_attr) 1847 { 1848 struct verbs_context *vctx = verbs_get_ctx_op(context, create_cq_ex); 1849 1850 if (!vctx) { 1851 errno = ENOSYS; 1852 return NULL; 1853 } 1854 1855 if (cq_attr->comp_mask & ~(IBV_CQ_INIT_ATTR_MASK_RESERVED - 1)) { 1856 errno = EINVAL; 1857 return NULL; 1858 } 1859 1860 return vctx->create_cq_ex(context, cq_attr); 1861 } 1862 1863 /** 1864 * ibv_resize_cq - Modifies the capacity of the CQ. 1865 * @cq: The CQ to resize. 1866 * @cqe: The minimum size of the CQ. 1867 * 1868 * Users can examine the cq structure to determine the actual CQ size. 1869 */ 1870 int ibv_resize_cq(struct ibv_cq *cq, int cqe); 1871 1872 /** 1873 * ibv_destroy_cq - Destroy a completion queue 1874 */ 1875 int ibv_destroy_cq(struct ibv_cq *cq); 1876 1877 /** 1878 * ibv_get_cq_event - Read next CQ event 1879 * @channel: Channel to get next event from. 1880 * @cq: Used to return pointer to CQ. 1881 * @cq_context: Used to return consumer-supplied CQ context. 1882 * 1883 * All completion events returned by ibv_get_cq_event() must 1884 * eventually be acknowledged with ibv_ack_cq_events(). 1885 */ 1886 int ibv_get_cq_event(struct ibv_comp_channel *channel, 1887 struct ibv_cq **cq, void **cq_context); 1888 1889 /** 1890 * ibv_ack_cq_events - Acknowledge CQ completion events 1891 * @cq: CQ to acknowledge events for 1892 * @nevents: Number of events to acknowledge. 1893 * 1894 * All completion events which are returned by ibv_get_cq_event() must 1895 * be acknowledged. To avoid races, ibv_destroy_cq() will wait for 1896 * all completion events to be acknowledged, so there should be a 1897 * one-to-one correspondence between acks and successful gets. An 1898 * application may accumulate multiple completion events and 1899 * acknowledge them in a single call to ibv_ack_cq_events() by passing 1900 * the number of events to ack in @nevents. 1901 */ 1902 void ibv_ack_cq_events(struct ibv_cq *cq, unsigned int nevents); 1903 1904 /** 1905 * ibv_poll_cq - Poll a CQ for work completions 1906 * @cq:the CQ being polled 1907 * @num_entries:maximum number of completions to return 1908 * @wc:array of at least @num_entries of &struct ibv_wc where completions 1909 * will be returned 1910 * 1911 * Poll a CQ for (possibly multiple) completions. If the return value 1912 * is < 0, an error occurred. If the return value is >= 0, it is the 1913 * number of completions returned. If the return value is 1914 * non-negative and strictly less than num_entries, then the CQ was 1915 * emptied. 1916 */ 1917 static inline int ibv_poll_cq(struct ibv_cq *cq, int num_entries, struct ibv_wc *wc) 1918 { 1919 return cq->context->ops.poll_cq(cq, num_entries, wc); 1920 } 1921 1922 /** 1923 * ibv_req_notify_cq - Request completion notification on a CQ. An 1924 * event will be added to the completion channel associated with the 1925 * CQ when an entry is added to the CQ. 1926 * @cq: The completion queue to request notification for. 1927 * @solicited_only: If non-zero, an event will be generated only for 1928 * the next solicited CQ entry. If zero, any CQ entry, solicited or 1929 * not, will generate an event. 1930 */ 1931 static inline int ibv_req_notify_cq(struct ibv_cq *cq, int solicited_only) 1932 { 1933 return cq->context->ops.req_notify_cq(cq, solicited_only); 1934 } 1935 1936 /** 1937 * ibv_create_srq - Creates a SRQ associated with the specified protection 1938 * domain. 1939 * @pd: The protection domain associated with the SRQ. 1940 * @srq_init_attr: A list of initial attributes required to create the SRQ. 1941 * 1942 * srq_attr->max_wr and srq_attr->max_sge are read the determine the 1943 * requested size of the SRQ, and set to the actual values allocated 1944 * on return. If ibv_create_srq() succeeds, then max_wr and max_sge 1945 * will always be at least as large as the requested values. 1946 */ 1947 struct ibv_srq *ibv_create_srq(struct ibv_pd *pd, 1948 struct ibv_srq_init_attr *srq_init_attr); 1949 1950 static inline struct ibv_srq * 1951 ibv_create_srq_ex(struct ibv_context *context, 1952 struct ibv_srq_init_attr_ex *srq_init_attr_ex) 1953 { 1954 struct verbs_context *vctx; 1955 uint32_t mask = srq_init_attr_ex->comp_mask; 1956 1957 if (!(mask & ~(IBV_SRQ_INIT_ATTR_PD | IBV_SRQ_INIT_ATTR_TYPE)) && 1958 (mask & IBV_SRQ_INIT_ATTR_PD) && 1959 (!(mask & IBV_SRQ_INIT_ATTR_TYPE) || 1960 (srq_init_attr_ex->srq_type == IBV_SRQT_BASIC))) 1961 return ibv_create_srq(srq_init_attr_ex->pd, 1962 (struct ibv_srq_init_attr *)srq_init_attr_ex); 1963 1964 vctx = verbs_get_ctx_op(context, create_srq_ex); 1965 if (!vctx) { 1966 errno = ENOSYS; 1967 return NULL; 1968 } 1969 return vctx->create_srq_ex(context, srq_init_attr_ex); 1970 } 1971 1972 /** 1973 * ibv_modify_srq - Modifies the attributes for the specified SRQ. 1974 * @srq: The SRQ to modify. 1975 * @srq_attr: On input, specifies the SRQ attributes to modify. On output, 1976 * the current values of selected SRQ attributes are returned. 1977 * @srq_attr_mask: A bit-mask used to specify which attributes of the SRQ 1978 * are being modified. 1979 * 1980 * The mask may contain IBV_SRQ_MAX_WR to resize the SRQ and/or 1981 * IBV_SRQ_LIMIT to set the SRQ's limit and request notification when 1982 * the number of receives queued drops below the limit. 1983 */ 1984 int ibv_modify_srq(struct ibv_srq *srq, 1985 struct ibv_srq_attr *srq_attr, 1986 int srq_attr_mask); 1987 1988 /** 1989 * ibv_query_srq - Returns the attribute list and current values for the 1990 * specified SRQ. 1991 * @srq: The SRQ to query. 1992 * @srq_attr: The attributes of the specified SRQ. 1993 */ 1994 int ibv_query_srq(struct ibv_srq *srq, struct ibv_srq_attr *srq_attr); 1995 1996 static inline int ibv_get_srq_num(struct ibv_srq *srq, uint32_t *srq_num) 1997 { 1998 struct verbs_context *vctx = verbs_get_ctx_op(srq->context, get_srq_num); 1999 2000 if (!vctx) 2001 return ENOSYS; 2002 2003 return vctx->get_srq_num(srq, srq_num); 2004 } 2005 2006 /** 2007 * ibv_destroy_srq - Destroys the specified SRQ. 2008 * @srq: The SRQ to destroy. 2009 */ 2010 int ibv_destroy_srq(struct ibv_srq *srq); 2011 2012 /** 2013 * ibv_post_srq_recv - Posts a list of work requests to the specified SRQ. 2014 * @srq: The SRQ to post the work request on. 2015 * @recv_wr: A list of work requests to post on the receive queue. 2016 * @bad_recv_wr: On an immediate failure, this parameter will reference 2017 * the work request that failed to be posted on the QP. 2018 */ 2019 static inline int ibv_post_srq_recv(struct ibv_srq *srq, 2020 struct ibv_recv_wr *recv_wr, 2021 struct ibv_recv_wr **bad_recv_wr) 2022 { 2023 return srq->context->ops.post_srq_recv(srq, recv_wr, bad_recv_wr); 2024 } 2025 2026 /** 2027 * ibv_create_qp - Create a queue pair. 2028 */ 2029 struct ibv_qp *ibv_create_qp(struct ibv_pd *pd, 2030 struct ibv_qp_init_attr *qp_init_attr); 2031 2032 static inline struct ibv_qp * 2033 ibv_create_qp_ex(struct ibv_context *context, struct ibv_qp_init_attr_ex *qp_init_attr_ex) 2034 { 2035 struct verbs_context *vctx; 2036 uint32_t mask = qp_init_attr_ex->comp_mask; 2037 2038 if (mask == IBV_QP_INIT_ATTR_PD) 2039 return ibv_create_qp(qp_init_attr_ex->pd, 2040 (struct ibv_qp_init_attr *)qp_init_attr_ex); 2041 2042 vctx = verbs_get_ctx_op(context, create_qp_ex); 2043 if (!vctx) { 2044 errno = ENOSYS; 2045 return NULL; 2046 } 2047 return vctx->create_qp_ex(context, qp_init_attr_ex); 2048 } 2049 2050 /** 2051 * ibv_query_rt_values_ex - Get current real time @values of a device. 2052 * @values - in/out - defines the attributes we need to query/queried. 2053 * (Or's bits of enum ibv_values_mask on values->comp_mask field) 2054 */ 2055 static inline int 2056 ibv_query_rt_values_ex(struct ibv_context *context, 2057 struct ibv_values_ex *values) 2058 { 2059 struct verbs_context *vctx; 2060 2061 vctx = verbs_get_ctx_op(context, query_rt_values); 2062 if (!vctx) 2063 return ENOSYS; 2064 2065 if (values->comp_mask & ~(IBV_VALUES_MASK_RESERVED - 1)) 2066 return EINVAL; 2067 2068 return vctx->query_rt_values(context, values); 2069 } 2070 2071 /** 2072 * ibv_query_device_ex - Get extended device properties 2073 */ 2074 static inline int 2075 ibv_query_device_ex(struct ibv_context *context, 2076 const struct ibv_query_device_ex_input *input, 2077 struct ibv_device_attr_ex *attr) 2078 { 2079 struct verbs_context *vctx; 2080 int ret; 2081 2082 vctx = verbs_get_ctx_op(context, query_device_ex); 2083 if (!vctx) 2084 goto legacy; 2085 2086 ret = vctx->query_device_ex(context, input, attr, sizeof(*attr)); 2087 if (ret == ENOSYS) 2088 goto legacy; 2089 2090 return ret; 2091 2092 legacy: 2093 memset(attr, 0, sizeof(*attr)); 2094 ret = ibv_query_device(context, &attr->orig_attr); 2095 2096 return ret; 2097 } 2098 2099 /** 2100 * ibv_open_qp - Open a shareable queue pair. 2101 */ 2102 static inline struct ibv_qp * 2103 ibv_open_qp(struct ibv_context *context, struct ibv_qp_open_attr *qp_open_attr) 2104 { 2105 struct verbs_context *vctx = verbs_get_ctx_op(context, open_qp); 2106 if (!vctx) { 2107 errno = ENOSYS; 2108 return NULL; 2109 } 2110 return vctx->open_qp(context, qp_open_attr); 2111 } 2112 2113 /** 2114 * ibv_modify_qp - Modify a queue pair. 2115 */ 2116 int ibv_modify_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr, 2117 int attr_mask); 2118 2119 /** 2120 * ibv_query_qp - Returns the attribute list and current values for the 2121 * specified QP. 2122 * @qp: The QP to query. 2123 * @attr: The attributes of the specified QP. 2124 * @attr_mask: A bit-mask used to select specific attributes to query. 2125 * @init_attr: Additional attributes of the selected QP. 2126 * 2127 * The qp_attr_mask may be used to limit the query to gathering only the 2128 * selected attributes. 2129 */ 2130 int ibv_query_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr, 2131 int attr_mask, 2132 struct ibv_qp_init_attr *init_attr); 2133 2134 /** 2135 * ibv_destroy_qp - Destroy a queue pair. 2136 */ 2137 int ibv_destroy_qp(struct ibv_qp *qp); 2138 2139 /* 2140 * ibv_create_wq - Creates a WQ associated with the specified protection 2141 * domain. 2142 * @context: ibv_context. 2143 * @wq_init_attr: A list of initial attributes required to create the 2144 * WQ. If WQ creation succeeds, then the attributes are updated to 2145 * the actual capabilities of the created WQ. 2146 * 2147 * wq_init_attr->max_wr and wq_init_attr->max_sge determine 2148 * the requested size of the WQ, and set to the actual values allocated 2149 * on return. 2150 * If ibv_create_wq() succeeds, then max_wr and max_sge will always be 2151 * at least as large as the requested values. 2152 * 2153 * Return Value 2154 * ibv_create_wq() returns a pointer to the created WQ, or NULL if the request 2155 * fails. 2156 */ 2157 static inline struct ibv_wq *ibv_create_wq(struct ibv_context *context, 2158 struct ibv_wq_init_attr *wq_init_attr) 2159 { 2160 struct verbs_context *vctx = verbs_get_ctx_op(context, create_wq); 2161 struct ibv_wq *wq; 2162 2163 if (!vctx) { 2164 errno = ENOSYS; 2165 return NULL; 2166 } 2167 2168 wq = vctx->create_wq(context, wq_init_attr); 2169 if (wq) { 2170 wq->events_completed = 0; 2171 pthread_mutex_init(&wq->mutex, NULL); 2172 pthread_cond_init(&wq->cond, NULL); 2173 } 2174 2175 return wq; 2176 } 2177 2178 /* 2179 * ibv_modify_wq - Modifies the attributes for the specified WQ. 2180 * @wq: The WQ to modify. 2181 * @wq_attr: On input, specifies the WQ attributes to modify. 2182 * wq_attr->attr_mask: A bit-mask used to specify which attributes of the WQ 2183 * are being modified. 2184 * On output, the current values of selected WQ attributes are returned. 2185 * 2186 * Return Value 2187 * ibv_modify_wq() returns 0 on success, or the value of errno 2188 * on failure (which indicates the failure reason). 2189 * 2190 */ 2191 static inline int ibv_modify_wq(struct ibv_wq *wq, struct ibv_wq_attr *wq_attr) 2192 { 2193 struct verbs_context *vctx = verbs_get_ctx_op(wq->context, modify_wq); 2194 2195 if (!vctx) 2196 return ENOSYS; 2197 2198 return vctx->modify_wq(wq, wq_attr); 2199 } 2200 2201 /* 2202 * ibv_destroy_wq - Destroys the specified WQ. 2203 * @ibv_wq: The WQ to destroy. 2204 * Return Value 2205 * ibv_destroy_wq() returns 0 on success, or the value of errno 2206 * on failure (which indicates the failure reason). 2207 */ 2208 static inline int ibv_destroy_wq(struct ibv_wq *wq) 2209 { 2210 struct verbs_context *vctx; 2211 2212 vctx = verbs_get_ctx_op(wq->context, destroy_wq); 2213 if (!vctx) 2214 return ENOSYS; 2215 2216 return vctx->destroy_wq(wq); 2217 } 2218 2219 /* 2220 * ibv_create_rwq_ind_table - Creates a receive work queue Indirection Table 2221 * @context: ibv_context. 2222 * @init_attr: A list of initial attributes required to create the Indirection Table. 2223 * Return Value 2224 * ibv_create_rwq_ind_table returns a pointer to the created 2225 * Indirection Table, or NULL if the request fails. 2226 */ 2227 static inline struct ibv_rwq_ind_table *ibv_create_rwq_ind_table(struct ibv_context *context, 2228 struct ibv_rwq_ind_table_init_attr *init_attr) 2229 { 2230 struct verbs_context *vctx; 2231 2232 vctx = verbs_get_ctx_op(context, create_rwq_ind_table); 2233 if (!vctx) { 2234 errno = ENOSYS; 2235 return NULL; 2236 } 2237 2238 return vctx->create_rwq_ind_table(context, init_attr); 2239 } 2240 2241 /* 2242 * ibv_destroy_rwq_ind_table - Destroys the specified Indirection Table. 2243 * @rwq_ind_table: The Indirection Table to destroy. 2244 * Return Value 2245 * ibv_destroy_rwq_ind_table() returns 0 on success, or the value of errno 2246 * on failure (which indicates the failure reason). 2247 */ 2248 static inline int ibv_destroy_rwq_ind_table(struct ibv_rwq_ind_table *rwq_ind_table) 2249 { 2250 struct verbs_context *vctx; 2251 2252 vctx = verbs_get_ctx_op(rwq_ind_table->context, destroy_rwq_ind_table); 2253 if (!vctx) 2254 return ENOSYS; 2255 2256 return vctx->destroy_rwq_ind_table(rwq_ind_table); 2257 } 2258 2259 /** 2260 * ibv_post_send - Post a list of work requests to a send queue. 2261 * 2262 * If IBV_SEND_INLINE flag is set, the data buffers can be reused 2263 * immediately after the call returns. 2264 */ 2265 static inline int ibv_post_send(struct ibv_qp *qp, struct ibv_send_wr *wr, 2266 struct ibv_send_wr **bad_wr) 2267 { 2268 return qp->context->ops.post_send(qp, wr, bad_wr); 2269 } 2270 2271 /** 2272 * ibv_post_recv - Post a list of work requests to a receive queue. 2273 */ 2274 static inline int ibv_post_recv(struct ibv_qp *qp, struct ibv_recv_wr *wr, 2275 struct ibv_recv_wr **bad_wr) 2276 { 2277 return qp->context->ops.post_recv(qp, wr, bad_wr); 2278 } 2279 2280 /** 2281 * ibv_create_ah - Create an address handle. 2282 */ 2283 struct ibv_ah *ibv_create_ah(struct ibv_pd *pd, struct ibv_ah_attr *attr); 2284 2285 /** 2286 * ibv_init_ah_from_wc - Initializes address handle attributes from a 2287 * work completion. 2288 * @context: Device context on which the received message arrived. 2289 * @port_num: Port on which the received message arrived. 2290 * @wc: Work completion associated with the received message. 2291 * @grh: References the received global route header. This parameter is 2292 * ignored unless the work completion indicates that the GRH is valid. 2293 * @ah_attr: Returned attributes that can be used when creating an address 2294 * handle for replying to the message. 2295 */ 2296 int ibv_init_ah_from_wc(struct ibv_context *context, uint8_t port_num, 2297 struct ibv_wc *wc, struct ibv_grh *grh, 2298 struct ibv_ah_attr *ah_attr); 2299 2300 /** 2301 * ibv_create_ah_from_wc - Creates an address handle associated with the 2302 * sender of the specified work completion. 2303 * @pd: The protection domain associated with the address handle. 2304 * @wc: Work completion information associated with a received message. 2305 * @grh: References the received global route header. This parameter is 2306 * ignored unless the work completion indicates that the GRH is valid. 2307 * @port_num: The outbound port number to associate with the address. 2308 * 2309 * The address handle is used to reference a local or global destination 2310 * in all UD QP post sends. 2311 */ 2312 struct ibv_ah *ibv_create_ah_from_wc(struct ibv_pd *pd, struct ibv_wc *wc, 2313 struct ibv_grh *grh, uint8_t port_num); 2314 2315 /** 2316 * ibv_destroy_ah - Destroy an address handle. 2317 */ 2318 int ibv_destroy_ah(struct ibv_ah *ah); 2319 2320 /** 2321 * ibv_attach_mcast - Attaches the specified QP to a multicast group. 2322 * @qp: QP to attach to the multicast group. The QP must be a UD QP. 2323 * @gid: Multicast group GID. 2324 * @lid: Multicast group LID in host byte order. 2325 * 2326 * In order to route multicast packets correctly, subnet 2327 * administration must have created the multicast group and configured 2328 * the fabric appropriately. The port associated with the specified 2329 * QP must also be a member of the multicast group. 2330 */ 2331 int ibv_attach_mcast(struct ibv_qp *qp, const union ibv_gid *gid, uint16_t lid); 2332 2333 /** 2334 * ibv_detach_mcast - Detaches the specified QP from a multicast group. 2335 * @qp: QP to detach from the multicast group. 2336 * @gid: Multicast group GID. 2337 * @lid: Multicast group LID in host byte order. 2338 */ 2339 int ibv_detach_mcast(struct ibv_qp *qp, const union ibv_gid *gid, uint16_t lid); 2340 2341 /** 2342 * ibv_fork_init - Prepare data structures so that fork() may be used 2343 * safely. If this function is not called or returns a non-zero 2344 * status, then libibverbs data structures are not fork()-safe and the 2345 * effect of an application calling fork() is undefined. 2346 */ 2347 int ibv_fork_init(void); 2348 2349 /** 2350 * ibv_node_type_str - Return string describing node_type enum value 2351 */ 2352 const char *ibv_node_type_str(enum ibv_node_type node_type); 2353 2354 /** 2355 * ibv_port_state_str - Return string describing port_state enum value 2356 */ 2357 const char *ibv_port_state_str(enum ibv_port_state port_state); 2358 2359 /** 2360 * ibv_event_type_str - Return string describing event_type enum value 2361 */ 2362 const char *ibv_event_type_str(enum ibv_event_type event); 2363 2364 #define ETHERNET_LL_SIZE 6 2365 int ibv_resolve_eth_l2_from_gid(struct ibv_context *context, 2366 struct ibv_ah_attr *attr, 2367 uint8_t eth_mac[ETHERNET_LL_SIZE], 2368 uint16_t *vid); 2369 2370 static inline int ibv_is_qpt_supported(uint32_t caps, enum ibv_qp_type qpt) 2371 { 2372 return !!(caps & (1 << qpt)); 2373 } 2374 2375 END_C_DECLS 2376 2377 # undef __attribute_const 2378 2379 2380 #endif /* INFINIBAND_VERBS_H */ 2381