blob: 50806bef9f2066cc2091e9abdd72dbd877a1abef [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (c) 2004 Mellanox Technologies Ltd. All rights reserved.
3 * Copyright (c) 2004 Infinicon Corporation. All rights reserved.
4 * Copyright (c) 2004 Intel Corporation. All rights reserved.
5 * Copyright (c) 2004 Topspin Corporation. All rights reserved.
6 * Copyright (c) 2004 Voltaire Corporation. All rights reserved.
Roland Dreier2a1d9b72005-08-10 23:03:10 -07007 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
Roland Dreierf7c6a7b2007-03-04 16:15:11 -08008 * Copyright (c) 2005, 2006, 2007 Cisco Systems. All rights reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
10 * This software is available to you under a choice of one of two
11 * licenses. You may choose to be licensed under the terms of the GNU
12 * General Public License (GPL) Version 2, available from the file
13 * COPYING in the main directory of this source tree, or the
14 * OpenIB.org BSD license below:
15 *
16 * Redistribution and use in source and binary forms, with or
17 * without modification, are permitted provided that the following
18 * conditions are met:
19 *
20 * - Redistributions of source code must retain the above
21 * copyright notice, this list of conditions and the following
22 * disclaimer.
23 *
24 * - Redistributions in binary form must reproduce the above
25 * copyright notice, this list of conditions and the following
26 * disclaimer in the documentation and/or other materials
27 * provided with the distribution.
28 *
29 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
30 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
31 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
32 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
33 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
34 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
35 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
36 * SOFTWARE.
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 */
38
39#if !defined(IB_VERBS_H)
40#define IB_VERBS_H
41
42#include <linux/types.h>
43#include <linux/device.h>
Ralph Campbell9b513092006-12-12 14:27:41 -080044#include <linux/dma-mapping.h>
Michael S. Tsirkin459d6e22007-02-04 14:11:55 -080045#include <linux/kref.h>
Dotan Barakbfb3ea12007-07-31 16:49:15 +030046#include <linux/list.h>
47#include <linux/rwsem.h>
Tejun Heof0626712010-10-19 15:24:36 +000048#include <linux/workqueue.h>
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -080049#include <linux/irq_poll.h>
Matan Barakdd5f03b2013-12-12 18:03:11 +020050#include <uapi/linux/if_ether.h>
Somnath Koturc865f242015-12-23 14:56:51 +020051#include <net/ipv6.h>
52#include <net/ip.h>
Matan Barak301a7212015-12-15 20:30:10 +020053#include <linux/string.h>
54#include <linux/slab.h>
Vishwanathapura, Niranjana2fc77572017-04-12 20:29:20 -070055#include <linux/netdevice.h>
Parav Pandit01b67112018-11-16 03:50:57 +020056#include <linux/refcount.h>
Eli Cohen50174a72016-03-11 22:58:38 +020057#include <linux/if_link.h>
Arun Sharma600634972011-07-26 16:09:06 -070058#include <linux/atomic.h>
Haggai Eran882214e2014-12-11 17:04:18 +020059#include <linux/mmu_notifier.h>
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080060#include <linux/uaccess.h>
Parav Pandit43579b52017-01-10 00:02:14 +000061#include <linux/cgroup_rdma.h>
Leon Romanovskyf6316032019-03-28 15:12:58 +020062#include <linux/irqflags.h>
63#include <linux/preempt.h>
Nicolas Dichtelea6819e2017-03-27 14:20:14 +020064#include <uapi/rdma/ib_user_verbs.h>
Mark Zhang413d3342019-07-02 13:02:34 +030065#include <rdma/rdma_counter.h>
Leon Romanovsky02d88832018-01-28 11:17:20 +020066#include <rdma/restrack.h>
Max Gurtovoy36b1e472019-06-11 18:52:37 +030067#include <rdma/signature.h>
Matan Barak0ede73b2018-03-19 15:02:34 +020068#include <uapi/rdma/rdma_user_ioctl.h>
Matan Barak2eb9bea2018-03-28 09:27:45 +030069#include <uapi/rdma/ib_user_ioctl_verbs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
Leon Romanovsky9abb0d12017-06-27 16:49:53 +030071#define IB_FW_VERSION_NAME_MAX ETHTOOL_FWVERS_LEN
72
Jason Gunthorpeb5231b02018-09-16 20:48:04 +030073struct ib_umem_odp;
74
Tejun Heof0626712010-10-19 15:24:36 +000075extern struct workqueue_struct *ib_wq;
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -080076extern struct workqueue_struct *ib_comp_wq;
Jack Morgensteinf7948092018-08-27 08:35:55 +030077extern struct workqueue_struct *ib_comp_unbound_wq;
Tejun Heof0626712010-10-19 15:24:36 +000078
Gal Pressman923abb92019-05-01 13:48:13 +030079__printf(3, 4) __cold
80void ibdev_printk(const char *level, const struct ib_device *ibdev,
81 const char *format, ...);
82__printf(2, 3) __cold
83void ibdev_emerg(const struct ib_device *ibdev, const char *format, ...);
84__printf(2, 3) __cold
85void ibdev_alert(const struct ib_device *ibdev, const char *format, ...);
86__printf(2, 3) __cold
87void ibdev_crit(const struct ib_device *ibdev, const char *format, ...);
88__printf(2, 3) __cold
89void ibdev_err(const struct ib_device *ibdev, const char *format, ...);
90__printf(2, 3) __cold
91void ibdev_warn(const struct ib_device *ibdev, const char *format, ...);
92__printf(2, 3) __cold
93void ibdev_notice(const struct ib_device *ibdev, const char *format, ...);
94__printf(2, 3) __cold
95void ibdev_info(const struct ib_device *ibdev, const char *format, ...);
96
97#if defined(CONFIG_DYNAMIC_DEBUG)
98#define ibdev_dbg(__dev, format, args...) \
99 dynamic_ibdev_dbg(__dev, format, ##args)
100#elif defined(DEBUG)
101#define ibdev_dbg(__dev, format, args...) \
102 ibdev_printk(KERN_DEBUG, __dev, format, ##args)
103#else
104__printf(2, 3) __cold
105static inline
106void ibdev_dbg(const struct ib_device *ibdev, const char *format, ...) {}
107#endif
108
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109union ib_gid {
110 u8 raw[16];
111 struct {
Sean Hefty97f52eb2005-08-13 21:05:57 -0700112 __be64 subnet_prefix;
113 __be64 interface_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 } global;
115};
116
Moni Shouae26be1b2015-07-30 18:33:29 +0300117extern union ib_gid zgid;
118
Matan Barakb39ffa12015-12-23 14:56:47 +0200119enum ib_gid_type {
120 /* If link layer is Ethernet, this is RoCE V1 */
121 IB_GID_TYPE_IB = 0,
122 IB_GID_TYPE_ROCE = 0,
Matan Barak7766a992015-12-23 14:56:50 +0200123 IB_GID_TYPE_ROCE_UDP_ENCAP = 1,
Matan Barakb39ffa12015-12-23 14:56:47 +0200124 IB_GID_TYPE_SIZE
125};
126
Moni Shoua7ead4bc2016-01-14 17:50:38 +0200127#define ROCE_V2_UDP_DPORT 4791
Matan Barak03db3a22015-07-30 18:33:26 +0300128struct ib_gid_attr {
Parav Pandit943bd982019-05-02 10:48:07 +0300129 struct net_device __rcu *ndev;
Parav Pandit598ff6b2018-04-01 15:08:21 +0300130 struct ib_device *device;
Parav Panditb150c382018-06-05 08:40:15 +0300131 union ib_gid gid;
Parav Pandit598ff6b2018-04-01 15:08:21 +0300132 enum ib_gid_type gid_type;
133 u16 index;
134 u8 port_num;
Matan Barak03db3a22015-07-30 18:33:26 +0300135};
136
Eli Cohena0c1b2a2016-03-11 22:58:37 +0200137enum {
138 /* set the local administered indication */
139 IB_SA_WELL_KNOWN_GUID = BIT_ULL(57) | 2,
140};
141
Tom Tucker07ebafb2006-08-03 16:02:42 -0500142enum rdma_transport_type {
143 RDMA_TRANSPORT_IB,
Upinder Malhi \(umalhi\)180771a2013-09-10 03:36:59 +0000144 RDMA_TRANSPORT_IWARP,
Upinder Malhi248567f2014-01-09 14:48:19 -0800145 RDMA_TRANSPORT_USNIC,
Gal Pressmanf95be3d2019-05-05 20:59:21 +0300146 RDMA_TRANSPORT_USNIC_UDP,
147 RDMA_TRANSPORT_UNSPECIFIED,
Tom Tucker07ebafb2006-08-03 16:02:42 -0500148};
149
Michael Wang6b90a6d2015-05-05 14:50:18 +0200150enum rdma_protocol_type {
151 RDMA_PROTOCOL_IB,
152 RDMA_PROTOCOL_IBOE,
153 RDMA_PROTOCOL_IWARP,
154 RDMA_PROTOCOL_USNIC_UDP
155};
156
Roland Dreier8385fd82014-06-04 10:00:16 -0700157__attribute_const__ enum rdma_transport_type
Jason Gunthorpe5d60c112019-06-13 21:38:17 -0300158rdma_node_get_transport(unsigned int node_type);
Tom Tucker07ebafb2006-08-03 16:02:42 -0500159
Somnath Koturc865f242015-12-23 14:56:51 +0200160enum rdma_network_type {
161 RDMA_NETWORK_IB,
162 RDMA_NETWORK_ROCE_V1 = RDMA_NETWORK_IB,
163 RDMA_NETWORK_IPV4,
164 RDMA_NETWORK_IPV6
165};
166
167static inline enum ib_gid_type ib_network_to_gid_type(enum rdma_network_type network_type)
168{
169 if (network_type == RDMA_NETWORK_IPV4 ||
170 network_type == RDMA_NETWORK_IPV6)
171 return IB_GID_TYPE_ROCE_UDP_ENCAP;
172
173 /* IB_GID_TYPE_IB same as RDMA_NETWORK_ROCE_V1 */
174 return IB_GID_TYPE_IB;
175}
176
Parav Pandit47ec3862018-06-13 10:22:06 +0300177static inline enum rdma_network_type
178rdma_gid_attr_network_type(const struct ib_gid_attr *attr)
Somnath Koturc865f242015-12-23 14:56:51 +0200179{
Parav Pandit47ec3862018-06-13 10:22:06 +0300180 if (attr->gid_type == IB_GID_TYPE_IB)
Somnath Koturc865f242015-12-23 14:56:51 +0200181 return RDMA_NETWORK_IB;
182
Parav Pandit47ec3862018-06-13 10:22:06 +0300183 if (ipv6_addr_v4mapped((struct in6_addr *)&attr->gid))
Somnath Koturc865f242015-12-23 14:56:51 +0200184 return RDMA_NETWORK_IPV4;
185 else
186 return RDMA_NETWORK_IPV6;
187}
188
Eli Cohena3f5ada2010-09-27 17:51:10 -0700189enum rdma_link_layer {
190 IB_LINK_LAYER_UNSPECIFIED,
191 IB_LINK_LAYER_INFINIBAND,
192 IB_LINK_LAYER_ETHERNET,
193};
194
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195enum ib_device_cap_flags {
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200196 IB_DEVICE_RESIZE_MAX_WR = (1 << 0),
197 IB_DEVICE_BAD_PKEY_CNTR = (1 << 1),
198 IB_DEVICE_BAD_QKEY_CNTR = (1 << 2),
199 IB_DEVICE_RAW_MULTI = (1 << 3),
200 IB_DEVICE_AUTO_PATH_MIG = (1 << 4),
201 IB_DEVICE_CHANGE_PHY_PORT = (1 << 5),
202 IB_DEVICE_UD_AV_PORT_ENFORCE = (1 << 6),
203 IB_DEVICE_CURR_QP_STATE_MOD = (1 << 7),
204 IB_DEVICE_SHUTDOWN_PORT = (1 << 8),
Leon Romanovsky78b57f92017-08-17 15:50:37 +0300205 /* Not in use, former INIT_TYPE = (1 << 9),*/
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200206 IB_DEVICE_PORT_ACTIVE_EVENT = (1 << 10),
207 IB_DEVICE_SYS_IMAGE_GUID = (1 << 11),
208 IB_DEVICE_RC_RNR_NAK_GEN = (1 << 12),
209 IB_DEVICE_SRQ_RESIZE = (1 << 13),
210 IB_DEVICE_N_NOTIFY_CQ = (1 << 14),
Christoph Hellwigb1adc712015-12-23 19:12:45 +0100211
212 /*
213 * This device supports a per-device lkey or stag that can be
214 * used without performing a memory registration for the local
215 * memory. Note that ULPs should never check this flag, but
216 * instead of use the local_dma_lkey flag in the ib_pd structure,
217 * which will always contain a usable lkey.
218 */
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200219 IB_DEVICE_LOCAL_DMA_LKEY = (1 << 15),
Leon Romanovsky78b57f92017-08-17 15:50:37 +0300220 /* Reserved, old SEND_W_INV = (1 << 16),*/
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200221 IB_DEVICE_MEM_WINDOW = (1 << 17),
Eli Cohene0605d92008-01-30 18:30:57 +0200222 /*
223 * Devices should set IB_DEVICE_UD_IP_SUM if they support
224 * insertion of UDP and TCP checksum on outgoing UD IPoIB
225 * messages and can verify the validity of checksum for
226 * incoming messages. Setting this flag implies that the
227 * IPoIB driver may set NETIF_F_IP_CSUM for datagram mode.
228 */
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200229 IB_DEVICE_UD_IP_CSUM = (1 << 18),
230 IB_DEVICE_UD_TSO = (1 << 19),
231 IB_DEVICE_XRC = (1 << 20),
Christoph Hellwigb1adc712015-12-23 19:12:45 +0100232
233 /*
234 * This device supports the IB "base memory management extension",
235 * which includes support for fast registrations (IB_WR_REG_MR,
236 * IB_WR_LOCAL_INV and IB_WR_SEND_WITH_INV verbs). This flag should
237 * also be set by any iWarp device which must support FRs to comply
238 * to the iWarp verbs spec. iWarp devices also support the
239 * IB_WR_RDMA_READ_WITH_INV verb for RDMA READs that invalidate the
240 * stag.
241 */
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200242 IB_DEVICE_MEM_MGT_EXTENSIONS = (1 << 21),
243 IB_DEVICE_BLOCK_MULTICAST_LOOPBACK = (1 << 22),
244 IB_DEVICE_MEM_WINDOW_TYPE_2A = (1 << 23),
245 IB_DEVICE_MEM_WINDOW_TYPE_2B = (1 << 24),
246 IB_DEVICE_RC_IP_CSUM = (1 << 25),
Noa Osherovichebaaee22017-01-18 15:39:54 +0200247 /* Deprecated. Please use IB_RAW_PACKET_CAP_IP_CSUM. */
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200248 IB_DEVICE_RAW_IP_CSUM = (1 << 26),
Leon Romanovsky8a06ce52015-12-20 12:16:10 +0200249 /*
250 * Devices should set IB_DEVICE_CROSS_CHANNEL if they
251 * support execution of WQEs that involve synchronization
252 * of I/O operations with single completion queue managed
253 * by hardware.
254 */
Leon Romanovsky78b57f92017-08-17 15:50:37 +0300255 IB_DEVICE_CROSS_CHANNEL = (1 << 27),
Leon Romanovsky7ca0bc52015-12-20 12:16:09 +0200256 IB_DEVICE_MANAGED_FLOW_STEERING = (1 << 29),
Israel Rukshinc0a6cbb2019-06-11 18:52:50 +0300257 IB_DEVICE_INTEGRITY_HANDOVER = (1 << 30),
Max Gurtovoy47355b32016-06-06 19:34:39 +0300258 IB_DEVICE_ON_DEMAND_PAGING = (1ULL << 31),
Sagi Grimbergf5aa9152016-02-29 19:07:32 +0200259 IB_DEVICE_SG_GAPS_REG = (1ULL << 32),
Max Gurtovoyc7e162a2016-06-06 19:34:40 +0300260 IB_DEVICE_VIRTUAL_FUNCTION = (1ULL << 33),
Noa Osherovichebaaee22017-01-18 15:39:54 +0200261 /* Deprecated. Please use IB_RAW_PACKET_CAP_SCATTER_FCS. */
Max Gurtovoyc7e162a2016-06-06 19:34:40 +0300262 IB_DEVICE_RAW_SCATTER_FCS = (1ULL << 34),
Vishwanathapura, Niranjana62e45942017-04-12 20:29:21 -0700263 IB_DEVICE_RDMA_NETDEV_OPA_VNIC = (1ULL << 35),
Noa Osheroviche1d2e882017-10-29 13:59:44 +0200264 /* The device supports padding incoming writes to cacheline. */
265 IB_DEVICE_PCI_WRITE_END_PADDING = (1ULL << 36),
Steve Wise3856ec42019-02-15 11:03:53 -0800266 IB_DEVICE_ALLOW_USER_UNREG = (1ULL << 37),
Sagi Grimberg1b01d332014-02-23 14:19:05 +0200267};
268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269enum ib_atomic_cap {
270 IB_ATOMIC_NONE,
271 IB_ATOMIC_HCA,
272 IB_ATOMIC_GLOB
273};
274
Sagi Grimberg860f10a2014-12-11 17:04:16 +0200275enum ib_odp_general_cap_bits {
Artemy Kovalyov25bf14d2017-01-18 16:58:06 +0200276 IB_ODP_SUPPORT = 1 << 0,
277 IB_ODP_SUPPORT_IMPLICIT = 1 << 1,
Sagi Grimberg860f10a2014-12-11 17:04:16 +0200278};
279
280enum ib_odp_transport_cap_bits {
281 IB_ODP_SUPPORT_SEND = 1 << 0,
282 IB_ODP_SUPPORT_RECV = 1 << 1,
283 IB_ODP_SUPPORT_WRITE = 1 << 2,
284 IB_ODP_SUPPORT_READ = 1 << 3,
285 IB_ODP_SUPPORT_ATOMIC = 1 << 4,
Moni Shouada823342019-01-22 08:48:41 +0200286 IB_ODP_SUPPORT_SRQ_RECV = 1 << 5,
Sagi Grimberg860f10a2014-12-11 17:04:16 +0200287};
288
289struct ib_odp_caps {
290 uint64_t general_caps;
291 struct {
292 uint32_t rc_odp_caps;
293 uint32_t uc_odp_caps;
294 uint32_t ud_odp_caps;
Moni Shoua52a72e22019-01-22 08:48:42 +0200295 uint32_t xrc_odp_caps;
Sagi Grimberg860f10a2014-12-11 17:04:16 +0200296 } per_transport_caps;
297};
298
Yishai Hadasccf20562016-08-28 11:28:43 +0300299struct ib_rss_caps {
300 /* Corresponding bit will be set if qp type from
301 * 'enum ib_qp_type' is supported, e.g.
302 * supported_qpts |= 1 << IB_QPT_UD
303 */
304 u32 supported_qpts;
305 u32 max_rwq_indirection_tables;
306 u32 max_rwq_indirection_table_size;
307};
308
Artemy Kovalyov6938fc1e2017-08-17 15:52:03 +0300309enum ib_tm_cap_flags {
310 /* Support tag matching on RC transport */
311 IB_TM_CAP_RC = 1 << 0,
312};
313
Leon Romanovsky78b1beb2017-09-24 21:46:29 +0300314struct ib_tm_caps {
Artemy Kovalyov6938fc1e2017-08-17 15:52:03 +0300315 /* Max size of RNDV header */
316 u32 max_rndv_hdr_size;
317 /* Max number of entries in tag matching list */
318 u32 max_num_tags;
319 /* From enum ib_tm_cap_flags */
320 u32 flags;
321 /* Max number of outstanding list operations */
322 u32 max_ops;
323 /* Max number of SGE in tag matching entry */
324 u32 max_sge;
325};
326
Matan Barakbcf4c1e2015-06-11 16:35:20 +0300327struct ib_cq_init_attr {
328 unsigned int cqe;
329 int comp_vector;
330 u32 flags;
331};
332
Yonatan Cohen869ddcf2017-11-13 10:51:13 +0200333enum ib_cq_attr_mask {
334 IB_CQ_MODERATE = 1 << 0,
335};
336
Yonatan Cohen18bd9072017-11-13 10:51:16 +0200337struct ib_cq_caps {
338 u16 max_cq_moderation_count;
339 u16 max_cq_moderation_period;
340};
341
Ariel Levkovichbe934cc2018-04-05 18:53:25 +0300342struct ib_dm_mr_attr {
343 u64 length;
344 u64 offset;
345 u32 access_flags;
346};
347
Ariel Levkovichbee76d72018-04-05 18:53:24 +0300348struct ib_dm_alloc_attr {
349 u64 length;
350 u32 alignment;
351 u32 flags;
352};
353
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354struct ib_device_attr {
355 u64 fw_ver;
Sean Hefty97f52eb2005-08-13 21:05:57 -0700356 __be64 sys_image_guid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 u64 max_mr_size;
358 u64 page_size_cap;
359 u32 vendor_id;
360 u32 vendor_part_id;
361 u32 hw_ver;
362 int max_qp;
363 int max_qp_wr;
Leon Romanovskyfb532d62016-02-23 10:25:25 +0200364 u64 device_cap_flags;
Steve Wise33023fb2018-06-18 08:05:26 -0700365 int max_send_sge;
366 int max_recv_sge;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 int max_sge_rd;
368 int max_cq;
369 int max_cqe;
370 int max_mr;
371 int max_pd;
372 int max_qp_rd_atom;
373 int max_ee_rd_atom;
374 int max_res_rd_atom;
375 int max_qp_init_rd_atom;
376 int max_ee_init_rd_atom;
377 enum ib_atomic_cap atomic_cap;
Vladimir Sokolovsky5e80ba82010-04-14 17:23:01 +0300378 enum ib_atomic_cap masked_atomic_cap;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 int max_ee;
380 int max_rdd;
381 int max_mw;
382 int max_raw_ipv6_qp;
383 int max_raw_ethy_qp;
384 int max_mcast_grp;
385 int max_mcast_qp_attach;
386 int max_total_mcast_qp_attach;
387 int max_ah;
388 int max_fmr;
389 int max_map_per_fmr;
390 int max_srq;
391 int max_srq_wr;
392 int max_srq_sge;
Steve Wise00f7ec32008-07-14 23:48:45 -0700393 unsigned int max_fast_reg_page_list_len;
Max Gurtovoy62e3c372019-06-11 18:52:43 +0300394 unsigned int max_pi_fast_reg_page_list_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 u16 max_pkeys;
396 u8 local_ca_ack_delay;
Sagi Grimberg1b01d332014-02-23 14:19:05 +0200397 int sig_prot_cap;
398 int sig_guard_cap;
Sagi Grimberg860f10a2014-12-11 17:04:16 +0200399 struct ib_odp_caps odp_caps;
Matan Barak24306dc2015-06-11 16:35:24 +0300400 uint64_t timestamp_mask;
401 uint64_t hca_core_clock; /* in KHZ */
Yishai Hadasccf20562016-08-28 11:28:43 +0300402 struct ib_rss_caps rss_caps;
403 u32 max_wq_type_rq;
Noa Osherovichebaaee22017-01-18 15:39:54 +0200404 u32 raw_packet_caps; /* Use ib_raw_packet_caps enum */
Leon Romanovsky78b1beb2017-09-24 21:46:29 +0300405 struct ib_tm_caps tm_caps;
Yonatan Cohen18bd9072017-11-13 10:51:16 +0200406 struct ib_cq_caps cq_caps;
Ariel Levkovich1d8eeb92018-04-05 18:53:23 +0300407 u64 max_dm_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408};
409
410enum ib_mtu {
411 IB_MTU_256 = 1,
412 IB_MTU_512 = 2,
413 IB_MTU_1024 = 3,
414 IB_MTU_2048 = 4,
415 IB_MTU_4096 = 5
416};
417
418static inline int ib_mtu_enum_to_int(enum ib_mtu mtu)
419{
420 switch (mtu) {
421 case IB_MTU_256: return 256;
422 case IB_MTU_512: return 512;
423 case IB_MTU_1024: return 1024;
424 case IB_MTU_2048: return 2048;
425 case IB_MTU_4096: return 4096;
426 default: return -1;
427 }
428}
429
Amrani, Ramd3f4aad2016-12-26 08:40:57 +0200430static inline enum ib_mtu ib_mtu_int_to_enum(int mtu)
431{
432 if (mtu >= 4096)
433 return IB_MTU_4096;
434 else if (mtu >= 2048)
435 return IB_MTU_2048;
436 else if (mtu >= 1024)
437 return IB_MTU_1024;
438 else if (mtu >= 512)
439 return IB_MTU_512;
440 else
441 return IB_MTU_256;
442}
443
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444enum ib_port_state {
445 IB_PORT_NOP = 0,
446 IB_PORT_DOWN = 1,
447 IB_PORT_INIT = 2,
448 IB_PORT_ARMED = 3,
449 IB_PORT_ACTIVE = 4,
450 IB_PORT_ACTIVE_DEFER = 5
451};
452
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453enum ib_port_width {
454 IB_WIDTH_1X = 1,
Michael Guralnikdbabf682018-12-09 11:49:49 +0200455 IB_WIDTH_2X = 16,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 IB_WIDTH_4X = 2,
457 IB_WIDTH_8X = 4,
458 IB_WIDTH_12X = 8
459};
460
461static inline int ib_width_enum_to_int(enum ib_port_width width)
462{
463 switch (width) {
464 case IB_WIDTH_1X: return 1;
Michael Guralnikdbabf682018-12-09 11:49:49 +0200465 case IB_WIDTH_2X: return 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 case IB_WIDTH_4X: return 4;
467 case IB_WIDTH_8X: return 8;
468 case IB_WIDTH_12X: return 12;
469 default: return -1;
470 }
471}
472
Or Gerlitz2e966912012-02-28 18:49:50 +0200473enum ib_port_speed {
474 IB_SPEED_SDR = 1,
475 IB_SPEED_DDR = 2,
476 IB_SPEED_QDR = 4,
477 IB_SPEED_FDR10 = 8,
478 IB_SPEED_FDR = 16,
Noa Osherovich12113a32017-04-20 20:53:31 +0300479 IB_SPEED_EDR = 32,
480 IB_SPEED_HDR = 64
Or Gerlitz2e966912012-02-28 18:49:50 +0200481};
482
Christoph Lameterb40f4752016-05-16 12:49:33 -0500483/**
484 * struct rdma_hw_stats
Mark Bloche9451302018-03-27 15:51:05 +0300485 * @lock - Mutex to protect parallel write access to lifespan and values
486 * of counters, which are 64bits and not guaranteeed to be written
487 * atomicaly on 32bits systems.
Christoph Lameterb40f4752016-05-16 12:49:33 -0500488 * @timestamp - Used by the core code to track when the last update was
489 * @lifespan - Used by the core code to determine how old the counters
490 * should be before being updated again. Stored in jiffies, defaults
491 * to 10 milliseconds, drivers can override the default be specifying
492 * their own value during their allocation routine.
493 * @name - Array of pointers to static names used for the counters in
494 * directory.
495 * @num_counters - How many hardware counters there are. If name is
496 * shorter than this number, a kernel oops will result. Driver authors
497 * are encouraged to leave BUILD_BUG_ON(ARRAY_SIZE(@name) < num_counters)
498 * in their code to prevent this.
499 * @value - Array of u64 counters that are accessed by the sysfs code and
500 * filled in by the drivers get_stats routine
501 */
502struct rdma_hw_stats {
Mark Bloche9451302018-03-27 15:51:05 +0300503 struct mutex lock; /* Protect lifespan and values[] */
Christoph Lameterb40f4752016-05-16 12:49:33 -0500504 unsigned long timestamp;
505 unsigned long lifespan;
506 const char * const *names;
507 int num_counters;
508 u64 value[];
Steve Wise7f624d02008-07-14 23:48:48 -0700509};
510
Christoph Lameterb40f4752016-05-16 12:49:33 -0500511#define RDMA_HW_STATS_DEFAULT_LIFESPAN 10
512/**
513 * rdma_alloc_hw_stats_struct - Helper function to allocate dynamic struct
514 * for drivers.
515 * @names - Array of static const char *
516 * @num_counters - How many elements in array
517 * @lifespan - How many milliseconds between updates
518 */
519static inline struct rdma_hw_stats *rdma_alloc_hw_stats_struct(
520 const char * const *names, int num_counters,
521 unsigned long lifespan)
522{
523 struct rdma_hw_stats *stats;
Steve Wise7f624d02008-07-14 23:48:48 -0700524
Christoph Lameterb40f4752016-05-16 12:49:33 -0500525 stats = kzalloc(sizeof(*stats) + num_counters * sizeof(u64),
526 GFP_KERNEL);
527 if (!stats)
528 return NULL;
529 stats->names = names;
530 stats->num_counters = num_counters;
531 stats->lifespan = msecs_to_jiffies(lifespan);
Steve Wise7f624d02008-07-14 23:48:48 -0700532
Christoph Lameterb40f4752016-05-16 12:49:33 -0500533 return stats;
534}
535
Steve Wise7f624d02008-07-14 23:48:48 -0700536
Ira Weinyf9b22e32015-05-13 20:02:59 -0400537/* Define bits for the various functionality this port needs to be supported by
538 * the core.
539 */
540/* Management 0x00000FFF */
541#define RDMA_CORE_CAP_IB_MAD 0x00000001
542#define RDMA_CORE_CAP_IB_SMI 0x00000002
543#define RDMA_CORE_CAP_IB_CM 0x00000004
544#define RDMA_CORE_CAP_IW_CM 0x00000008
545#define RDMA_CORE_CAP_IB_SA 0x00000010
Ira Weiny65995fe2015-06-06 14:38:32 -0400546#define RDMA_CORE_CAP_OPA_MAD 0x00000020
Ira Weinyf9b22e32015-05-13 20:02:59 -0400547
548/* Address format 0x000FF000 */
549#define RDMA_CORE_CAP_AF_IB 0x00001000
550#define RDMA_CORE_CAP_ETH_AH 0x00002000
Dasaratharaman Chandramouli94d595c2017-03-20 19:38:09 -0400551#define RDMA_CORE_CAP_OPA_AH 0x00004000
Artemy Kovalyovb02289b2018-07-04 15:57:50 +0300552#define RDMA_CORE_CAP_IB_GRH_REQUIRED 0x00008000
Ira Weinyf9b22e32015-05-13 20:02:59 -0400553
554/* Protocol 0xFFF00000 */
555#define RDMA_CORE_CAP_PROT_IB 0x00100000
556#define RDMA_CORE_CAP_PROT_ROCE 0x00200000
557#define RDMA_CORE_CAP_PROT_IWARP 0x00400000
Matan Barak7766a992015-12-23 14:56:50 +0200558#define RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP 0x00800000
Or Gerlitzaa773bd2017-01-24 13:02:35 +0200559#define RDMA_CORE_CAP_PROT_RAW_PACKET 0x01000000
Or Gerlitzce1e0552017-01-24 13:02:38 +0200560#define RDMA_CORE_CAP_PROT_USNIC 0x02000000
Ira Weinyf9b22e32015-05-13 20:02:59 -0400561
Artemy Kovalyovb02289b2018-07-04 15:57:50 +0300562#define RDMA_CORE_PORT_IB_GRH_REQUIRED (RDMA_CORE_CAP_IB_GRH_REQUIRED \
563 | RDMA_CORE_CAP_PROT_ROCE \
564 | RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP)
565
Ira Weinyf9b22e32015-05-13 20:02:59 -0400566#define RDMA_CORE_PORT_IBA_IB (RDMA_CORE_CAP_PROT_IB \
567 | RDMA_CORE_CAP_IB_MAD \
568 | RDMA_CORE_CAP_IB_SMI \
569 | RDMA_CORE_CAP_IB_CM \
570 | RDMA_CORE_CAP_IB_SA \
571 | RDMA_CORE_CAP_AF_IB)
572#define RDMA_CORE_PORT_IBA_ROCE (RDMA_CORE_CAP_PROT_ROCE \
573 | RDMA_CORE_CAP_IB_MAD \
574 | RDMA_CORE_CAP_IB_CM \
Ira Weinyf9b22e32015-05-13 20:02:59 -0400575 | RDMA_CORE_CAP_AF_IB \
576 | RDMA_CORE_CAP_ETH_AH)
Matan Barak7766a992015-12-23 14:56:50 +0200577#define RDMA_CORE_PORT_IBA_ROCE_UDP_ENCAP \
578 (RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP \
579 | RDMA_CORE_CAP_IB_MAD \
580 | RDMA_CORE_CAP_IB_CM \
581 | RDMA_CORE_CAP_AF_IB \
582 | RDMA_CORE_CAP_ETH_AH)
Ira Weinyf9b22e32015-05-13 20:02:59 -0400583#define RDMA_CORE_PORT_IWARP (RDMA_CORE_CAP_PROT_IWARP \
584 | RDMA_CORE_CAP_IW_CM)
Ira Weiny65995fe2015-06-06 14:38:32 -0400585#define RDMA_CORE_PORT_INTEL_OPA (RDMA_CORE_PORT_IBA_IB \
586 | RDMA_CORE_CAP_OPA_MAD)
Ira Weinyf9b22e32015-05-13 20:02:59 -0400587
Or Gerlitzaa773bd2017-01-24 13:02:35 +0200588#define RDMA_CORE_PORT_RAW_PACKET (RDMA_CORE_CAP_PROT_RAW_PACKET)
589
Or Gerlitzce1e0552017-01-24 13:02:38 +0200590#define RDMA_CORE_PORT_USNIC (RDMA_CORE_CAP_PROT_USNIC)
591
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592struct ib_port_attr {
Eli Cohenfad61ad2016-03-11 22:58:36 +0200593 u64 subnet_prefix;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 enum ib_port_state state;
595 enum ib_mtu max_mtu;
596 enum ib_mtu active_mtu;
597 int gid_tbl_len;
Jason Gunthorpe2f944c02018-07-04 15:57:48 +0300598 unsigned int ip_gids:1;
599 /* This is the value from PortInfo CapabilityMask, defined by IBA */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 u32 port_cap_flags;
601 u32 max_msg_sz;
602 u32 bad_pkey_cntr;
603 u32 qkey_viol_cntr;
604 u16 pkey_tbl_len;
Dasaratharaman Chandramoulidb585402017-06-08 13:37:48 -0400605 u32 sm_lid;
Dasaratharaman Chandramouli582faf32017-06-08 13:37:47 -0400606 u32 lid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 u8 lmc;
608 u8 max_vl_num;
609 u8 sm_sl;
610 u8 subnet_timeout;
611 u8 init_type_reply;
612 u8 active_width;
613 u8 active_speed;
614 u8 phys_state;
Michael Guralnik1e8f43b2018-12-09 11:49:48 +0200615 u16 port_cap_flags2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616};
617
618enum ib_device_modify_flags {
Roland Dreierc5bcbbb2006-02-02 09:47:14 -0800619 IB_DEVICE_MODIFY_SYS_IMAGE_GUID = 1 << 0,
620 IB_DEVICE_MODIFY_NODE_DESC = 1 << 1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621};
622
Yuval Shaiabd99fde2016-08-25 10:57:07 -0700623#define IB_DEVICE_NODE_DESC_MAX 64
624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625struct ib_device_modify {
626 u64 sys_image_guid;
Yuval Shaiabd99fde2016-08-25 10:57:07 -0700627 char node_desc[IB_DEVICE_NODE_DESC_MAX];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628};
629
630enum ib_port_modify_flags {
631 IB_PORT_SHUTDOWN = 1,
632 IB_PORT_INIT_TYPE = (1<<2),
Vishwanathapura, Niranjanacb493662017-06-01 17:04:02 -0700633 IB_PORT_RESET_QKEY_CNTR = (1<<3),
634 IB_PORT_OPA_MASK_CHG = (1<<4)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635};
636
637struct ib_port_modify {
638 u32 set_port_cap_mask;
639 u32 clr_port_cap_mask;
640 u8 init_type;
641};
642
643enum ib_event_type {
644 IB_EVENT_CQ_ERR,
645 IB_EVENT_QP_FATAL,
646 IB_EVENT_QP_REQ_ERR,
647 IB_EVENT_QP_ACCESS_ERR,
648 IB_EVENT_COMM_EST,
649 IB_EVENT_SQ_DRAINED,
650 IB_EVENT_PATH_MIG,
651 IB_EVENT_PATH_MIG_ERR,
652 IB_EVENT_DEVICE_FATAL,
653 IB_EVENT_PORT_ACTIVE,
654 IB_EVENT_PORT_ERR,
655 IB_EVENT_LID_CHANGE,
656 IB_EVENT_PKEY_CHANGE,
Roland Dreierd41fcc62005-08-18 12:23:08 -0700657 IB_EVENT_SM_CHANGE,
658 IB_EVENT_SRQ_ERR,
659 IB_EVENT_SRQ_LIMIT_REACHED,
Leonid Arsh63942c92006-06-17 20:37:35 -0700660 IB_EVENT_QP_LAST_WQE_REACHED,
Or Gerlitz761d90e2011-06-15 14:39:29 +0000661 IB_EVENT_CLIENT_REREGISTER,
662 IB_EVENT_GID_CHANGE,
Yishai Hadasf213c052016-05-23 15:20:49 +0300663 IB_EVENT_WQ_FATAL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664};
665
Bart Van Asschedb7489e2015-08-03 10:01:52 -0700666const char *__attribute_const__ ib_event_msg(enum ib_event_type event);
Sagi Grimberg2b1b5b62015-05-18 13:40:28 +0300667
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668struct ib_event {
669 struct ib_device *device;
670 union {
671 struct ib_cq *cq;
672 struct ib_qp *qp;
Roland Dreierd41fcc62005-08-18 12:23:08 -0700673 struct ib_srq *srq;
Yishai Hadasf213c052016-05-23 15:20:49 +0300674 struct ib_wq *wq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 u8 port_num;
676 } element;
677 enum ib_event_type event;
678};
679
680struct ib_event_handler {
681 struct ib_device *device;
682 void (*handler)(struct ib_event_handler *, struct ib_event *);
683 struct list_head list;
684};
685
686#define INIT_IB_EVENT_HANDLER(_ptr, _device, _handler) \
687 do { \
688 (_ptr)->device = _device; \
689 (_ptr)->handler = _handler; \
690 INIT_LIST_HEAD(&(_ptr)->list); \
691 } while (0)
692
693struct ib_global_route {
Jason Gunthorpe8d9ec9a2018-06-13 10:22:03 +0300694 const struct ib_gid_attr *sgid_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 union ib_gid dgid;
696 u32 flow_label;
697 u8 sgid_index;
698 u8 hop_limit;
699 u8 traffic_class;
700};
701
Hal Rosenstock513789e2005-07-27 11:45:34 -0700702struct ib_grh {
Sean Hefty97f52eb2005-08-13 21:05:57 -0700703 __be32 version_tclass_flow;
704 __be16 paylen;
Hal Rosenstock513789e2005-07-27 11:45:34 -0700705 u8 next_hdr;
706 u8 hop_limit;
707 union ib_gid sgid;
708 union ib_gid dgid;
709};
710
Somnath Koturc865f242015-12-23 14:56:51 +0200711union rdma_network_hdr {
712 struct ib_grh ibgrh;
713 struct {
714 /* The IB spec states that if it's IPv4, the header
715 * is located in the last 20 bytes of the header.
716 */
717 u8 reserved[20];
718 struct iphdr roce4grh;
719 };
720};
721
Don Hiatt7dafbab2017-05-12 09:19:55 -0700722#define IB_QPN_MASK 0xFFFFFF
723
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724enum {
725 IB_MULTICAST_QPN = 0xffffff
726};
727
Harvey Harrisonf3a7c662009-02-14 22:58:35 -0800728#define IB_LID_PERMISSIVE cpu_to_be16(0xFFFF)
Dennis Dalessandrob4e64392016-01-06 10:04:31 -0800729#define IB_MULTICAST_LID_BASE cpu_to_be16(0xC000)
Sean Hefty97f52eb2005-08-13 21:05:57 -0700730
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731enum ib_ah_flags {
732 IB_AH_GRH = 1
733};
734
Jack Morgensteinbf6a9e32006-04-10 09:43:47 -0700735enum ib_rate {
736 IB_RATE_PORT_CURRENT = 0,
737 IB_RATE_2_5_GBPS = 2,
738 IB_RATE_5_GBPS = 5,
739 IB_RATE_10_GBPS = 3,
740 IB_RATE_20_GBPS = 6,
741 IB_RATE_30_GBPS = 4,
742 IB_RATE_40_GBPS = 7,
743 IB_RATE_60_GBPS = 8,
744 IB_RATE_80_GBPS = 9,
Marcel Apfelbaum71eeba12011-10-05 14:21:47 +0300745 IB_RATE_120_GBPS = 10,
746 IB_RATE_14_GBPS = 11,
747 IB_RATE_56_GBPS = 12,
748 IB_RATE_112_GBPS = 13,
749 IB_RATE_168_GBPS = 14,
750 IB_RATE_25_GBPS = 15,
751 IB_RATE_100_GBPS = 16,
752 IB_RATE_200_GBPS = 17,
Michael Guralnika5a5d192018-12-09 11:49:50 +0200753 IB_RATE_300_GBPS = 18,
754 IB_RATE_28_GBPS = 19,
755 IB_RATE_50_GBPS = 20,
756 IB_RATE_400_GBPS = 21,
757 IB_RATE_600_GBPS = 22,
Jack Morgensteinbf6a9e32006-04-10 09:43:47 -0700758};
759
760/**
761 * ib_rate_to_mult - Convert the IB rate enum to a multiple of the
762 * base rate of 2.5 Gbit/sec. For example, IB_RATE_5_GBPS will be
763 * converted to 2, since 5 Gbit/sec is 2 * 2.5 Gbit/sec.
764 * @rate: rate to convert.
765 */
Roland Dreier8385fd82014-06-04 10:00:16 -0700766__attribute_const__ int ib_rate_to_mult(enum ib_rate rate);
Jack Morgensteinbf6a9e32006-04-10 09:43:47 -0700767
768/**
Marcel Apfelbaum71eeba12011-10-05 14:21:47 +0300769 * ib_rate_to_mbps - Convert the IB rate enum to Mbps.
770 * For example, IB_RATE_2_5_GBPS will be converted to 2500.
771 * @rate: rate to convert.
772 */
Roland Dreier8385fd82014-06-04 10:00:16 -0700773__attribute_const__ int ib_rate_to_mbps(enum ib_rate rate);
Marcel Apfelbaum71eeba12011-10-05 14:21:47 +0300774
Sagi Grimberg17cd3a22014-02-23 14:19:04 +0200775
776/**
Sagi Grimberg9bee1782015-07-30 10:32:35 +0300777 * enum ib_mr_type - memory region type
778 * @IB_MR_TYPE_MEM_REG: memory region that is used for
779 * normal registration
Sagi Grimbergf5aa9152016-02-29 19:07:32 +0200780 * @IB_MR_TYPE_SG_GAPS: memory region that is capable to
781 * register any arbitrary sg lists (without
782 * the normal mr constraints - see
783 * ib_map_mr_sg)
Max Gurtovoya0bc0992019-06-11 18:52:38 +0300784 * @IB_MR_TYPE_DM: memory region that is used for device
785 * memory registration
786 * @IB_MR_TYPE_USER: memory region that is used for the user-space
787 * application
788 * @IB_MR_TYPE_DMA: memory region that is used for DMA operations
789 * without address translations (VA=PA)
Israel Rukshin26bc7ea2019-06-11 18:52:39 +0300790 * @IB_MR_TYPE_INTEGRITY: memory region that is used for
791 * data integrity operations
Sagi Grimberg17cd3a22014-02-23 14:19:04 +0200792 */
Sagi Grimberg9bee1782015-07-30 10:32:35 +0300793enum ib_mr_type {
794 IB_MR_TYPE_MEM_REG,
Sagi Grimbergf5aa9152016-02-29 19:07:32 +0200795 IB_MR_TYPE_SG_GAPS,
Max Gurtovoya0bc0992019-06-11 18:52:38 +0300796 IB_MR_TYPE_DM,
797 IB_MR_TYPE_USER,
798 IB_MR_TYPE_DMA,
Israel Rukshin26bc7ea2019-06-11 18:52:39 +0300799 IB_MR_TYPE_INTEGRITY,
Sagi Grimberg17cd3a22014-02-23 14:19:04 +0200800};
801
Sagi Grimberg1b01d332014-02-23 14:19:05 +0200802enum ib_mr_status_check {
803 IB_MR_CHECK_SIG_STATUS = 1,
804};
805
806/**
807 * struct ib_mr_status - Memory region status container
808 *
809 * @fail_status: Bitmask of MR checks status. For each
810 * failed check a corresponding status bit is set.
811 * @sig_err: Additional info for IB_MR_CEHCK_SIG_STATUS
812 * failure.
813 */
814struct ib_mr_status {
815 u32 fail_status;
816 struct ib_sig_err sig_err;
817};
818
Marcel Apfelbaum71eeba12011-10-05 14:21:47 +0300819/**
Jack Morgensteinbf6a9e32006-04-10 09:43:47 -0700820 * mult_to_ib_rate - Convert a multiple of 2.5 Gbit/sec to an IB rate
821 * enum.
822 * @mult: multiple to convert.
823 */
Roland Dreier8385fd82014-06-04 10:00:16 -0700824__attribute_const__ enum ib_rate mult_to_ib_rate(int mult);
Jack Morgensteinbf6a9e32006-04-10 09:43:47 -0700825
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -0400826enum rdma_ah_attr_type {
Don Hiatt87daac62018-02-01 10:57:03 -0800827 RDMA_AH_ATTR_TYPE_UNDEFINED,
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -0400828 RDMA_AH_ATTR_TYPE_IB,
829 RDMA_AH_ATTR_TYPE_ROCE,
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -0400830 RDMA_AH_ATTR_TYPE_OPA,
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -0400831};
832
833struct ib_ah_attr {
834 u16 dlid;
835 u8 src_path_bits;
836};
837
838struct roce_ah_attr {
839 u8 dmac[ETH_ALEN];
840};
841
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -0400842struct opa_ah_attr {
843 u32 dlid;
844 u8 src_path_bits;
Don Hiattd98bb7f2017-08-04 13:54:16 -0700845 bool make_grd;
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -0400846};
847
Dasaratharaman Chandramouli90898852017-04-29 14:41:18 -0400848struct rdma_ah_attr {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 struct ib_global_route grh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 u8 sl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 u8 static_rate;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 u8 port_num;
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -0400853 u8 ah_flags;
854 enum rdma_ah_attr_type type;
855 union {
856 struct ib_ah_attr ib;
857 struct roce_ah_attr roce;
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -0400858 struct opa_ah_attr opa;
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -0400859 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860};
861
862enum ib_wc_status {
863 IB_WC_SUCCESS,
864 IB_WC_LOC_LEN_ERR,
865 IB_WC_LOC_QP_OP_ERR,
866 IB_WC_LOC_EEC_OP_ERR,
867 IB_WC_LOC_PROT_ERR,
868 IB_WC_WR_FLUSH_ERR,
869 IB_WC_MW_BIND_ERR,
870 IB_WC_BAD_RESP_ERR,
871 IB_WC_LOC_ACCESS_ERR,
872 IB_WC_REM_INV_REQ_ERR,
873 IB_WC_REM_ACCESS_ERR,
874 IB_WC_REM_OP_ERR,
875 IB_WC_RETRY_EXC_ERR,
876 IB_WC_RNR_RETRY_EXC_ERR,
877 IB_WC_LOC_RDD_VIOL_ERR,
878 IB_WC_REM_INV_RD_REQ_ERR,
879 IB_WC_REM_ABORT_ERR,
880 IB_WC_INV_EECN_ERR,
881 IB_WC_INV_EEC_STATE_ERR,
882 IB_WC_FATAL_ERR,
883 IB_WC_RESP_TIMEOUT_ERR,
884 IB_WC_GENERAL_ERR
885};
886
Bart Van Asschedb7489e2015-08-03 10:01:52 -0700887const char *__attribute_const__ ib_wc_status_msg(enum ib_wc_status status);
Sagi Grimberg2b1b5b62015-05-18 13:40:28 +0300888
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889enum ib_wc_opcode {
890 IB_WC_SEND,
891 IB_WC_RDMA_WRITE,
892 IB_WC_RDMA_READ,
893 IB_WC_COMP_SWAP,
894 IB_WC_FETCH_ADD,
Eli Cohenc93570f2008-04-16 21:09:27 -0700895 IB_WC_LSO,
Steve Wise00f7ec32008-07-14 23:48:45 -0700896 IB_WC_LOCAL_INV,
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +0300897 IB_WC_REG_MR,
Vladimir Sokolovsky5e80ba82010-04-14 17:23:01 +0300898 IB_WC_MASKED_COMP_SWAP,
899 IB_WC_MASKED_FETCH_ADD,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900/*
901 * Set value of IB_WC_RECV so consumers can test if a completion is a
902 * receive by testing (opcode & IB_WC_RECV).
903 */
904 IB_WC_RECV = 1 << 7,
905 IB_WC_RECV_RDMA_WITH_IMM
906};
907
908enum ib_wc_flags {
909 IB_WC_GRH = 1,
Steve Wise00f7ec32008-07-14 23:48:45 -0700910 IB_WC_WITH_IMM = (1<<1),
911 IB_WC_WITH_INVALIDATE = (1<<2),
Or Gerlitzd927d502012-01-11 19:03:51 +0200912 IB_WC_IP_CSUM_OK = (1<<3),
Matan Barakdd5f03b2013-12-12 18:03:11 +0200913 IB_WC_WITH_SMAC = (1<<4),
914 IB_WC_WITH_VLAN = (1<<5),
Somnath Koturc865f242015-12-23 14:56:51 +0200915 IB_WC_WITH_NETWORK_HDR_TYPE = (1<<6),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916};
917
918struct ib_wc {
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -0800919 union {
920 u64 wr_id;
921 struct ib_cqe *wr_cqe;
922 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 enum ib_wc_status status;
924 enum ib_wc_opcode opcode;
925 u32 vendor_err;
926 u32 byte_len;
Michael S. Tsirkin062dbb62006-12-31 21:09:42 +0200927 struct ib_qp *qp;
Steve Wise00f7ec32008-07-14 23:48:45 -0700928 union {
929 __be32 imm_data;
930 u32 invalidate_rkey;
931 } ex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 u32 src_qp;
Bodong Wangcd2a6e72018-01-12 07:58:41 +0200933 u32 slid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 int wc_flags;
935 u16 pkey_index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 u8 sl;
937 u8 dlid_path_bits;
938 u8 port_num; /* valid only for DR SMPs on switches */
Matan Barakdd5f03b2013-12-12 18:03:11 +0200939 u8 smac[ETH_ALEN];
940 u16 vlan_id;
Somnath Koturc865f242015-12-23 14:56:51 +0200941 u8 network_hdr_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942};
943
Roland Dreiered23a722007-05-06 21:02:48 -0700944enum ib_cq_notify_flags {
945 IB_CQ_SOLICITED = 1 << 0,
946 IB_CQ_NEXT_COMP = 1 << 1,
947 IB_CQ_SOLICITED_MASK = IB_CQ_SOLICITED | IB_CQ_NEXT_COMP,
948 IB_CQ_REPORT_MISSED_EVENTS = 1 << 2,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949};
950
Sean Hefty96104ed2011-05-23 16:31:36 -0700951enum ib_srq_type {
Sean Hefty418d5132011-05-23 19:42:29 -0700952 IB_SRQT_BASIC,
Artemy Kovalyov9c2c8492017-08-17 15:52:05 +0300953 IB_SRQT_XRC,
954 IB_SRQT_TM,
Sean Hefty96104ed2011-05-23 16:31:36 -0700955};
956
Artemy Kovalyov1a56ff62017-08-17 15:52:04 +0300957static inline bool ib_srq_has_cq(enum ib_srq_type srq_type)
958{
Artemy Kovalyov9c2c8492017-08-17 15:52:05 +0300959 return srq_type == IB_SRQT_XRC ||
960 srq_type == IB_SRQT_TM;
Artemy Kovalyov1a56ff62017-08-17 15:52:04 +0300961}
962
Roland Dreierd41fcc62005-08-18 12:23:08 -0700963enum ib_srq_attr_mask {
964 IB_SRQ_MAX_WR = 1 << 0,
965 IB_SRQ_LIMIT = 1 << 1,
966};
967
968struct ib_srq_attr {
969 u32 max_wr;
970 u32 max_sge;
971 u32 srq_limit;
972};
973
974struct ib_srq_init_attr {
975 void (*event_handler)(struct ib_event *, void *);
976 void *srq_context;
977 struct ib_srq_attr attr;
Sean Hefty96104ed2011-05-23 16:31:36 -0700978 enum ib_srq_type srq_type;
Sean Hefty418d5132011-05-23 19:42:29 -0700979
Artemy Kovalyov1a56ff62017-08-17 15:52:04 +0300980 struct {
981 struct ib_cq *cq;
982 union {
983 struct {
984 struct ib_xrcd *xrcd;
985 } xrc;
Artemy Kovalyov9c2c8492017-08-17 15:52:05 +0300986
987 struct {
988 u32 max_num_tags;
989 } tag_matching;
Artemy Kovalyov1a56ff62017-08-17 15:52:04 +0300990 };
Sean Hefty418d5132011-05-23 19:42:29 -0700991 } ext;
Roland Dreierd41fcc62005-08-18 12:23:08 -0700992};
993
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994struct ib_qp_cap {
995 u32 max_send_wr;
996 u32 max_recv_wr;
997 u32 max_send_sge;
998 u32 max_recv_sge;
999 u32 max_inline_data;
Christoph Hellwiga060b562016-05-03 18:01:09 +02001000
1001 /*
1002 * Maximum number of rdma_rw_ctx structures in flight at a time.
1003 * ib_create_qp() will calculate the right amount of neededed WRs
1004 * and MRs based on this.
1005 */
1006 u32 max_rdma_ctxs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007};
1008
1009enum ib_sig_type {
1010 IB_SIGNAL_ALL_WR,
1011 IB_SIGNAL_REQ_WR
1012};
1013
1014enum ib_qp_type {
1015 /*
1016 * IB_QPT_SMI and IB_QPT_GSI have to be the first two entries
1017 * here (and in that order) since the MAD layer uses them as
1018 * indices into a 2-entry table.
1019 */
1020 IB_QPT_SMI,
1021 IB_QPT_GSI,
1022
1023 IB_QPT_RC,
1024 IB_QPT_UC,
1025 IB_QPT_UD,
1026 IB_QPT_RAW_IPV6,
Sean Heftyb42b63c2011-05-23 19:59:25 -07001027 IB_QPT_RAW_ETHERTYPE,
Or Gerlitzc938a612012-03-01 12:17:51 +02001028 IB_QPT_RAW_PACKET = 8,
Sean Heftyb42b63c2011-05-23 19:59:25 -07001029 IB_QPT_XRC_INI = 9,
1030 IB_QPT_XRC_TGT,
Jack Morgenstein0134f162013-07-07 17:25:52 +03001031 IB_QPT_MAX,
Moni Shoua8011c1e2018-01-02 16:19:30 +02001032 IB_QPT_DRIVER = 0xFF,
Jack Morgenstein0134f162013-07-07 17:25:52 +03001033 /* Reserve a range for qp types internal to the low level driver.
1034 * These qp types will not be visible at the IB core layer, so the
1035 * IB_QPT_MAX usages should not be affected in the core layer
1036 */
1037 IB_QPT_RESERVED1 = 0x1000,
1038 IB_QPT_RESERVED2,
1039 IB_QPT_RESERVED3,
1040 IB_QPT_RESERVED4,
1041 IB_QPT_RESERVED5,
1042 IB_QPT_RESERVED6,
1043 IB_QPT_RESERVED7,
1044 IB_QPT_RESERVED8,
1045 IB_QPT_RESERVED9,
1046 IB_QPT_RESERVED10,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047};
1048
Eli Cohenb846f252008-04-16 21:09:27 -07001049enum ib_qp_create_flags {
Ron Livne47ee1b92008-07-14 23:48:48 -07001050 IB_QP_CREATE_IPOIB_UD_LSO = 1 << 0,
1051 IB_QP_CREATE_BLOCK_MULTICAST_LOOPBACK = 1 << 1,
Leon Romanovsky8a06ce52015-12-20 12:16:10 +02001052 IB_QP_CREATE_CROSS_CHANNEL = 1 << 2,
1053 IB_QP_CREATE_MANAGED_SEND = 1 << 3,
1054 IB_QP_CREATE_MANAGED_RECV = 1 << 4,
Matan Barak90f1d1b2013-11-07 15:25:12 +02001055 IB_QP_CREATE_NETIF_QP = 1 << 5,
Israel Rukshinc0a6cbb2019-06-11 18:52:50 +03001056 IB_QP_CREATE_INTEGRITY_EN = 1 << 6,
Leon Romanovsky7855f582017-05-23 14:38:16 +03001057 /* FREE = 1 << 7, */
Majd Dibbinyb531b902016-04-17 17:19:36 +03001058 IB_QP_CREATE_SCATTER_FCS = 1 << 8,
Noa Osherovich9c2b2702017-01-18 15:39:56 +02001059 IB_QP_CREATE_CVLAN_STRIPPING = 1 << 9,
Yishai Hadas02984cc2017-06-08 16:15:06 +03001060 IB_QP_CREATE_SOURCE_QPN = 1 << 10,
Noa Osheroviche1d2e882017-10-29 13:59:44 +02001061 IB_QP_CREATE_PCI_WRITE_END_PADDING = 1 << 11,
Jack Morgensteind2b57062012-08-03 08:40:37 +00001062 /* reserve bits 26-31 for low level drivers' internal use */
1063 IB_QP_CREATE_RESERVED_START = 1 << 26,
1064 IB_QP_CREATE_RESERVED_END = 1 << 31,
Eli Cohenb846f252008-04-16 21:09:27 -07001065};
1066
Yishai Hadas73c40c62013-08-01 18:49:53 +03001067/*
1068 * Note: users may not call ib_close_qp or ib_destroy_qp from the event_handler
1069 * callback to destroy the passed in QP.
1070 */
1071
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072struct ib_qp_init_attr {
Chuck Levereb93c82e2018-09-04 11:45:20 -04001073 /* Consumer's event_handler callback must not block */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 void (*event_handler)(struct ib_event *, void *);
Chuck Levereb93c82e2018-09-04 11:45:20 -04001075
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 void *qp_context;
1077 struct ib_cq *send_cq;
1078 struct ib_cq *recv_cq;
1079 struct ib_srq *srq;
Sean Heftyb42b63c2011-05-23 19:59:25 -07001080 struct ib_xrcd *xrcd; /* XRC TGT QPs only */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 struct ib_qp_cap cap;
1082 enum ib_sig_type sq_sig_type;
1083 enum ib_qp_type qp_type;
Nathan Chancellorb56511c2018-09-24 12:57:16 -07001084 u32 create_flags;
Christoph Hellwiga060b562016-05-03 18:01:09 +02001085
1086 /*
1087 * Only needed for special QP types, or when using the RW API.
1088 */
1089 u8 port_num;
Yishai Hadasa9017e22016-05-23 15:20:54 +03001090 struct ib_rwq_ind_table *rwq_ind_tbl;
Yishai Hadas02984cc2017-06-08 16:15:06 +03001091 u32 source_qpn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092};
1093
Sean Hefty0e0ec7e2011-08-08 15:31:51 -07001094struct ib_qp_open_attr {
1095 void (*event_handler)(struct ib_event *, void *);
1096 void *qp_context;
1097 u32 qp_num;
1098 enum ib_qp_type qp_type;
1099};
1100
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101enum ib_rnr_timeout {
1102 IB_RNR_TIMER_655_36 = 0,
1103 IB_RNR_TIMER_000_01 = 1,
1104 IB_RNR_TIMER_000_02 = 2,
1105 IB_RNR_TIMER_000_03 = 3,
1106 IB_RNR_TIMER_000_04 = 4,
1107 IB_RNR_TIMER_000_06 = 5,
1108 IB_RNR_TIMER_000_08 = 6,
1109 IB_RNR_TIMER_000_12 = 7,
1110 IB_RNR_TIMER_000_16 = 8,
1111 IB_RNR_TIMER_000_24 = 9,
1112 IB_RNR_TIMER_000_32 = 10,
1113 IB_RNR_TIMER_000_48 = 11,
1114 IB_RNR_TIMER_000_64 = 12,
1115 IB_RNR_TIMER_000_96 = 13,
1116 IB_RNR_TIMER_001_28 = 14,
1117 IB_RNR_TIMER_001_92 = 15,
1118 IB_RNR_TIMER_002_56 = 16,
1119 IB_RNR_TIMER_003_84 = 17,
1120 IB_RNR_TIMER_005_12 = 18,
1121 IB_RNR_TIMER_007_68 = 19,
1122 IB_RNR_TIMER_010_24 = 20,
1123 IB_RNR_TIMER_015_36 = 21,
1124 IB_RNR_TIMER_020_48 = 22,
1125 IB_RNR_TIMER_030_72 = 23,
1126 IB_RNR_TIMER_040_96 = 24,
1127 IB_RNR_TIMER_061_44 = 25,
1128 IB_RNR_TIMER_081_92 = 26,
1129 IB_RNR_TIMER_122_88 = 27,
1130 IB_RNR_TIMER_163_84 = 28,
1131 IB_RNR_TIMER_245_76 = 29,
1132 IB_RNR_TIMER_327_68 = 30,
1133 IB_RNR_TIMER_491_52 = 31
1134};
1135
1136enum ib_qp_attr_mask {
1137 IB_QP_STATE = 1,
1138 IB_QP_CUR_STATE = (1<<1),
1139 IB_QP_EN_SQD_ASYNC_NOTIFY = (1<<2),
1140 IB_QP_ACCESS_FLAGS = (1<<3),
1141 IB_QP_PKEY_INDEX = (1<<4),
1142 IB_QP_PORT = (1<<5),
1143 IB_QP_QKEY = (1<<6),
1144 IB_QP_AV = (1<<7),
1145 IB_QP_PATH_MTU = (1<<8),
1146 IB_QP_TIMEOUT = (1<<9),
1147 IB_QP_RETRY_CNT = (1<<10),
1148 IB_QP_RNR_RETRY = (1<<11),
1149 IB_QP_RQ_PSN = (1<<12),
1150 IB_QP_MAX_QP_RD_ATOMIC = (1<<13),
1151 IB_QP_ALT_PATH = (1<<14),
1152 IB_QP_MIN_RNR_TIMER = (1<<15),
1153 IB_QP_SQ_PSN = (1<<16),
1154 IB_QP_MAX_DEST_RD_ATOMIC = (1<<17),
1155 IB_QP_PATH_MIG_STATE = (1<<18),
1156 IB_QP_CAP = (1<<19),
Matan Barakdd5f03b2013-12-12 18:03:11 +02001157 IB_QP_DEST_QPN = (1<<20),
Matan Barakaa744cc2015-10-15 18:38:53 +03001158 IB_QP_RESERVED1 = (1<<21),
1159 IB_QP_RESERVED2 = (1<<22),
1160 IB_QP_RESERVED3 = (1<<23),
1161 IB_QP_RESERVED4 = (1<<24),
Bodong Wang528e5a12016-12-01 13:43:14 +02001162 IB_QP_RATE_LIMIT = (1<<25),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163};
1164
1165enum ib_qp_state {
1166 IB_QPS_RESET,
1167 IB_QPS_INIT,
1168 IB_QPS_RTR,
1169 IB_QPS_RTS,
1170 IB_QPS_SQD,
1171 IB_QPS_SQE,
1172 IB_QPS_ERR
1173};
1174
1175enum ib_mig_state {
1176 IB_MIG_MIGRATED,
1177 IB_MIG_REARM,
1178 IB_MIG_ARMED
1179};
1180
Shani Michaeli7083e422013-02-06 16:19:12 +00001181enum ib_mw_type {
1182 IB_MW_TYPE_1 = 1,
1183 IB_MW_TYPE_2 = 2
1184};
1185
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186struct ib_qp_attr {
1187 enum ib_qp_state qp_state;
1188 enum ib_qp_state cur_qp_state;
1189 enum ib_mtu path_mtu;
1190 enum ib_mig_state path_mig_state;
1191 u32 qkey;
1192 u32 rq_psn;
1193 u32 sq_psn;
1194 u32 dest_qp_num;
1195 int qp_access_flags;
1196 struct ib_qp_cap cap;
Dasaratharaman Chandramouli90898852017-04-29 14:41:18 -04001197 struct rdma_ah_attr ah_attr;
1198 struct rdma_ah_attr alt_ah_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 u16 pkey_index;
1200 u16 alt_pkey_index;
1201 u8 en_sqd_async_notify;
1202 u8 sq_draining;
1203 u8 max_rd_atomic;
1204 u8 max_dest_rd_atomic;
1205 u8 min_rnr_timer;
1206 u8 port_num;
1207 u8 timeout;
1208 u8 retry_cnt;
1209 u8 rnr_retry;
1210 u8 alt_port_num;
1211 u8 alt_timeout;
Bodong Wang528e5a12016-12-01 13:43:14 +02001212 u32 rate_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213};
1214
1215enum ib_wr_opcode {
Jason Gunthorpe9a597392018-08-14 15:33:02 -07001216 /* These are shared with userspace */
1217 IB_WR_RDMA_WRITE = IB_UVERBS_WR_RDMA_WRITE,
1218 IB_WR_RDMA_WRITE_WITH_IMM = IB_UVERBS_WR_RDMA_WRITE_WITH_IMM,
1219 IB_WR_SEND = IB_UVERBS_WR_SEND,
1220 IB_WR_SEND_WITH_IMM = IB_UVERBS_WR_SEND_WITH_IMM,
1221 IB_WR_RDMA_READ = IB_UVERBS_WR_RDMA_READ,
1222 IB_WR_ATOMIC_CMP_AND_SWP = IB_UVERBS_WR_ATOMIC_CMP_AND_SWP,
1223 IB_WR_ATOMIC_FETCH_AND_ADD = IB_UVERBS_WR_ATOMIC_FETCH_AND_ADD,
1224 IB_WR_LSO = IB_UVERBS_WR_TSO,
1225 IB_WR_SEND_WITH_INV = IB_UVERBS_WR_SEND_WITH_INV,
1226 IB_WR_RDMA_READ_WITH_INV = IB_UVERBS_WR_RDMA_READ_WITH_INV,
1227 IB_WR_LOCAL_INV = IB_UVERBS_WR_LOCAL_INV,
1228 IB_WR_MASKED_ATOMIC_CMP_AND_SWP =
1229 IB_UVERBS_WR_MASKED_ATOMIC_CMP_AND_SWP,
1230 IB_WR_MASKED_ATOMIC_FETCH_AND_ADD =
1231 IB_UVERBS_WR_MASKED_ATOMIC_FETCH_AND_ADD,
1232
1233 /* These are kernel only and can not be issued by userspace */
1234 IB_WR_REG_MR = 0x20,
Max Gurtovoy38ca87c2019-06-11 18:52:46 +03001235 IB_WR_REG_MR_INTEGRITY,
Jason Gunthorpe9a597392018-08-14 15:33:02 -07001236
Jack Morgenstein0134f162013-07-07 17:25:52 +03001237 /* reserve values for low level drivers' internal use.
1238 * These values will not be used at all in the ib core layer.
1239 */
1240 IB_WR_RESERVED1 = 0xf0,
1241 IB_WR_RESERVED2,
1242 IB_WR_RESERVED3,
1243 IB_WR_RESERVED4,
1244 IB_WR_RESERVED5,
1245 IB_WR_RESERVED6,
1246 IB_WR_RESERVED7,
1247 IB_WR_RESERVED8,
1248 IB_WR_RESERVED9,
1249 IB_WR_RESERVED10,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250};
1251
1252enum ib_send_flags {
1253 IB_SEND_FENCE = 1,
1254 IB_SEND_SIGNALED = (1<<1),
1255 IB_SEND_SOLICITED = (1<<2),
Eli Cohene0605d92008-01-30 18:30:57 +02001256 IB_SEND_INLINE = (1<<3),
Jack Morgenstein0134f162013-07-07 17:25:52 +03001257 IB_SEND_IP_CSUM = (1<<4),
1258
1259 /* reserve bits 26-31 for low level drivers' internal use */
1260 IB_SEND_RESERVED_START = (1 << 26),
1261 IB_SEND_RESERVED_END = (1 << 31),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262};
1263
1264struct ib_sge {
1265 u64 addr;
1266 u32 length;
1267 u32 lkey;
1268};
1269
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -08001270struct ib_cqe {
1271 void (*done)(struct ib_cq *cq, struct ib_wc *wc);
1272};
1273
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274struct ib_send_wr {
1275 struct ib_send_wr *next;
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -08001276 union {
1277 u64 wr_id;
1278 struct ib_cqe *wr_cqe;
1279 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 struct ib_sge *sg_list;
1281 int num_sge;
1282 enum ib_wr_opcode opcode;
1283 int send_flags;
Roland Dreier0f39cf32008-04-16 21:09:32 -07001284 union {
1285 __be32 imm_data;
1286 u32 invalidate_rkey;
1287 } ex;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288};
1289
Christoph Hellwige622f2f2015-10-08 09:16:33 +01001290struct ib_rdma_wr {
1291 struct ib_send_wr wr;
1292 u64 remote_addr;
1293 u32 rkey;
1294};
1295
Bart Van Asschef696bf62018-07-18 09:25:14 -07001296static inline const struct ib_rdma_wr *rdma_wr(const struct ib_send_wr *wr)
Christoph Hellwige622f2f2015-10-08 09:16:33 +01001297{
1298 return container_of(wr, struct ib_rdma_wr, wr);
1299}
1300
1301struct ib_atomic_wr {
1302 struct ib_send_wr wr;
1303 u64 remote_addr;
1304 u64 compare_add;
1305 u64 swap;
1306 u64 compare_add_mask;
1307 u64 swap_mask;
1308 u32 rkey;
1309};
1310
Bart Van Asschef696bf62018-07-18 09:25:14 -07001311static inline const struct ib_atomic_wr *atomic_wr(const struct ib_send_wr *wr)
Christoph Hellwige622f2f2015-10-08 09:16:33 +01001312{
1313 return container_of(wr, struct ib_atomic_wr, wr);
1314}
1315
1316struct ib_ud_wr {
1317 struct ib_send_wr wr;
1318 struct ib_ah *ah;
1319 void *header;
1320 int hlen;
1321 int mss;
1322 u32 remote_qpn;
1323 u32 remote_qkey;
1324 u16 pkey_index; /* valid for GSI only */
1325 u8 port_num; /* valid for DR SMPs on switch only */
1326};
1327
Bart Van Asschef696bf62018-07-18 09:25:14 -07001328static inline const struct ib_ud_wr *ud_wr(const struct ib_send_wr *wr)
Christoph Hellwige622f2f2015-10-08 09:16:33 +01001329{
1330 return container_of(wr, struct ib_ud_wr, wr);
1331}
1332
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03001333struct ib_reg_wr {
1334 struct ib_send_wr wr;
1335 struct ib_mr *mr;
1336 u32 key;
1337 int access;
1338};
1339
Bart Van Asschef696bf62018-07-18 09:25:14 -07001340static inline const struct ib_reg_wr *reg_wr(const struct ib_send_wr *wr)
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03001341{
1342 return container_of(wr, struct ib_reg_wr, wr);
1343}
1344
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345struct ib_recv_wr {
1346 struct ib_recv_wr *next;
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -08001347 union {
1348 u64 wr_id;
1349 struct ib_cqe *wr_cqe;
1350 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 struct ib_sge *sg_list;
1352 int num_sge;
1353};
1354
1355enum ib_access_flags {
Jason Gunthorpe4fca0372018-07-11 16:20:44 -06001356 IB_ACCESS_LOCAL_WRITE = IB_UVERBS_ACCESS_LOCAL_WRITE,
1357 IB_ACCESS_REMOTE_WRITE = IB_UVERBS_ACCESS_REMOTE_WRITE,
1358 IB_ACCESS_REMOTE_READ = IB_UVERBS_ACCESS_REMOTE_READ,
1359 IB_ACCESS_REMOTE_ATOMIC = IB_UVERBS_ACCESS_REMOTE_ATOMIC,
1360 IB_ACCESS_MW_BIND = IB_UVERBS_ACCESS_MW_BIND,
1361 IB_ZERO_BASED = IB_UVERBS_ACCESS_ZERO_BASED,
1362 IB_ACCESS_ON_DEMAND = IB_UVERBS_ACCESS_ON_DEMAND,
1363 IB_ACCESS_HUGETLB = IB_UVERBS_ACCESS_HUGETLB,
1364
1365 IB_ACCESS_SUPPORTED = ((IB_ACCESS_HUGETLB << 1) - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366};
1367
Christoph Hellwigb7d3e0a2015-12-23 19:12:47 +01001368/*
1369 * XXX: these are apparently used for ->rereg_user_mr, no idea why they
1370 * are hidden here instead of a uapi header!
1371 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372enum ib_mr_rereg_flags {
1373 IB_MR_REREG_TRANS = 1,
1374 IB_MR_REREG_PD = (1<<1),
Matan Barak7e6edb92014-07-31 11:01:28 +03001375 IB_MR_REREG_ACCESS = (1<<2),
1376 IB_MR_REREG_SUPPORTED = ((IB_MR_REREG_ACCESS << 1) - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377};
1378
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379struct ib_fmr_attr {
1380 int max_pages;
1381 int max_maps;
Or Gerlitzd36f34a2006-02-02 10:43:45 -08001382 u8 page_shift;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383};
1384
Haggai Eran882214e2014-12-11 17:04:18 +02001385struct ib_umem;
1386
Matan Barak38321252017-04-04 13:31:42 +03001387enum rdma_remove_reason {
Yishai Hadas1c774832018-06-20 17:11:39 +03001388 /*
1389 * Userspace requested uobject deletion or initial try
1390 * to remove uobject via cleanup. Call could fail
1391 */
Matan Barak38321252017-04-04 13:31:42 +03001392 RDMA_REMOVE_DESTROY,
1393 /* Context deletion. This call should delete the actual object itself */
1394 RDMA_REMOVE_CLOSE,
1395 /* Driver is being hot-unplugged. This call should delete the actual object itself */
1396 RDMA_REMOVE_DRIVER_REMOVE,
Jason Gunthorpe87ad80a2018-07-25 21:40:12 -06001397 /* uobj is being cleaned-up before being committed */
1398 RDMA_REMOVE_ABORT,
Matan Barak38321252017-04-04 13:31:42 +03001399};
1400
Parav Pandit43579b52017-01-10 00:02:14 +00001401struct ib_rdmacg_object {
1402#ifdef CONFIG_CGROUP_RDMA
1403 struct rdma_cgroup *cg; /* owner rdma cgroup */
1404#endif
1405};
1406
Roland Dreiere2773c02005-07-07 17:57:10 -07001407struct ib_ucontext {
1408 struct ib_device *device;
Matan Barak771addf2017-04-04 13:31:41 +03001409 struct ib_uverbs_file *ufile;
Jason Gunthorpee9517472018-07-10 20:55:19 -06001410 /*
1411 * 'closing' can be read by the driver only during a destroy callback,
1412 * it is set when we are closing the file descriptor and indicates
1413 * that mm_sem may be locked.
1414 */
Leon Romanovsky6ceb6332018-09-03 20:18:03 +03001415 bool closing;
Shachar Raindel8ada2c12014-12-11 17:04:17 +02001416
Yishai Hadas1c774832018-06-20 17:11:39 +03001417 bool cleanup_retryable;
Matan Barak38321252017-04-04 13:31:42 +03001418
Jason Gunthorpeb5231b02018-09-16 20:48:04 +03001419 void (*invalidate_range)(struct ib_umem_odp *umem_odp,
Haggai Eran882214e2014-12-11 17:04:18 +02001420 unsigned long start, unsigned long end);
Jason Gunthorpef27a0d52018-09-16 20:48:08 +03001421 struct mutex per_mm_list_lock;
1422 struct list_head per_mm_list;
Parav Pandit43579b52017-01-10 00:02:14 +00001423
1424 struct ib_rdmacg_object cg_obj;
Leon Romanovsky60615212018-11-28 13:16:43 +02001425 /*
1426 * Implementation details of the RDMA core, don't use in drivers:
1427 */
1428 struct rdma_restrack_entry res;
Roland Dreiere2773c02005-07-07 17:57:10 -07001429};
1430
1431struct ib_uobject {
1432 u64 user_handle; /* handle given to us by userspace */
Jason Gunthorpe6a5e9c82018-07-04 11:32:07 +03001433 /* ufile & ucontext owning this object */
1434 struct ib_uverbs_file *ufile;
1435 /* FIXME, save memory: ufile->context == context */
Roland Dreiere2773c02005-07-07 17:57:10 -07001436 struct ib_ucontext *context; /* associated user context */
Roland Dreier9ead1902006-06-17 20:44:49 -07001437 void *object; /* containing object */
Roland Dreiere2773c02005-07-07 17:57:10 -07001438 struct list_head list; /* link to context's list */
Parav Pandit43579b52017-01-10 00:02:14 +00001439 struct ib_rdmacg_object cg_obj; /* rdmacg object */
Roland Dreierb3d636b2008-04-16 21:01:06 -07001440 int id; /* index into kernel idr */
Roland Dreier9ead1902006-06-17 20:44:49 -07001441 struct kref ref;
Matan Barak38321252017-04-04 13:31:42 +03001442 atomic_t usecnt; /* protects exclusive access */
Mike Marciniszynd144da82015-11-02 12:13:25 -05001443 struct rcu_head rcu; /* kfree_rcu() overhead */
Matan Barak38321252017-04-04 13:31:42 +03001444
Jason Gunthorpe6b0d08f2018-08-09 20:14:37 -06001445 const struct uverbs_api_object *uapi_object;
Roland Dreiere2773c02005-07-07 17:57:10 -07001446};
1447
Roland Dreiere2773c02005-07-07 17:57:10 -07001448struct ib_udata {
Yann Droneaud309243e2013-12-11 23:01:44 +01001449 const void __user *inbuf;
Roland Dreiere2773c02005-07-07 17:57:10 -07001450 void __user *outbuf;
1451 size_t inlen;
1452 size_t outlen;
1453};
1454
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455struct ib_pd {
Jason Gunthorpe96249d72015-08-05 14:14:45 -06001456 u32 local_dma_lkey;
Christoph Hellwiged082d32016-09-05 12:56:17 +02001457 u32 flags;
Roland Dreiere2773c02005-07-07 17:57:10 -07001458 struct ib_device *device;
1459 struct ib_uobject *uobject;
1460 atomic_t usecnt; /* count all resources */
Christoph Hellwig50d46332016-09-05 12:56:16 +02001461
Christoph Hellwiged082d32016-09-05 12:56:17 +02001462 u32 unsafe_global_rkey;
1463
Christoph Hellwig50d46332016-09-05 12:56:16 +02001464 /*
1465 * Implementation details of the RDMA core, don't use in drivers:
1466 */
1467 struct ib_mr *__internal_mr;
Leon Romanovsky02d88832018-01-28 11:17:20 +02001468 struct rdma_restrack_entry res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469};
1470
Sean Hefty59991f92011-05-23 17:52:46 -07001471struct ib_xrcd {
1472 struct ib_device *device;
Sean Heftyd3d72d92011-05-26 23:06:44 -07001473 atomic_t usecnt; /* count all exposed resources */
Sean Hefty53d0bd12011-05-24 08:33:46 -07001474 struct inode *inode;
Sean Heftyd3d72d92011-05-26 23:06:44 -07001475
1476 struct mutex tgt_qp_mutex;
1477 struct list_head tgt_qp_list;
Sean Hefty59991f92011-05-23 17:52:46 -07001478};
1479
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480struct ib_ah {
1481 struct ib_device *device;
1482 struct ib_pd *pd;
Roland Dreiere2773c02005-07-07 17:57:10 -07001483 struct ib_uobject *uobject;
Jason Gunthorpe1a1f4602018-06-13 10:22:08 +03001484 const struct ib_gid_attr *sgid_attr;
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04001485 enum rdma_ah_attr_type type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486};
1487
1488typedef void (*ib_comp_handler)(struct ib_cq *cq, void *cq_context);
1489
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -08001490enum ib_poll_context {
Jack Morgensteinf7948092018-08-27 08:35:55 +03001491 IB_POLL_DIRECT, /* caller context, no hw completions */
1492 IB_POLL_SOFTIRQ, /* poll from softirq context */
1493 IB_POLL_WORKQUEUE, /* poll from workqueue */
1494 IB_POLL_UNBOUND_WORKQUEUE, /* poll from unbound workqueue */
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -08001495};
1496
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497struct ib_cq {
Roland Dreiere2773c02005-07-07 17:57:10 -07001498 struct ib_device *device;
1499 struct ib_uobject *uobject;
1500 ib_comp_handler comp_handler;
1501 void (*event_handler)(struct ib_event *, void *);
Dotan Barak4deccd62008-07-14 23:48:44 -07001502 void *cq_context;
Roland Dreiere2773c02005-07-07 17:57:10 -07001503 int cqe;
1504 atomic_t usecnt; /* count number of work queues */
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -08001505 enum ib_poll_context poll_ctx;
1506 struct ib_wc *wc;
1507 union {
1508 struct irq_poll iop;
1509 struct work_struct work;
1510 };
Jack Morgensteinf7948092018-08-27 08:35:55 +03001511 struct workqueue_struct *comp_wq;
Leon Romanovsky02d88832018-01-28 11:17:20 +02001512 /*
1513 * Implementation details of the RDMA core, don't use in drivers:
1514 */
1515 struct rdma_restrack_entry res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516};
1517
1518struct ib_srq {
Roland Dreierd41fcc62005-08-18 12:23:08 -07001519 struct ib_device *device;
1520 struct ib_pd *pd;
1521 struct ib_uobject *uobject;
1522 void (*event_handler)(struct ib_event *, void *);
1523 void *srq_context;
Sean Hefty96104ed2011-05-23 16:31:36 -07001524 enum ib_srq_type srq_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 atomic_t usecnt;
Sean Hefty418d5132011-05-23 19:42:29 -07001526
Artemy Kovalyov1a56ff62017-08-17 15:52:04 +03001527 struct {
1528 struct ib_cq *cq;
1529 union {
1530 struct {
1531 struct ib_xrcd *xrcd;
1532 u32 srq_num;
1533 } xrc;
1534 };
Sean Hefty418d5132011-05-23 19:42:29 -07001535 } ext;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536};
1537
Noa Osherovichebaaee22017-01-18 15:39:54 +02001538enum ib_raw_packet_caps {
1539 /* Strip cvlan from incoming packet and report it in the matching work
1540 * completion is supported.
1541 */
1542 IB_RAW_PACKET_CAP_CVLAN_STRIPPING = (1 << 0),
1543 /* Scatter FCS field of an incoming packet to host memory is supported.
1544 */
1545 IB_RAW_PACKET_CAP_SCATTER_FCS = (1 << 1),
1546 /* Checksum offloads are supported (for both send and receive). */
1547 IB_RAW_PACKET_CAP_IP_CSUM = (1 << 2),
Maor Gottlieb7d9336d2017-05-30 10:29:10 +03001548 /* When a packet is received for an RQ with no receive WQEs, the
1549 * packet processing is delayed.
1550 */
1551 IB_RAW_PACKET_CAP_DELAY_DROP = (1 << 3),
Noa Osherovichebaaee22017-01-18 15:39:54 +02001552};
1553
Yishai Hadas5fd251c2016-05-23 15:20:48 +03001554enum ib_wq_type {
1555 IB_WQT_RQ
1556};
1557
1558enum ib_wq_state {
1559 IB_WQS_RESET,
1560 IB_WQS_RDY,
1561 IB_WQS_ERR
1562};
1563
1564struct ib_wq {
1565 struct ib_device *device;
1566 struct ib_uobject *uobject;
1567 void *wq_context;
1568 void (*event_handler)(struct ib_event *, void *);
1569 struct ib_pd *pd;
1570 struct ib_cq *cq;
1571 u32 wq_num;
1572 enum ib_wq_state state;
1573 enum ib_wq_type wq_type;
1574 atomic_t usecnt;
1575};
1576
Noa Osherovich10bac722017-01-18 15:39:55 +02001577enum ib_wq_flags {
1578 IB_WQ_FLAGS_CVLAN_STRIPPING = 1 << 0,
Noa Osherovich27b0df12017-01-18 15:39:57 +02001579 IB_WQ_FLAGS_SCATTER_FCS = 1 << 1,
Maor Gottlieb7d9336d2017-05-30 10:29:10 +03001580 IB_WQ_FLAGS_DELAY_DROP = 1 << 2,
Noa Osheroviche1d2e882017-10-29 13:59:44 +02001581 IB_WQ_FLAGS_PCI_WRITE_END_PADDING = 1 << 3,
Noa Osherovich10bac722017-01-18 15:39:55 +02001582};
1583
Yishai Hadas5fd251c2016-05-23 15:20:48 +03001584struct ib_wq_init_attr {
1585 void *wq_context;
1586 enum ib_wq_type wq_type;
1587 u32 max_wr;
1588 u32 max_sge;
1589 struct ib_cq *cq;
1590 void (*event_handler)(struct ib_event *, void *);
Noa Osherovich10bac722017-01-18 15:39:55 +02001591 u32 create_flags; /* Use enum ib_wq_flags */
Yishai Hadas5fd251c2016-05-23 15:20:48 +03001592};
1593
1594enum ib_wq_attr_mask {
Noa Osherovich10bac722017-01-18 15:39:55 +02001595 IB_WQ_STATE = 1 << 0,
1596 IB_WQ_CUR_STATE = 1 << 1,
1597 IB_WQ_FLAGS = 1 << 2,
Yishai Hadas5fd251c2016-05-23 15:20:48 +03001598};
1599
1600struct ib_wq_attr {
1601 enum ib_wq_state wq_state;
1602 enum ib_wq_state curr_wq_state;
Noa Osherovich10bac722017-01-18 15:39:55 +02001603 u32 flags; /* Use enum ib_wq_flags */
1604 u32 flags_mask; /* Use enum ib_wq_flags */
Yishai Hadas5fd251c2016-05-23 15:20:48 +03001605};
1606
Yishai Hadas6d397862016-05-23 15:20:51 +03001607struct ib_rwq_ind_table {
1608 struct ib_device *device;
1609 struct ib_uobject *uobject;
1610 atomic_t usecnt;
1611 u32 ind_tbl_num;
1612 u32 log_ind_tbl_size;
1613 struct ib_wq **ind_tbl;
1614};
1615
1616struct ib_rwq_ind_table_init_attr {
1617 u32 log_ind_tbl_size;
1618 /* Each entry is a pointer to Receive Work Queue */
1619 struct ib_wq **ind_tbl;
1620};
1621
Daniel Jurgensd291f1a2017-05-19 15:48:52 +03001622enum port_pkey_state {
1623 IB_PORT_PKEY_NOT_VALID = 0,
1624 IB_PORT_PKEY_VALID = 1,
1625 IB_PORT_PKEY_LISTED = 2,
1626};
1627
1628struct ib_qp_security;
1629
1630struct ib_port_pkey {
1631 enum port_pkey_state state;
1632 u16 pkey_index;
1633 u8 port_num;
1634 struct list_head qp_list;
1635 struct list_head to_error_list;
1636 struct ib_qp_security *sec;
1637};
1638
1639struct ib_ports_pkeys {
1640 struct ib_port_pkey main;
1641 struct ib_port_pkey alt;
1642};
1643
1644struct ib_qp_security {
1645 struct ib_qp *qp;
1646 struct ib_device *dev;
1647 /* Hold this mutex when changing port and pkey settings. */
1648 struct mutex mutex;
1649 struct ib_ports_pkeys *ports_pkeys;
1650 /* A list of all open shared QP handles. Required to enforce security
1651 * properly for all users of a shared QP.
1652 */
1653 struct list_head shared_qp_list;
1654 void *security;
1655 bool destroying;
1656 atomic_t error_list_count;
1657 struct completion error_complete;
1658 int error_comps_pending;
1659};
1660
Bart Van Assche632bc3f2016-07-21 13:03:30 -07001661/*
1662 * @max_write_sge: Maximum SGE elements per RDMA WRITE request.
1663 * @max_read_sge: Maximum SGE elements per RDMA READ request.
1664 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665struct ib_qp {
1666 struct ib_device *device;
1667 struct ib_pd *pd;
1668 struct ib_cq *send_cq;
1669 struct ib_cq *recv_cq;
Christoph Hellwigfffb0382016-05-03 18:01:07 +02001670 spinlock_t mr_lock;
1671 int mrs_used;
Christoph Hellwiga060b562016-05-03 18:01:09 +02001672 struct list_head rdma_mrs;
Christoph Hellwig0e353e32016-05-03 18:01:12 +02001673 struct list_head sig_mrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 struct ib_srq *srq;
Sean Heftyb42b63c2011-05-23 19:59:25 -07001675 struct ib_xrcd *xrcd; /* XRC TGT QPs only */
Sean Heftyd3d72d92011-05-26 23:06:44 -07001676 struct list_head xrcd_list;
Christoph Hellwigfffb0382016-05-03 18:01:07 +02001677
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001678 /* count times opened, mcast attaches, flow attaches */
1679 atomic_t usecnt;
Sean Hefty0e0ec7e2011-08-08 15:31:51 -07001680 struct list_head open_list;
1681 struct ib_qp *real_qp;
Roland Dreiere2773c02005-07-07 17:57:10 -07001682 struct ib_uobject *uobject;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 void (*event_handler)(struct ib_event *, void *);
1684 void *qp_context;
Jason Gunthorpe1a1f4602018-06-13 10:22:08 +03001685 /* sgid_attrs associated with the AV's */
1686 const struct ib_gid_attr *av_sgid_attr;
1687 const struct ib_gid_attr *alt_path_sgid_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 u32 qp_num;
Bart Van Assche632bc3f2016-07-21 13:03:30 -07001689 u32 max_write_sge;
1690 u32 max_read_sge;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 enum ib_qp_type qp_type;
Yishai Hadasa9017e22016-05-23 15:20:54 +03001692 struct ib_rwq_ind_table *rwq_ind_tbl;
Daniel Jurgensd291f1a2017-05-19 15:48:52 +03001693 struct ib_qp_security *qp_sec;
Noa Osherovich498ca3c2017-08-23 08:35:40 +03001694 u8 port;
Leon Romanovsky02d88832018-01-28 11:17:20 +02001695
Max Gurtovoy185eddc2019-06-11 18:52:51 +03001696 bool integrity_en;
Leon Romanovsky02d88832018-01-28 11:17:20 +02001697 /*
1698 * Implementation details of the RDMA core, don't use in drivers:
1699 */
1700 struct rdma_restrack_entry res;
Mark Zhang99fa3312019-07-02 13:02:35 +03001701
1702 /* The counter the qp is bind to */
1703 struct rdma_counter *counter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704};
1705
Ariel Levkovichbee76d72018-04-05 18:53:24 +03001706struct ib_dm {
1707 struct ib_device *device;
1708 u32 length;
1709 u32 flags;
1710 struct ib_uobject *uobject;
1711 atomic_t usecnt;
1712};
1713
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714struct ib_mr {
Roland Dreiere2773c02005-07-07 17:57:10 -07001715 struct ib_device *device;
1716 struct ib_pd *pd;
Roland Dreiere2773c02005-07-07 17:57:10 -07001717 u32 lkey;
1718 u32 rkey;
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03001719 u64 iova;
Parav Panditedd31552017-09-24 21:46:31 +03001720 u64 length;
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03001721 unsigned int page_size;
Max Gurtovoya0bc0992019-06-11 18:52:38 +03001722 enum ib_mr_type type;
Steve Wised4a85c32016-05-03 18:01:08 +02001723 bool need_inval;
Christoph Hellwigfffb0382016-05-03 18:01:07 +02001724 union {
1725 struct ib_uobject *uobject; /* user */
1726 struct list_head qp_entry; /* FR */
1727 };
Steve Wisefccec5b2018-03-01 13:58:13 -08001728
Ariel Levkovichbe934cc2018-04-05 18:53:25 +03001729 struct ib_dm *dm;
Max Gurtovoy7c717d32019-06-11 18:52:41 +03001730 struct ib_sig_attrs *sig_attrs; /* only for IB_MR_TYPE_INTEGRITY MRs */
Steve Wisefccec5b2018-03-01 13:58:13 -08001731 /*
1732 * Implementation details of the RDMA core, don't use in drivers:
1733 */
1734 struct rdma_restrack_entry res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735};
1736
1737struct ib_mw {
1738 struct ib_device *device;
1739 struct ib_pd *pd;
Roland Dreiere2773c02005-07-07 17:57:10 -07001740 struct ib_uobject *uobject;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 u32 rkey;
Shani Michaeli7083e422013-02-06 16:19:12 +00001742 enum ib_mw_type type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743};
1744
1745struct ib_fmr {
1746 struct ib_device *device;
1747 struct ib_pd *pd;
1748 struct list_head list;
1749 u32 lkey;
1750 u32 rkey;
1751};
1752
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001753/* Supported steering options */
1754enum ib_flow_attr_type {
1755 /* steering according to rule specifications */
1756 IB_FLOW_ATTR_NORMAL = 0x0,
1757 /* default unicast and multicast rule -
1758 * receive all Eth traffic which isn't steered to any QP
1759 */
1760 IB_FLOW_ATTR_ALL_DEFAULT = 0x1,
1761 /* default multicast rule -
1762 * receive all Eth multicast traffic which isn't steered to any QP
1763 */
1764 IB_FLOW_ATTR_MC_DEFAULT = 0x2,
1765 /* sniffer rule - receive all port traffic */
1766 IB_FLOW_ATTR_SNIFFER = 0x3
1767};
1768
1769/* Supported steering header types */
1770enum ib_flow_spec_type {
1771 /* L2 headers*/
Moses Reuben76bd23b2016-11-14 19:04:48 +02001772 IB_FLOW_SPEC_ETH = 0x20,
1773 IB_FLOW_SPEC_IB = 0x22,
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001774 /* L3 header*/
Moses Reuben76bd23b2016-11-14 19:04:48 +02001775 IB_FLOW_SPEC_IPV4 = 0x30,
1776 IB_FLOW_SPEC_IPV6 = 0x31,
Matan Barak56ab0b32018-03-28 09:27:49 +03001777 IB_FLOW_SPEC_ESP = 0x34,
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001778 /* L4 headers*/
Moses Reuben76bd23b2016-11-14 19:04:48 +02001779 IB_FLOW_SPEC_TCP = 0x40,
1780 IB_FLOW_SPEC_UDP = 0x41,
Moses Reuben0dbf3332016-11-14 19:04:47 +02001781 IB_FLOW_SPEC_VXLAN_TUNNEL = 0x50,
Ariel Levkovichd90e5e52018-05-13 14:33:30 +03001782 IB_FLOW_SPEC_GRE = 0x51,
Ariel Levkovichb04f0f02018-05-13 14:33:32 +03001783 IB_FLOW_SPEC_MPLS = 0x60,
Moses Reubenfbf46862016-11-14 19:04:51 +02001784 IB_FLOW_SPEC_INNER = 0x100,
Moses Reuben460d0192017-01-18 14:59:48 +02001785 /* Actions */
1786 IB_FLOW_SPEC_ACTION_TAG = 0x1000,
Slava Shwartsman483a3962017-04-03 13:13:51 +03001787 IB_FLOW_SPEC_ACTION_DROP = 0x1001,
Matan Barak9b828442018-03-28 09:27:46 +03001788 IB_FLOW_SPEC_ACTION_HANDLE = 0x1002,
Raed Salem7eea23a2018-05-31 16:43:36 +03001789 IB_FLOW_SPEC_ACTION_COUNT = 0x1003,
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001790};
Matan Barak240ae002013-11-07 15:25:13 +02001791#define IB_FLOW_SPEC_LAYER_MASK 0xF0
Raed Salem7eea23a2018-05-31 16:43:36 +03001792#define IB_FLOW_SPEC_SUPPORT_LAYERS 10
Matan Barak22878db2013-09-01 18:39:52 +03001793
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001794/* Flow steering rule priority is set according to it's domain.
1795 * Lower domain value means higher priority.
1796 */
1797enum ib_flow_domain {
1798 IB_FLOW_DOMAIN_USER,
1799 IB_FLOW_DOMAIN_ETHTOOL,
1800 IB_FLOW_DOMAIN_RFS,
1801 IB_FLOW_DOMAIN_NIC,
1802 IB_FLOW_DOMAIN_NUM /* Must be last */
1803};
1804
Marina Varshavera3100a72016-02-18 18:31:05 +02001805enum ib_flow_flags {
1806 IB_FLOW_ATTR_FLAGS_DONT_TRAP = 1UL << 1, /* Continue match, no steal */
Boris Pismenny21e82d32018-03-28 09:27:47 +03001807 IB_FLOW_ATTR_FLAGS_EGRESS = 1UL << 2, /* Egress flow */
1808 IB_FLOW_ATTR_FLAGS_RESERVED = 1UL << 3 /* Must be last */
Marina Varshavera3100a72016-02-18 18:31:05 +02001809};
1810
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001811struct ib_flow_eth_filter {
1812 u8 dst_mac[6];
1813 u8 src_mac[6];
1814 __be16 ether_type;
1815 __be16 vlan_tag;
Maor Gottlieb15dfbd62016-08-30 16:58:32 +03001816 /* Must be last */
1817 u8 real_sz[0];
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001818};
1819
1820struct ib_flow_spec_eth {
Moses Reubenfbf46862016-11-14 19:04:51 +02001821 u32 type;
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001822 u16 size;
1823 struct ib_flow_eth_filter val;
1824 struct ib_flow_eth_filter mask;
1825};
1826
Matan Barak240ae002013-11-07 15:25:13 +02001827struct ib_flow_ib_filter {
1828 __be16 dlid;
1829 __u8 sl;
Maor Gottlieb15dfbd62016-08-30 16:58:32 +03001830 /* Must be last */
1831 u8 real_sz[0];
Matan Barak240ae002013-11-07 15:25:13 +02001832};
1833
1834struct ib_flow_spec_ib {
Moses Reubenfbf46862016-11-14 19:04:51 +02001835 u32 type;
Matan Barak240ae002013-11-07 15:25:13 +02001836 u16 size;
1837 struct ib_flow_ib_filter val;
1838 struct ib_flow_ib_filter mask;
1839};
1840
Maor Gottlieb989a3a82016-08-30 16:58:33 +03001841/* IPv4 header flags */
1842enum ib_ipv4_flags {
1843 IB_IPV4_DONT_FRAG = 0x2, /* Don't enable packet fragmentation */
1844 IB_IPV4_MORE_FRAG = 0X4 /* For All fragmented packets except the
1845 last have this flag set */
1846};
1847
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001848struct ib_flow_ipv4_filter {
1849 __be32 src_ip;
1850 __be32 dst_ip;
Maor Gottlieb989a3a82016-08-30 16:58:33 +03001851 u8 proto;
1852 u8 tos;
1853 u8 ttl;
1854 u8 flags;
Maor Gottlieb15dfbd62016-08-30 16:58:32 +03001855 /* Must be last */
1856 u8 real_sz[0];
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001857};
1858
1859struct ib_flow_spec_ipv4 {
Moses Reubenfbf46862016-11-14 19:04:51 +02001860 u32 type;
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001861 u16 size;
1862 struct ib_flow_ipv4_filter val;
1863 struct ib_flow_ipv4_filter mask;
1864};
1865
Maor Gottlieb4c2aae72016-06-17 15:14:50 +03001866struct ib_flow_ipv6_filter {
1867 u8 src_ip[16];
1868 u8 dst_ip[16];
Maor Gottlieba72c6a22016-08-30 16:58:34 +03001869 __be32 flow_label;
1870 u8 next_hdr;
1871 u8 traffic_class;
1872 u8 hop_limit;
Maor Gottlieb15dfbd62016-08-30 16:58:32 +03001873 /* Must be last */
1874 u8 real_sz[0];
Maor Gottlieb4c2aae72016-06-17 15:14:50 +03001875};
1876
1877struct ib_flow_spec_ipv6 {
Moses Reubenfbf46862016-11-14 19:04:51 +02001878 u32 type;
Maor Gottlieb4c2aae72016-06-17 15:14:50 +03001879 u16 size;
1880 struct ib_flow_ipv6_filter val;
1881 struct ib_flow_ipv6_filter mask;
1882};
1883
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001884struct ib_flow_tcp_udp_filter {
1885 __be16 dst_port;
1886 __be16 src_port;
Maor Gottlieb15dfbd62016-08-30 16:58:32 +03001887 /* Must be last */
1888 u8 real_sz[0];
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001889};
1890
1891struct ib_flow_spec_tcp_udp {
Moses Reubenfbf46862016-11-14 19:04:51 +02001892 u32 type;
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001893 u16 size;
1894 struct ib_flow_tcp_udp_filter val;
1895 struct ib_flow_tcp_udp_filter mask;
1896};
1897
Moses Reuben0dbf3332016-11-14 19:04:47 +02001898struct ib_flow_tunnel_filter {
1899 __be32 tunnel_id;
1900 u8 real_sz[0];
1901};
1902
1903/* ib_flow_spec_tunnel describes the Vxlan tunnel
1904 * the tunnel_id from val has the vni value
1905 */
1906struct ib_flow_spec_tunnel {
Moses Reubenfbf46862016-11-14 19:04:51 +02001907 u32 type;
Moses Reuben0dbf3332016-11-14 19:04:47 +02001908 u16 size;
1909 struct ib_flow_tunnel_filter val;
1910 struct ib_flow_tunnel_filter mask;
1911};
1912
Matan Barak56ab0b32018-03-28 09:27:49 +03001913struct ib_flow_esp_filter {
1914 __be32 spi;
1915 __be32 seq;
1916 /* Must be last */
1917 u8 real_sz[0];
1918};
1919
1920struct ib_flow_spec_esp {
1921 u32 type;
1922 u16 size;
1923 struct ib_flow_esp_filter val;
1924 struct ib_flow_esp_filter mask;
1925};
1926
Ariel Levkovichd90e5e52018-05-13 14:33:30 +03001927struct ib_flow_gre_filter {
1928 __be16 c_ks_res0_ver;
1929 __be16 protocol;
1930 __be32 key;
1931 /* Must be last */
1932 u8 real_sz[0];
1933};
1934
1935struct ib_flow_spec_gre {
1936 u32 type;
1937 u16 size;
1938 struct ib_flow_gre_filter val;
1939 struct ib_flow_gre_filter mask;
1940};
1941
Ariel Levkovichb04f0f02018-05-13 14:33:32 +03001942struct ib_flow_mpls_filter {
1943 __be32 tag;
1944 /* Must be last */
1945 u8 real_sz[0];
1946};
1947
1948struct ib_flow_spec_mpls {
1949 u32 type;
1950 u16 size;
1951 struct ib_flow_mpls_filter val;
1952 struct ib_flow_mpls_filter mask;
1953};
1954
Moses Reuben460d0192017-01-18 14:59:48 +02001955struct ib_flow_spec_action_tag {
1956 enum ib_flow_spec_type type;
1957 u16 size;
1958 u32 tag_id;
1959};
1960
Slava Shwartsman483a3962017-04-03 13:13:51 +03001961struct ib_flow_spec_action_drop {
1962 enum ib_flow_spec_type type;
1963 u16 size;
1964};
1965
Matan Barak9b828442018-03-28 09:27:46 +03001966struct ib_flow_spec_action_handle {
1967 enum ib_flow_spec_type type;
1968 u16 size;
1969 struct ib_flow_action *act;
1970};
1971
Raed Salem7eea23a2018-05-31 16:43:36 +03001972enum ib_counters_description {
1973 IB_COUNTER_PACKETS,
1974 IB_COUNTER_BYTES,
1975};
1976
1977struct ib_flow_spec_action_count {
1978 enum ib_flow_spec_type type;
1979 u16 size;
1980 struct ib_counters *counters;
1981};
1982
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001983union ib_flow_spec {
1984 struct {
Moses Reubenfbf46862016-11-14 19:04:51 +02001985 u32 type;
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001986 u16 size;
1987 };
1988 struct ib_flow_spec_eth eth;
Matan Barak240ae002013-11-07 15:25:13 +02001989 struct ib_flow_spec_ib ib;
Hadar Hen Zion319a4412013-08-07 14:01:59 +03001990 struct ib_flow_spec_ipv4 ipv4;
1991 struct ib_flow_spec_tcp_udp tcp_udp;
Maor Gottlieb4c2aae72016-06-17 15:14:50 +03001992 struct ib_flow_spec_ipv6 ipv6;
Moses Reuben0dbf3332016-11-14 19:04:47 +02001993 struct ib_flow_spec_tunnel tunnel;
Matan Barak56ab0b32018-03-28 09:27:49 +03001994 struct ib_flow_spec_esp esp;
Ariel Levkovichd90e5e52018-05-13 14:33:30 +03001995 struct ib_flow_spec_gre gre;
Ariel Levkovichb04f0f02018-05-13 14:33:32 +03001996 struct ib_flow_spec_mpls mpls;
Moses Reuben460d0192017-01-18 14:59:48 +02001997 struct ib_flow_spec_action_tag flow_tag;
Slava Shwartsman483a3962017-04-03 13:13:51 +03001998 struct ib_flow_spec_action_drop drop;
Matan Barak9b828442018-03-28 09:27:46 +03001999 struct ib_flow_spec_action_handle action;
Raed Salem7eea23a2018-05-31 16:43:36 +03002000 struct ib_flow_spec_action_count flow_count;
Hadar Hen Zion319a4412013-08-07 14:01:59 +03002001};
2002
2003struct ib_flow_attr {
2004 enum ib_flow_attr_type type;
2005 u16 size;
2006 u16 priority;
2007 u32 flags;
2008 u8 num_of_specs;
2009 u8 port;
Matthew Wilcox7654cb12018-06-07 07:57:16 -07002010 union ib_flow_spec flows[];
Hadar Hen Zion319a4412013-08-07 14:01:59 +03002011};
2012
2013struct ib_flow {
2014 struct ib_qp *qp;
Yishai Hadas6cd080a2018-07-23 15:25:08 +03002015 struct ib_device *device;
Hadar Hen Zion319a4412013-08-07 14:01:59 +03002016 struct ib_uobject *uobject;
2017};
2018
Matan Barak2eb9bea2018-03-28 09:27:45 +03002019enum ib_flow_action_type {
2020 IB_FLOW_ACTION_UNSPECIFIED,
2021 IB_FLOW_ACTION_ESP = 1,
2022};
2023
2024struct ib_flow_action_attrs_esp_keymats {
2025 enum ib_uverbs_flow_action_esp_keymat protocol;
2026 union {
2027 struct ib_uverbs_flow_action_esp_keymat_aes_gcm aes_gcm;
2028 } keymat;
2029};
2030
2031struct ib_flow_action_attrs_esp_replays {
2032 enum ib_uverbs_flow_action_esp_replay protocol;
2033 union {
2034 struct ib_uverbs_flow_action_esp_replay_bmp bmp;
2035 } replay;
2036};
2037
2038enum ib_flow_action_attrs_esp_flags {
2039 /* All user-space flags at the top: Use enum ib_uverbs_flow_action_esp_flags
2040 * This is done in order to share the same flags between user-space and
2041 * kernel and spare an unnecessary translation.
2042 */
2043
2044 /* Kernel flags */
2045 IB_FLOW_ACTION_ESP_FLAGS_ESN_TRIGGERED = 1ULL << 32,
Matan Barak7d12f8d2018-03-28 09:27:48 +03002046 IB_FLOW_ACTION_ESP_FLAGS_MOD_ESP_ATTRS = 1ULL << 33,
Matan Barak2eb9bea2018-03-28 09:27:45 +03002047};
2048
2049struct ib_flow_spec_list {
2050 struct ib_flow_spec_list *next;
2051 union ib_flow_spec spec;
2052};
2053
2054struct ib_flow_action_attrs_esp {
2055 struct ib_flow_action_attrs_esp_keymats *keymat;
2056 struct ib_flow_action_attrs_esp_replays *replay;
2057 struct ib_flow_spec_list *encap;
2058 /* Used only if IB_FLOW_ACTION_ESP_FLAGS_ESN_TRIGGERED is enabled.
2059 * Value of 0 is a valid value.
2060 */
2061 u32 esn;
2062 u32 spi;
2063 u32 seq;
2064 u32 tfc_pad;
2065 /* Use enum ib_flow_action_attrs_esp_flags */
2066 u64 flags;
2067 u64 hard_limit_pkts;
2068};
2069
2070struct ib_flow_action {
2071 struct ib_device *device;
2072 struct ib_uobject *uobject;
2073 enum ib_flow_action_type type;
2074 atomic_t usecnt;
2075};
2076
Ira Weiny4cd7c942015-06-06 14:38:31 -04002077struct ib_mad_hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078struct ib_grh;
2079
2080enum ib_process_mad_flags {
2081 IB_MAD_IGNORE_MKEY = 1,
2082 IB_MAD_IGNORE_BKEY = 2,
2083 IB_MAD_IGNORE_ALL = IB_MAD_IGNORE_MKEY | IB_MAD_IGNORE_BKEY
2084};
2085
2086enum ib_mad_result {
2087 IB_MAD_RESULT_FAILURE = 0, /* (!SUCCESS is the important flag) */
2088 IB_MAD_RESULT_SUCCESS = 1 << 0, /* MAD was successfully processed */
2089 IB_MAD_RESULT_REPLY = 1 << 1, /* Reply packet needs to be sent */
2090 IB_MAD_RESULT_CONSUMED = 1 << 2 /* Packet consumed: stop processing */
2091};
2092
Jack Wang21d64542017-01-17 10:11:12 +01002093struct ib_port_cache {
Daniel Jurgens883c71f2017-05-19 15:48:51 +03002094 u64 subnet_prefix;
Jack Wang21d64542017-01-17 10:11:12 +01002095 struct ib_pkey_cache *pkey;
2096 struct ib_gid_table *gid;
2097 u8 lmc;
2098 enum ib_port_state port_state;
2099};
2100
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101struct ib_cache {
2102 rwlock_t lock;
2103 struct ib_event_handler event_handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104};
2105
Ira Weiny77386132015-05-13 20:02:58 -04002106struct ib_port_immutable {
2107 int pkey_tbl_len;
2108 int gid_tbl_len;
Ira Weinyf9b22e32015-05-13 20:02:59 -04002109 u32 core_cap_flags;
Ira Weiny337877a2015-06-06 14:38:29 -04002110 u32 max_mad_size;
Ira Weiny77386132015-05-13 20:02:58 -04002111};
2112
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002113struct ib_port_data {
Jason Gunthorpe324e2272019-02-12 21:12:51 -07002114 struct ib_device *ib_dev;
2115
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002116 struct ib_port_immutable immutable;
2117
2118 spinlock_t pkey_list_lock;
2119 struct list_head pkey_list;
Jason Gunthorpe8faea9f2019-02-12 21:12:49 -07002120
2121 struct ib_port_cache cache;
Jason Gunthorpec2261dd2019-02-12 21:12:50 -07002122
2123 spinlock_t netdev_lock;
Jason Gunthorpe324e2272019-02-12 21:12:51 -07002124 struct net_device __rcu *netdev;
2125 struct hlist_node ndev_hash_link;
Mark Zhang413d3342019-07-02 13:02:34 +03002126 struct rdma_port_counter port_counter;
Mark Zhang6e7be472019-07-02 13:02:46 +03002127 struct rdma_hw_stats *hw_stats;
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002128};
2129
Vishwanathapura, Niranjana2fc77572017-04-12 20:29:20 -07002130/* rdma netdev type - specifies protocol type */
2131enum rdma_netdev_t {
Niranjana Vishwanathapuraf0ad83ac2017-04-10 11:22:25 +03002132 RDMA_NETDEV_OPA_VNIC,
2133 RDMA_NETDEV_IPOIB,
Vishwanathapura, Niranjana2fc77572017-04-12 20:29:20 -07002134};
2135
2136/**
2137 * struct rdma_netdev - rdma netdev
2138 * For cases where netstack interfacing is required.
2139 */
2140struct rdma_netdev {
2141 void *clnt_priv;
2142 struct ib_device *hca;
2143 u8 port_num;
2144
Jason Gunthorpe9f49a5b2018-07-29 11:34:56 +03002145 /*
2146 * cleanup function must be specified.
2147 * FIXME: This is only used for OPA_VNIC and that usage should be
2148 * removed too.
2149 */
Niranjana Vishwanathapura8e959602017-06-30 13:14:46 -07002150 void (*free_rdma_netdev)(struct net_device *netdev);
2151
Vishwanathapura, Niranjana2fc77572017-04-12 20:29:20 -07002152 /* control functions */
2153 void (*set_id)(struct net_device *netdev, int id);
Niranjana Vishwanathapuraf0ad83ac2017-04-10 11:22:25 +03002154 /* send packet */
2155 int (*send)(struct net_device *dev, struct sk_buff *skb,
2156 struct ib_ah *address, u32 dqpn);
2157 /* multicast */
2158 int (*attach_mcast)(struct net_device *dev, struct ib_device *hca,
2159 union ib_gid *gid, u16 mlid,
2160 int set_qkey, u32 qkey);
2161 int (*detach_mcast)(struct net_device *dev, struct ib_device *hca,
2162 union ib_gid *gid, u16 mlid);
Vishwanathapura, Niranjana2fc77572017-04-12 20:29:20 -07002163};
2164
Denis Drozdovf6a8a192018-08-14 14:08:51 +03002165struct rdma_netdev_alloc_params {
2166 size_t sizeof_priv;
2167 unsigned int txqs;
2168 unsigned int rxqs;
2169 void *param;
2170
2171 int (*initialize_rdma_netdev)(struct ib_device *device, u8 port_num,
2172 struct net_device *netdev, void *param);
2173};
2174
Raed Salemfa9b1802018-05-31 16:43:31 +03002175struct ib_counters {
2176 struct ib_device *device;
2177 struct ib_uobject *uobject;
2178 /* num of objects attached */
2179 atomic_t usecnt;
2180};
2181
Raed Salem51d7a532018-05-31 16:43:33 +03002182struct ib_counters_read_attr {
2183 u64 *counters_buff;
2184 u32 ncounters;
2185 u32 flags; /* use enum ib_read_counters_flags */
2186};
2187
Matan Barak2eb9bea2018-03-28 09:27:45 +03002188struct uverbs_attr_bundle;
Kamal Heibdd05cb82019-04-29 14:59:06 +03002189struct iw_cm_id;
2190struct iw_cm_conn_param;
Matan Barak2eb9bea2018-03-28 09:27:45 +03002191
Leon Romanovsky30471d42019-02-03 14:55:50 +02002192#define INIT_RDMA_OBJ_SIZE(ib_struct, drv_struct, member) \
2193 .size_##ib_struct = \
2194 (sizeof(struct drv_struct) + \
2195 BUILD_BUG_ON_ZERO(offsetof(struct drv_struct, member)) + \
2196 BUILD_BUG_ON_ZERO( \
2197 !__same_type(((struct drv_struct *)NULL)->member, \
2198 struct ib_struct)))
2199
Leon Romanovskyf6316032019-03-28 15:12:58 +02002200#define rdma_zalloc_drv_obj_gfp(ib_dev, ib_type, gfp) \
2201 ((struct ib_type *)kzalloc(ib_dev->ops.size_##ib_type, gfp))
2202
Leon Romanovsky30471d42019-02-03 14:55:50 +02002203#define rdma_zalloc_drv_obj(ib_dev, ib_type) \
Leon Romanovskyf6316032019-03-28 15:12:58 +02002204 rdma_zalloc_drv_obj_gfp(ib_dev, ib_type, GFP_KERNEL)
Leon Romanovsky30471d42019-02-03 14:55:50 +02002205
2206#define DECLARE_RDMA_OBJ_SIZE(ib_struct) size_t size_##ib_struct
2207
Kamal Heib521ed0d2018-12-10 21:09:30 +02002208/**
2209 * struct ib_device_ops - InfiniBand device operations
2210 * This structure defines all the InfiniBand device operations, providers will
2211 * need to define the supported operations, otherwise they will be set to null.
2212 */
2213struct ib_device_ops {
Jason Gunthorpe7a154142019-06-05 14:39:26 -03002214 struct module *owner;
Jason Gunthorpeb9560a42019-06-05 14:39:24 -03002215 enum rdma_driver_id driver_id;
Jason Gunthorpe72c6ec12019-06-05 14:39:25 -03002216 u32 uverbs_abi_ver;
Jason Gunthorpe8f71bb02019-06-13 21:38:19 -03002217 unsigned int uverbs_no_driver_id_binding:1;
Jason Gunthorpeb9560a42019-06-05 14:39:24 -03002218
Kamal Heib521ed0d2018-12-10 21:09:30 +02002219 int (*post_send)(struct ib_qp *qp, const struct ib_send_wr *send_wr,
2220 const struct ib_send_wr **bad_send_wr);
2221 int (*post_recv)(struct ib_qp *qp, const struct ib_recv_wr *recv_wr,
2222 const struct ib_recv_wr **bad_recv_wr);
2223 void (*drain_rq)(struct ib_qp *qp);
2224 void (*drain_sq)(struct ib_qp *qp);
2225 int (*poll_cq)(struct ib_cq *cq, int num_entries, struct ib_wc *wc);
2226 int (*peek_cq)(struct ib_cq *cq, int wc_cnt);
2227 int (*req_notify_cq)(struct ib_cq *cq, enum ib_cq_notify_flags flags);
2228 int (*req_ncomp_notif)(struct ib_cq *cq, int wc_cnt);
2229 int (*post_srq_recv)(struct ib_srq *srq,
2230 const struct ib_recv_wr *recv_wr,
2231 const struct ib_recv_wr **bad_recv_wr);
2232 int (*process_mad)(struct ib_device *device, int process_mad_flags,
2233 u8 port_num, const struct ib_wc *in_wc,
2234 const struct ib_grh *in_grh,
2235 const struct ib_mad_hdr *in_mad, size_t in_mad_size,
2236 struct ib_mad_hdr *out_mad, size_t *out_mad_size,
2237 u16 *out_mad_pkey_index);
2238 int (*query_device)(struct ib_device *device,
2239 struct ib_device_attr *device_attr,
2240 struct ib_udata *udata);
2241 int (*modify_device)(struct ib_device *device, int device_modify_mask,
2242 struct ib_device_modify *device_modify);
2243 void (*get_dev_fw_str)(struct ib_device *device, char *str);
2244 const struct cpumask *(*get_vector_affinity)(struct ib_device *ibdev,
2245 int comp_vector);
2246 int (*query_port)(struct ib_device *device, u8 port_num,
2247 struct ib_port_attr *port_attr);
2248 int (*modify_port)(struct ib_device *device, u8 port_num,
2249 int port_modify_mask,
2250 struct ib_port_modify *port_modify);
2251 /**
2252 * The following mandatory functions are used only at device
2253 * registration. Keep functions such as these at the end of this
2254 * structure to avoid cache line misses when accessing struct ib_device
2255 * in fast paths.
2256 */
2257 int (*get_port_immutable)(struct ib_device *device, u8 port_num,
2258 struct ib_port_immutable *immutable);
2259 enum rdma_link_layer (*get_link_layer)(struct ib_device *device,
2260 u8 port_num);
2261 /**
2262 * When calling get_netdev, the HW vendor's driver should return the
2263 * net device of device @device at port @port_num or NULL if such
2264 * a net device doesn't exist. The vendor driver should call dev_hold
2265 * on this net device. The HW vendor's device driver must guarantee
2266 * that this function returns NULL before the net device has finished
2267 * NETDEV_UNREGISTER state.
2268 */
2269 struct net_device *(*get_netdev)(struct ib_device *device, u8 port_num);
2270 /**
2271 * rdma netdev operation
2272 *
2273 * Driver implementing alloc_rdma_netdev or rdma_netdev_get_params
2274 * must return -EOPNOTSUPP if it doesn't support the specified type.
2275 */
2276 struct net_device *(*alloc_rdma_netdev)(
2277 struct ib_device *device, u8 port_num, enum rdma_netdev_t type,
2278 const char *name, unsigned char name_assign_type,
2279 void (*setup)(struct net_device *));
2280
2281 int (*rdma_netdev_get_params)(struct ib_device *device, u8 port_num,
2282 enum rdma_netdev_t type,
2283 struct rdma_netdev_alloc_params *params);
2284 /**
2285 * query_gid should be return GID value for @device, when @port_num
2286 * link layer is either IB or iWarp. It is no-op if @port_num port
2287 * is RoCE link layer.
2288 */
2289 int (*query_gid)(struct ib_device *device, u8 port_num, int index,
2290 union ib_gid *gid);
2291 /**
2292 * When calling add_gid, the HW vendor's driver should add the gid
2293 * of device of port at gid index available at @attr. Meta-info of
2294 * that gid (for example, the network device related to this gid) is
2295 * available at @attr. @context allows the HW vendor driver to store
2296 * extra information together with a GID entry. The HW vendor driver may
2297 * allocate memory to contain this information and store it in @context
2298 * when a new GID entry is written to. Params are consistent until the
2299 * next call of add_gid or delete_gid. The function should return 0 on
2300 * success or error otherwise. The function could be called
2301 * concurrently for different ports. This function is only called when
2302 * roce_gid_table is used.
2303 */
2304 int (*add_gid)(const struct ib_gid_attr *attr, void **context);
2305 /**
2306 * When calling del_gid, the HW vendor's driver should delete the
2307 * gid of device @device at gid index gid_index of port port_num
2308 * available in @attr.
2309 * Upon the deletion of a GID entry, the HW vendor must free any
2310 * allocated memory. The caller will clear @context afterwards.
2311 * This function is only called when roce_gid_table is used.
2312 */
2313 int (*del_gid)(const struct ib_gid_attr *attr, void **context);
2314 int (*query_pkey)(struct ib_device *device, u8 port_num, u16 index,
2315 u16 *pkey);
Leon Romanovskya2a074e2019-02-12 20:39:16 +02002316 int (*alloc_ucontext)(struct ib_ucontext *context,
2317 struct ib_udata *udata);
2318 void (*dealloc_ucontext)(struct ib_ucontext *context);
Kamal Heib521ed0d2018-12-10 21:09:30 +02002319 int (*mmap)(struct ib_ucontext *context, struct vm_area_struct *vma);
2320 void (*disassociate_ucontext)(struct ib_ucontext *ibcontext);
Shamir Rabinovitchff23dfa2019-03-31 19:10:07 +03002321 int (*alloc_pd)(struct ib_pd *pd, struct ib_udata *udata);
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03002322 void (*dealloc_pd)(struct ib_pd *pd, struct ib_udata *udata);
Leon Romanovskyd3456912019-04-03 16:42:42 +03002323 int (*create_ah)(struct ib_ah *ah, struct rdma_ah_attr *ah_attr,
2324 u32 flags, struct ib_udata *udata);
Kamal Heib521ed0d2018-12-10 21:09:30 +02002325 int (*modify_ah)(struct ib_ah *ah, struct rdma_ah_attr *ah_attr);
2326 int (*query_ah)(struct ib_ah *ah, struct rdma_ah_attr *ah_attr);
Leon Romanovskyd3456912019-04-03 16:42:42 +03002327 void (*destroy_ah)(struct ib_ah *ah, u32 flags);
Leon Romanovsky68e326d2019-04-03 16:42:43 +03002328 int (*create_srq)(struct ib_srq *srq,
2329 struct ib_srq_init_attr *srq_init_attr,
2330 struct ib_udata *udata);
Kamal Heib521ed0d2018-12-10 21:09:30 +02002331 int (*modify_srq)(struct ib_srq *srq, struct ib_srq_attr *srq_attr,
2332 enum ib_srq_attr_mask srq_attr_mask,
2333 struct ib_udata *udata);
2334 int (*query_srq)(struct ib_srq *srq, struct ib_srq_attr *srq_attr);
Leon Romanovsky68e326d2019-04-03 16:42:43 +03002335 void (*destroy_srq)(struct ib_srq *srq, struct ib_udata *udata);
Kamal Heib521ed0d2018-12-10 21:09:30 +02002336 struct ib_qp *(*create_qp)(struct ib_pd *pd,
2337 struct ib_qp_init_attr *qp_init_attr,
2338 struct ib_udata *udata);
2339 int (*modify_qp)(struct ib_qp *qp, struct ib_qp_attr *qp_attr,
2340 int qp_attr_mask, struct ib_udata *udata);
2341 int (*query_qp)(struct ib_qp *qp, struct ib_qp_attr *qp_attr,
2342 int qp_attr_mask, struct ib_qp_init_attr *qp_init_attr);
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03002343 int (*destroy_qp)(struct ib_qp *qp, struct ib_udata *udata);
Leon Romanovskye39afe32019-05-28 14:37:29 +03002344 int (*create_cq)(struct ib_cq *cq, const struct ib_cq_init_attr *attr,
2345 struct ib_udata *udata);
Kamal Heib521ed0d2018-12-10 21:09:30 +02002346 int (*modify_cq)(struct ib_cq *cq, u16 cq_count, u16 cq_period);
Leon Romanovskya52c8e22019-05-28 14:37:28 +03002347 void (*destroy_cq)(struct ib_cq *cq, struct ib_udata *udata);
Kamal Heib521ed0d2018-12-10 21:09:30 +02002348 int (*resize_cq)(struct ib_cq *cq, int cqe, struct ib_udata *udata);
2349 struct ib_mr *(*get_dma_mr)(struct ib_pd *pd, int mr_access_flags);
2350 struct ib_mr *(*reg_user_mr)(struct ib_pd *pd, u64 start, u64 length,
2351 u64 virt_addr, int mr_access_flags,
2352 struct ib_udata *udata);
2353 int (*rereg_user_mr)(struct ib_mr *mr, int flags, u64 start, u64 length,
2354 u64 virt_addr, int mr_access_flags,
2355 struct ib_pd *pd, struct ib_udata *udata);
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03002356 int (*dereg_mr)(struct ib_mr *mr, struct ib_udata *udata);
Kamal Heib521ed0d2018-12-10 21:09:30 +02002357 struct ib_mr *(*alloc_mr)(struct ib_pd *pd, enum ib_mr_type mr_type,
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03002358 u32 max_num_sg, struct ib_udata *udata);
Israel Rukshin26bc7ea2019-06-11 18:52:39 +03002359 struct ib_mr *(*alloc_mr_integrity)(struct ib_pd *pd,
2360 u32 max_num_data_sg,
2361 u32 max_num_meta_sg);
Moni Shouaad8a4492018-12-11 13:37:52 +02002362 int (*advise_mr)(struct ib_pd *pd,
2363 enum ib_uverbs_advise_mr_advice advice, u32 flags,
2364 struct ib_sge *sg_list, u32 num_sge,
2365 struct uverbs_attr_bundle *attrs);
Kamal Heib521ed0d2018-12-10 21:09:30 +02002366 int (*map_mr_sg)(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,
2367 unsigned int *sg_offset);
2368 int (*check_mr_status)(struct ib_mr *mr, u32 check_mask,
2369 struct ib_mr_status *mr_status);
2370 struct ib_mw *(*alloc_mw)(struct ib_pd *pd, enum ib_mw_type type,
2371 struct ib_udata *udata);
2372 int (*dealloc_mw)(struct ib_mw *mw);
2373 struct ib_fmr *(*alloc_fmr)(struct ib_pd *pd, int mr_access_flags,
2374 struct ib_fmr_attr *fmr_attr);
2375 int (*map_phys_fmr)(struct ib_fmr *fmr, u64 *page_list, int list_len,
2376 u64 iova);
2377 int (*unmap_fmr)(struct list_head *fmr_list);
2378 int (*dealloc_fmr)(struct ib_fmr *fmr);
2379 int (*attach_mcast)(struct ib_qp *qp, union ib_gid *gid, u16 lid);
2380 int (*detach_mcast)(struct ib_qp *qp, union ib_gid *gid, u16 lid);
2381 struct ib_xrcd *(*alloc_xrcd)(struct ib_device *device,
Kamal Heib521ed0d2018-12-10 21:09:30 +02002382 struct ib_udata *udata);
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03002383 int (*dealloc_xrcd)(struct ib_xrcd *xrcd, struct ib_udata *udata);
Kamal Heib521ed0d2018-12-10 21:09:30 +02002384 struct ib_flow *(*create_flow)(struct ib_qp *qp,
2385 struct ib_flow_attr *flow_attr,
2386 int domain, struct ib_udata *udata);
2387 int (*destroy_flow)(struct ib_flow *flow_id);
2388 struct ib_flow_action *(*create_flow_action_esp)(
2389 struct ib_device *device,
2390 const struct ib_flow_action_attrs_esp *attr,
2391 struct uverbs_attr_bundle *attrs);
2392 int (*destroy_flow_action)(struct ib_flow_action *action);
2393 int (*modify_flow_action_esp)(
2394 struct ib_flow_action *action,
2395 const struct ib_flow_action_attrs_esp *attr,
2396 struct uverbs_attr_bundle *attrs);
2397 int (*set_vf_link_state)(struct ib_device *device, int vf, u8 port,
2398 int state);
2399 int (*get_vf_config)(struct ib_device *device, int vf, u8 port,
2400 struct ifla_vf_info *ivf);
2401 int (*get_vf_stats)(struct ib_device *device, int vf, u8 port,
2402 struct ifla_vf_stats *stats);
2403 int (*set_vf_guid)(struct ib_device *device, int vf, u8 port, u64 guid,
2404 int type);
2405 struct ib_wq *(*create_wq)(struct ib_pd *pd,
2406 struct ib_wq_init_attr *init_attr,
2407 struct ib_udata *udata);
Leon Romanovskya49b1dc2019-06-12 15:27:41 +03002408 void (*destroy_wq)(struct ib_wq *wq, struct ib_udata *udata);
Kamal Heib521ed0d2018-12-10 21:09:30 +02002409 int (*modify_wq)(struct ib_wq *wq, struct ib_wq_attr *attr,
2410 u32 wq_attr_mask, struct ib_udata *udata);
2411 struct ib_rwq_ind_table *(*create_rwq_ind_table)(
2412 struct ib_device *device,
2413 struct ib_rwq_ind_table_init_attr *init_attr,
2414 struct ib_udata *udata);
2415 int (*destroy_rwq_ind_table)(struct ib_rwq_ind_table *wq_ind_table);
2416 struct ib_dm *(*alloc_dm)(struct ib_device *device,
2417 struct ib_ucontext *context,
2418 struct ib_dm_alloc_attr *attr,
2419 struct uverbs_attr_bundle *attrs);
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03002420 int (*dealloc_dm)(struct ib_dm *dm, struct uverbs_attr_bundle *attrs);
Kamal Heib521ed0d2018-12-10 21:09:30 +02002421 struct ib_mr *(*reg_dm_mr)(struct ib_pd *pd, struct ib_dm *dm,
2422 struct ib_dm_mr_attr *attr,
2423 struct uverbs_attr_bundle *attrs);
2424 struct ib_counters *(*create_counters)(
2425 struct ib_device *device, struct uverbs_attr_bundle *attrs);
2426 int (*destroy_counters)(struct ib_counters *counters);
2427 int (*read_counters)(struct ib_counters *counters,
2428 struct ib_counters_read_attr *counters_read_attr,
2429 struct uverbs_attr_bundle *attrs);
Max Gurtovoy2cdfcdd2019-06-11 18:52:40 +03002430 int (*map_mr_sg_pi)(struct ib_mr *mr, struct scatterlist *data_sg,
2431 int data_sg_nents, unsigned int *data_sg_offset,
2432 struct scatterlist *meta_sg, int meta_sg_nents,
2433 unsigned int *meta_sg_offset);
2434
Kamal Heib521ed0d2018-12-10 21:09:30 +02002435 /**
2436 * alloc_hw_stats - Allocate a struct rdma_hw_stats and fill in the
2437 * driver initialized data. The struct is kfree()'ed by the sysfs
2438 * core when the device is removed. A lifespan of -1 in the return
2439 * struct tells the core to set a default lifespan.
2440 */
2441 struct rdma_hw_stats *(*alloc_hw_stats)(struct ib_device *device,
2442 u8 port_num);
2443 /**
2444 * get_hw_stats - Fill in the counter value(s) in the stats struct.
2445 * @index - The index in the value array we wish to have updated, or
2446 * num_counters if we want all stats updated
2447 * Return codes -
2448 * < 0 - Error, no counters updated
2449 * index - Updated the single counter pointed to by index
2450 * num_counters - Updated all counters (will reset the timestamp
2451 * and prevent further calls for lifespan milliseconds)
2452 * Drivers are allowed to update all counters in leiu of just the
2453 * one given in index at their option
2454 */
2455 int (*get_hw_stats)(struct ib_device *device,
2456 struct rdma_hw_stats *stats, u8 port, int index);
Parav Panditea4baf72018-12-18 14:28:30 +02002457 /*
2458 * This function is called once for each port when a ib device is
2459 * registered.
2460 */
2461 int (*init_port)(struct ib_device *device, u8 port_num,
2462 struct kobject *port_sysfs);
Leon Romanovsky02da3752019-01-30 12:49:02 +02002463 /**
2464 * Allows rdma drivers to add their own restrack attributes.
2465 */
2466 int (*fill_res_entry)(struct sk_buff *msg,
2467 struct rdma_restrack_entry *entry);
Leon Romanovsky21a428a2019-02-03 14:55:51 +02002468
Jason Gunthorped0899892019-02-12 21:12:53 -07002469 /* Device lifecycle callbacks */
2470 /*
Jason Gunthorpeca223542019-02-12 21:12:56 -07002471 * Called after the device becomes registered, before clients are
2472 * attached
2473 */
2474 int (*enable_driver)(struct ib_device *dev);
2475 /*
Jason Gunthorped0899892019-02-12 21:12:53 -07002476 * This is called as part of ib_dealloc_device().
2477 */
2478 void (*dealloc_driver)(struct ib_device *dev);
2479
Kamal Heibdd05cb82019-04-29 14:59:06 +03002480 /* iWarp CM callbacks */
2481 void (*iw_add_ref)(struct ib_qp *qp);
2482 void (*iw_rem_ref)(struct ib_qp *qp);
2483 struct ib_qp *(*iw_get_qp)(struct ib_device *device, int qpn);
2484 int (*iw_connect)(struct iw_cm_id *cm_id,
2485 struct iw_cm_conn_param *conn_param);
2486 int (*iw_accept)(struct iw_cm_id *cm_id,
2487 struct iw_cm_conn_param *conn_param);
2488 int (*iw_reject)(struct iw_cm_id *cm_id, const void *pdata,
2489 u8 pdata_len);
2490 int (*iw_create_listen)(struct iw_cm_id *cm_id, int backlog);
2491 int (*iw_destroy_listen)(struct iw_cm_id *cm_id);
Mark Zhang99fa3312019-07-02 13:02:35 +03002492 /**
2493 * counter_bind_qp - Bind a QP to a counter.
2494 * @counter - The counter to be bound. If counter->id is zero then
2495 * the driver needs to allocate a new counter and set counter->id
2496 */
2497 int (*counter_bind_qp)(struct rdma_counter *counter, struct ib_qp *qp);
2498 /**
2499 * counter_unbind_qp - Unbind the qp from the dynamically-allocated
2500 * counter and bind it onto the default one
2501 */
2502 int (*counter_unbind_qp)(struct ib_qp *qp);
2503 /**
2504 * counter_dealloc -De-allocate the hw counter
2505 */
2506 int (*counter_dealloc)(struct rdma_counter *counter);
Mark Zhangc4ffee72019-07-02 13:02:40 +03002507 /**
2508 * counter_alloc_stats - Allocate a struct rdma_hw_stats and fill in
2509 * the driver initialized data.
2510 */
2511 struct rdma_hw_stats *(*counter_alloc_stats)(
2512 struct rdma_counter *counter);
2513 /**
2514 * counter_update_stats - Query the stats value of this counter
2515 */
2516 int (*counter_update_stats)(struct rdma_counter *counter);
Kamal Heibdd05cb82019-04-29 14:59:06 +03002517
Leon Romanovskyd3456912019-04-03 16:42:42 +03002518 DECLARE_RDMA_OBJ_SIZE(ib_ah);
Leon Romanovskye39afe32019-05-28 14:37:29 +03002519 DECLARE_RDMA_OBJ_SIZE(ib_cq);
Leon Romanovsky21a428a2019-02-03 14:55:51 +02002520 DECLARE_RDMA_OBJ_SIZE(ib_pd);
Leon Romanovsky68e326d2019-04-03 16:42:43 +03002521 DECLARE_RDMA_OBJ_SIZE(ib_srq);
Leon Romanovskya2a074e2019-02-12 20:39:16 +02002522 DECLARE_RDMA_OBJ_SIZE(ib_ucontext);
Kamal Heib521ed0d2018-12-10 21:09:30 +02002523};
2524
Parav Panditcebe5562019-02-26 13:56:11 +02002525struct ib_core_device {
2526 /* device must be the first element in structure until,
2527 * union of ib_core_device and device exists in ib_device.
2528 */
2529 struct device dev;
Parav Pandit4e0f7b92019-02-26 13:56:13 +02002530 possible_net_t rdma_net;
Parav Panditcebe5562019-02-26 13:56:11 +02002531 struct kobject *ports_kobj;
2532 struct list_head port_list;
2533 struct ib_device *owner; /* reach back to owner ib_device */
2534};
Leon Romanovsky41eda652019-02-18 22:25:47 +02002535
Parav Panditcebe5562019-02-26 13:56:11 +02002536struct rdma_restrack_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002537struct ib_device {
Bart Van Assche0957c292017-03-07 22:56:53 +00002538 /* Do not access @dma_device directly from ULP nor from HW drivers. */
2539 struct device *dma_device;
Kamal Heib3023a1e2018-12-10 21:09:48 +02002540 struct ib_device_ops ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541 char name[IB_DEVICE_NAME_MAX];
Jason Gunthorpe324e2272019-02-12 21:12:51 -07002542 struct rcu_head rcu_head;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543
2544 struct list_head event_handler_list;
2545 spinlock_t event_handler_lock;
2546
Jason Gunthorpe921eab12019-02-06 22:41:54 -07002547 struct rw_semaphore client_data_rwsem;
Jason Gunthorpe0df91bb2019-02-06 22:41:53 -07002548 struct xarray client_data;
Jason Gunthorped0899892019-02-12 21:12:53 -07002549 struct mutex unregistration_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550
2551 struct ib_cache cache;
Ira Weiny77386132015-05-13 20:02:58 -04002552 /**
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002553 * port_data is indexed by port number
Ira Weiny77386132015-05-13 20:02:58 -04002554 */
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002555 struct ib_port_data *port_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002556
Michael S. Tsirkinf4fd0b22007-05-03 13:48:47 +03002557 int num_comp_vectors;
2558
Parav Panditcebe5562019-02-26 13:56:11 +02002559 union {
2560 struct device dev;
2561 struct ib_core_device coredev;
2562 };
2563
Parav Panditd4122f52018-10-11 22:31:53 +03002564 /* First group for device attributes,
2565 * Second group for driver provided attributes (optional).
2566 * It is NULL terminated array.
2567 */
2568 const struct attribute_group *groups[3];
Parav Panditadee9f32018-09-05 09:47:58 +03002569
Alexander Chiang17a55f72010-02-02 19:09:16 +00002570 u64 uverbs_cmd_mask;
Yann Droneaudf21519b2013-11-06 23:21:49 +01002571 u64 uverbs_ex_cmd_mask;
Roland Dreier274c0892005-09-29 14:17:48 -07002572
Yuval Shaiabd99fde2016-08-25 10:57:07 -07002573 char node_desc[IB_DEVICE_NODE_DESC_MAX];
Sean Heftycf311cd2006-01-10 07:39:34 -08002574 __be64 node_guid;
Steve Wise96f15c02008-07-14 23:48:53 -07002575 u32 local_dma_lkey;
Hal Rosenstock41390322015-06-29 09:57:00 -04002576 u16 is_switch:1;
Gal Pressman6780c4f2019-01-22 10:08:22 +02002577 /* Indicates kernel verbs support, should not be used in drivers */
2578 u16 kverbs_provider:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579 u8 node_type;
2580 u8 phys_port_cnt;
Ira Weiny3e153a92015-12-18 10:59:44 +02002581 struct ib_device_attr attrs;
Christoph Lameterb40f4752016-05-16 12:49:33 -05002582 struct attribute_group *hw_stats_ag;
2583 struct rdma_hw_stats *hw_stats;
Ira Weiny77386132015-05-13 20:02:58 -04002584
Parav Pandit43579b52017-01-10 00:02:14 +00002585#ifdef CONFIG_CGROUP_RDMA
2586 struct rdmacg_device cg_device;
2587#endif
2588
Leon Romanovskyecc82c52017-06-18 14:39:59 +03002589 u32 index;
Leon Romanovsky41eda652019-02-18 22:25:47 +02002590 struct rdma_restrack_root *res;
Leon Romanovskyecc82c52017-06-18 14:39:59 +03002591
Jason Gunthorpe0cbf4322018-11-12 22:59:50 +02002592 const struct uapi_definition *driver_def;
Jason Gunthorped79af722019-01-10 14:02:24 -07002593
Parav Pandit01b67112018-11-16 03:50:57 +02002594 /*
Jason Gunthorped79af722019-01-10 14:02:24 -07002595 * Positive refcount indicates that the device is currently
2596 * registered and cannot be unregistered.
Parav Pandit01b67112018-11-16 03:50:57 +02002597 */
2598 refcount_t refcount;
2599 struct completion unreg_completion;
Jason Gunthorped0899892019-02-12 21:12:53 -07002600 struct work_struct unregistration_work;
Steve Wise3856ec42019-02-15 11:03:53 -08002601
2602 const struct rdma_link_ops *link_ops;
Parav Pandit4e0f7b92019-02-26 13:56:13 +02002603
2604 /* Protects compat_devs xarray modifications */
2605 struct mutex compat_devs_mutex;
2606 /* Maintains compat devices for each net namespace */
2607 struct xarray compat_devs;
Kamal Heibdd05cb82019-04-29 14:59:06 +03002608
2609 /* Used by iWarp CM */
2610 char iw_ifname[IFNAMSIZ];
2611 u32 iw_driver_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612};
2613
Jason Gunthorpe0e2d00e2019-06-13 21:38:18 -03002614struct ib_client_nl_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615struct ib_client {
Jason Gunthorpee59178d2019-02-06 22:41:52 -07002616 const char *name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617 void (*add) (struct ib_device *);
Haggai Eran7c1eb452015-07-30 17:50:14 +03002618 void (*remove)(struct ib_device *, void *client_data);
Leon Romanovskydc1435c2019-05-17 15:43:10 +03002619 void (*rename)(struct ib_device *dev, void *client_data);
Jason Gunthorpe0e2d00e2019-06-13 21:38:18 -03002620 int (*get_nl_info)(struct ib_device *ibdev, void *client_data,
2621 struct ib_client_nl_info *res);
2622 int (*get_global_nl_info)(struct ib_client_nl_info *res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623
Yotam Kenneth9268f722015-07-30 17:50:15 +03002624 /* Returns the net_dev belonging to this ib_client and matching the
2625 * given parameters.
2626 * @dev: An RDMA device that the net_dev use for communication.
2627 * @port: A physical port number on the RDMA device.
2628 * @pkey: P_Key that the net_dev uses if applicable.
2629 * @gid: A GID that the net_dev uses to communicate.
2630 * @addr: An IP address the net_dev is configured with.
2631 * @client_data: The device's client data set by ib_set_client_data().
2632 *
2633 * An ib_client that implements a net_dev on top of RDMA devices
2634 * (such as IP over IB) should implement this callback, allowing the
2635 * rdma_cm module to find the right net_dev for a given request.
2636 *
2637 * The caller is responsible for calling dev_put on the returned
2638 * netdev. */
2639 struct net_device *(*get_net_dev_by_params)(
2640 struct ib_device *dev,
2641 u8 port,
2642 u16 pkey,
2643 const union ib_gid *gid,
2644 const struct sockaddr *addr,
2645 void *client_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002646 struct list_head list;
Jason Gunthorpee59178d2019-02-06 22:41:52 -07002647 u32 client_id;
Gal Pressman6780c4f2019-01-22 10:08:22 +02002648
2649 /* kverbs are not required by the client */
2650 u8 no_kverbs_req:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002651};
2652
Shiraz Saleema8082732019-05-06 08:53:33 -05002653/*
2654 * IB block DMA iterator
2655 *
2656 * Iterates the DMA-mapped SGL in contiguous memory blocks aligned
2657 * to a HW supported page size.
2658 */
2659struct ib_block_iter {
2660 /* internal states */
2661 struct scatterlist *__sg; /* sg holding the current aligned block */
2662 dma_addr_t __dma_addr; /* unaligned DMA address of this block */
2663 unsigned int __sg_nents; /* number of SG entries */
2664 unsigned int __sg_advance; /* number of bytes to advance in sg in next step */
2665 unsigned int __pg_bit; /* alignment of current block */
2666};
2667
Leon Romanovsky459cc692019-01-30 12:49:11 +02002668struct ib_device *_ib_alloc_device(size_t size);
2669#define ib_alloc_device(drv_struct, member) \
2670 container_of(_ib_alloc_device(sizeof(struct drv_struct) + \
2671 BUILD_BUG_ON_ZERO(offsetof( \
2672 struct drv_struct, member))), \
2673 struct drv_struct, member)
2674
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675void ib_dealloc_device(struct ib_device *device);
2676
Leon Romanovsky9abb0d12017-06-27 16:49:53 +03002677void ib_get_device_fw_str(struct ib_device *device, char *str);
Ira Weiny5fa76c22016-06-15 02:21:56 -04002678
Parav Panditea4baf72018-12-18 14:28:30 +02002679int ib_register_device(struct ib_device *device, const char *name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680void ib_unregister_device(struct ib_device *device);
Jason Gunthorped0899892019-02-12 21:12:53 -07002681void ib_unregister_driver(enum rdma_driver_id driver_id);
2682void ib_unregister_device_and_put(struct ib_device *device);
2683void ib_unregister_device_queued(struct ib_device *ib_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684
2685int ib_register_client (struct ib_client *client);
2686void ib_unregister_client(struct ib_client *client);
2687
Shiraz Saleema8082732019-05-06 08:53:33 -05002688void __rdma_block_iter_start(struct ib_block_iter *biter,
2689 struct scatterlist *sglist,
2690 unsigned int nents,
2691 unsigned long pgsz);
2692bool __rdma_block_iter_next(struct ib_block_iter *biter);
2693
2694/**
2695 * rdma_block_iter_dma_address - get the aligned dma address of the current
2696 * block held by the block iterator.
2697 * @biter: block iterator holding the memory block
2698 */
2699static inline dma_addr_t
2700rdma_block_iter_dma_address(struct ib_block_iter *biter)
2701{
2702 return biter->__dma_addr & ~(BIT_ULL(biter->__pg_bit) - 1);
2703}
2704
2705/**
2706 * rdma_for_each_block - iterate over contiguous memory blocks of the sg list
2707 * @sglist: sglist to iterate over
2708 * @biter: block iterator holding the memory block
2709 * @nents: maximum number of sg entries to iterate over
2710 * @pgsz: best HW supported page size to use
2711 *
2712 * Callers may use rdma_block_iter_dma_address() to get each
2713 * blocks aligned DMA address.
2714 */
2715#define rdma_for_each_block(sglist, biter, nents, pgsz) \
2716 for (__rdma_block_iter_start(biter, sglist, nents, \
2717 pgsz); \
2718 __rdma_block_iter_next(biter);)
2719
Jason Gunthorpe0df91bb2019-02-06 22:41:53 -07002720/**
2721 * ib_get_client_data - Get IB client context
2722 * @device:Device to get context for
2723 * @client:Client to get context for
2724 *
2725 * ib_get_client_data() returns the client context data set with
2726 * ib_set_client_data(). This can only be called while the client is
2727 * registered to the device, once the ib_client remove() callback returns this
2728 * cannot be called.
2729 */
2730static inline void *ib_get_client_data(struct ib_device *device,
2731 struct ib_client *client)
2732{
2733 return xa_load(&device->client_data, client->client_id);
2734}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002735void ib_set_client_data(struct ib_device *device, struct ib_client *client,
2736 void *data);
Kamal Heib521ed0d2018-12-10 21:09:30 +02002737void ib_set_device_ops(struct ib_device *device,
2738 const struct ib_device_ops *ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739
Jason Gunthorpe5f9794d2018-09-16 20:43:08 +03002740#if IS_ENABLED(CONFIG_INFINIBAND_USER_ACCESS)
2741int rdma_user_mmap_io(struct ib_ucontext *ucontext, struct vm_area_struct *vma,
2742 unsigned long pfn, unsigned long size, pgprot_t prot);
Jason Gunthorpe5f9794d2018-09-16 20:43:08 +03002743#else
2744static inline int rdma_user_mmap_io(struct ib_ucontext *ucontext,
2745 struct vm_area_struct *vma,
2746 unsigned long pfn, unsigned long size,
2747 pgprot_t prot)
2748{
2749 return -EINVAL;
2750}
Jason Gunthorpe5f9794d2018-09-16 20:43:08 +03002751#endif
2752
Roland Dreiere2773c02005-07-07 17:57:10 -07002753static inline int ib_copy_from_udata(void *dest, struct ib_udata *udata, size_t len)
2754{
2755 return copy_from_user(dest, udata->inbuf, len) ? -EFAULT : 0;
2756}
2757
2758static inline int ib_copy_to_udata(struct ib_udata *udata, void *src, size_t len)
2759{
Yann Droneaud43c611652015-02-05 22:10:18 +01002760 return copy_to_user(udata->outbuf, src, len) ? -EFAULT : 0;
Roland Dreiere2773c02005-07-07 17:57:10 -07002761}
2762
Matan Barakc66db312018-03-19 15:02:36 +02002763static inline bool ib_is_buffer_cleared(const void __user *p,
2764 size_t len)
Matan Barak301a7212015-12-15 20:30:10 +02002765{
Markus Elfring92d27ae2016-08-22 18:23:24 +02002766 bool ret;
Matan Barak301a7212015-12-15 20:30:10 +02002767 u8 *buf;
2768
2769 if (len > USHRT_MAX)
2770 return false;
2771
Markus Elfring92d27ae2016-08-22 18:23:24 +02002772 buf = memdup_user(p, len);
2773 if (IS_ERR(buf))
Matan Barak301a7212015-12-15 20:30:10 +02002774 return false;
2775
Matan Barak301a7212015-12-15 20:30:10 +02002776 ret = !memchr_inv(buf, 0, len);
Matan Barak301a7212015-12-15 20:30:10 +02002777 kfree(buf);
2778 return ret;
2779}
2780
Matan Barakc66db312018-03-19 15:02:36 +02002781static inline bool ib_is_udata_cleared(struct ib_udata *udata,
2782 size_t offset,
2783 size_t len)
2784{
2785 return ib_is_buffer_cleared(udata->inbuf + offset, len);
2786}
2787
Roland Dreier8a518662006-02-13 12:48:12 -08002788/**
Yishai Hadas1c774832018-06-20 17:11:39 +03002789 * ib_is_destroy_retryable - Check whether the uobject destruction
2790 * is retryable.
2791 * @ret: The initial destruction return code
2792 * @why: remove reason
2793 * @uobj: The uobject that is destroyed
2794 *
2795 * This function is a helper function that IB layer and low-level drivers
2796 * can use to consider whether the destruction of the given uobject is
2797 * retry-able.
2798 * It checks the original return code, if it wasn't success the destruction
2799 * is retryable according to the ucontext state (i.e. cleanup_retryable) and
2800 * the remove reason. (i.e. why).
2801 * Must be called with the object locked for destroy.
2802 */
2803static inline bool ib_is_destroy_retryable(int ret, enum rdma_remove_reason why,
2804 struct ib_uobject *uobj)
2805{
2806 return ret && (why == RDMA_REMOVE_DESTROY ||
2807 uobj->context->cleanup_retryable);
2808}
2809
2810/**
2811 * ib_destroy_usecnt - Called during destruction to check the usecnt
2812 * @usecnt: The usecnt atomic
2813 * @why: remove reason
2814 * @uobj: The uobject that is destroyed
2815 *
2816 * Non-zero usecnts will block destruction unless destruction was triggered by
2817 * a ucontext cleanup.
2818 */
2819static inline int ib_destroy_usecnt(atomic_t *usecnt,
2820 enum rdma_remove_reason why,
2821 struct ib_uobject *uobj)
2822{
2823 if (atomic_read(usecnt) && ib_is_destroy_retryable(-EBUSY, why, uobj))
2824 return -EBUSY;
2825 return 0;
2826}
2827
2828/**
Roland Dreier8a518662006-02-13 12:48:12 -08002829 * ib_modify_qp_is_ok - Check that the supplied attribute mask
2830 * contains all required attributes and no attributes not allowed for
2831 * the given QP state transition.
2832 * @cur_state: Current QP state
2833 * @next_state: Next QP state
2834 * @type: QP type
2835 * @mask: Mask of supplied QP attributes
2836 *
2837 * This function is a helper function that a low-level driver's
2838 * modify_qp method can use to validate the consumer's input. It
2839 * checks that cur_state and next_state are valid QP states, that a
2840 * transition from cur_state to next_state is allowed by the IB spec,
2841 * and that the attribute mask supplied is allowed for the transition.
2842 */
Leon Romanovsky19b1f542018-03-11 13:51:35 +02002843bool ib_modify_qp_is_ok(enum ib_qp_state cur_state, enum ib_qp_state next_state,
Kamal Heibd31131b2018-10-02 16:11:21 +03002844 enum ib_qp_type type, enum ib_qp_attr_mask mask);
Roland Dreier8a518662006-02-13 12:48:12 -08002845
Leon Romanovskydcc98812017-08-17 15:50:36 +03002846void ib_register_event_handler(struct ib_event_handler *event_handler);
2847void ib_unregister_event_handler(struct ib_event_handler *event_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848void ib_dispatch_event(struct ib_event *event);
2849
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850int ib_query_port(struct ib_device *device,
2851 u8 port_num, struct ib_port_attr *port_attr);
2852
Eli Cohena3f5ada2010-09-27 17:51:10 -07002853enum rdma_link_layer rdma_port_get_link_layer(struct ib_device *device,
2854 u8 port_num);
2855
Ira Weiny0cf18d72015-05-13 20:02:55 -04002856/**
Hal Rosenstock41390322015-06-29 09:57:00 -04002857 * rdma_cap_ib_switch - Check if the device is IB switch
2858 * @device: Device to check
2859 *
2860 * Device driver is responsible for setting is_switch bit on
2861 * in ib_device structure at init time.
2862 *
2863 * Return: true if the device is IB switch.
2864 */
2865static inline bool rdma_cap_ib_switch(const struct ib_device *device)
2866{
2867 return device->is_switch;
2868}
2869
2870/**
Ira Weiny0cf18d72015-05-13 20:02:55 -04002871 * rdma_start_port - Return the first valid port number for the device
2872 * specified
2873 *
2874 * @device: Device to be checked
2875 *
2876 * Return start port number
2877 */
2878static inline u8 rdma_start_port(const struct ib_device *device)
2879{
Hal Rosenstock41390322015-06-29 09:57:00 -04002880 return rdma_cap_ib_switch(device) ? 0 : 1;
Ira Weiny0cf18d72015-05-13 20:02:55 -04002881}
2882
2883/**
Jason Gunthorpeea1075e2019-02-12 21:12:47 -07002884 * rdma_for_each_port - Iterate over all valid port numbers of the IB device
2885 * @device - The struct ib_device * to iterate over
2886 * @iter - The unsigned int to store the port number
2887 */
2888#define rdma_for_each_port(device, iter) \
2889 for (iter = rdma_start_port(device + BUILD_BUG_ON_ZERO(!__same_type( \
2890 unsigned int, iter))); \
2891 iter <= rdma_end_port(device); (iter)++)
2892
2893/**
Ira Weiny0cf18d72015-05-13 20:02:55 -04002894 * rdma_end_port - Return the last valid port number for the device
2895 * specified
2896 *
2897 * @device: Device to be checked
2898 *
2899 * Return last port number
2900 */
2901static inline u8 rdma_end_port(const struct ib_device *device)
2902{
Hal Rosenstock41390322015-06-29 09:57:00 -04002903 return rdma_cap_ib_switch(device) ? 0 : device->phys_port_cnt;
Ira Weiny0cf18d72015-05-13 20:02:55 -04002904}
2905
Yuval Shaia24dc8312017-01-25 18:41:37 +02002906static inline int rdma_is_port_valid(const struct ib_device *device,
2907 unsigned int port)
2908{
2909 return (port >= rdma_start_port(device) &&
2910 port <= rdma_end_port(device));
2911}
2912
Artemy Kovalyovb02289b2018-07-04 15:57:50 +03002913static inline bool rdma_is_grh_required(const struct ib_device *device,
2914 u8 port_num)
2915{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002916 return device->port_data[port_num].immutable.core_cap_flags &
2917 RDMA_CORE_PORT_IB_GRH_REQUIRED;
Artemy Kovalyovb02289b2018-07-04 15:57:50 +03002918}
2919
Ira Weiny5ede9282015-05-31 17:15:29 -04002920static inline bool rdma_protocol_ib(const struct ib_device *device, u8 port_num)
Michael Wangde66be92015-05-05 14:50:19 +02002921{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002922 return device->port_data[port_num].immutable.core_cap_flags &
2923 RDMA_CORE_CAP_PROT_IB;
Michael Wangde66be92015-05-05 14:50:19 +02002924}
2925
Ira Weiny5ede9282015-05-31 17:15:29 -04002926static inline bool rdma_protocol_roce(const struct ib_device *device, u8 port_num)
Michael Wangde66be92015-05-05 14:50:19 +02002927{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002928 return device->port_data[port_num].immutable.core_cap_flags &
2929 (RDMA_CORE_CAP_PROT_ROCE | RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP);
Matan Barak7766a992015-12-23 14:56:50 +02002930}
2931
2932static inline bool rdma_protocol_roce_udp_encap(const struct ib_device *device, u8 port_num)
2933{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002934 return device->port_data[port_num].immutable.core_cap_flags &
2935 RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP;
Matan Barak7766a992015-12-23 14:56:50 +02002936}
2937
2938static inline bool rdma_protocol_roce_eth_encap(const struct ib_device *device, u8 port_num)
2939{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002940 return device->port_data[port_num].immutable.core_cap_flags &
2941 RDMA_CORE_CAP_PROT_ROCE;
Michael Wangde66be92015-05-05 14:50:19 +02002942}
2943
Ira Weiny5ede9282015-05-31 17:15:29 -04002944static inline bool rdma_protocol_iwarp(const struct ib_device *device, u8 port_num)
Michael Wangde66be92015-05-05 14:50:19 +02002945{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002946 return device->port_data[port_num].immutable.core_cap_flags &
2947 RDMA_CORE_CAP_PROT_IWARP;
Michael Wangde66be92015-05-05 14:50:19 +02002948}
2949
Ira Weiny5ede9282015-05-31 17:15:29 -04002950static inline bool rdma_ib_or_roce(const struct ib_device *device, u8 port_num)
Michael Wangde66be92015-05-05 14:50:19 +02002951{
Matan Barak7766a992015-12-23 14:56:50 +02002952 return rdma_protocol_ib(device, port_num) ||
2953 rdma_protocol_roce(device, port_num);
Michael Wangde66be92015-05-05 14:50:19 +02002954}
2955
Or Gerlitzaa773bd2017-01-24 13:02:35 +02002956static inline bool rdma_protocol_raw_packet(const struct ib_device *device, u8 port_num)
2957{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002958 return device->port_data[port_num].immutable.core_cap_flags &
2959 RDMA_CORE_CAP_PROT_RAW_PACKET;
Or Gerlitzaa773bd2017-01-24 13:02:35 +02002960}
2961
Or Gerlitzce1e0552017-01-24 13:02:38 +02002962static inline bool rdma_protocol_usnic(const struct ib_device *device, u8 port_num)
2963{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002964 return device->port_data[port_num].immutable.core_cap_flags &
2965 RDMA_CORE_CAP_PROT_USNIC;
Or Gerlitzce1e0552017-01-24 13:02:38 +02002966}
2967
Michael Wangc757dea2015-05-05 14:50:32 +02002968/**
Michael Wang296ec002015-05-18 10:41:45 +02002969 * rdma_cap_ib_mad - Check if the port of a device supports Infiniband
Michael Wangc757dea2015-05-05 14:50:32 +02002970 * Management Datagrams.
Michael Wang296ec002015-05-18 10:41:45 +02002971 * @device: Device to check
2972 * @port_num: Port number to check
Michael Wangc757dea2015-05-05 14:50:32 +02002973 *
Michael Wang296ec002015-05-18 10:41:45 +02002974 * Management Datagrams (MAD) are a required part of the InfiniBand
2975 * specification and are supported on all InfiniBand devices. A slightly
2976 * extended version are also supported on OPA interfaces.
Michael Wangc757dea2015-05-05 14:50:32 +02002977 *
Michael Wang296ec002015-05-18 10:41:45 +02002978 * Return: true if the port supports sending/receiving of MAD packets.
Michael Wangc757dea2015-05-05 14:50:32 +02002979 */
Ira Weiny5ede9282015-05-31 17:15:29 -04002980static inline bool rdma_cap_ib_mad(const struct ib_device *device, u8 port_num)
Michael Wangc757dea2015-05-05 14:50:32 +02002981{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07002982 return device->port_data[port_num].immutable.core_cap_flags &
2983 RDMA_CORE_CAP_IB_MAD;
Michael Wangc757dea2015-05-05 14:50:32 +02002984}
2985
Michael Wang29541e32015-05-05 14:50:33 +02002986/**
Ira Weiny65995fe2015-06-06 14:38:32 -04002987 * rdma_cap_opa_mad - Check if the port of device provides support for OPA
2988 * Management Datagrams.
2989 * @device: Device to check
2990 * @port_num: Port number to check
2991 *
2992 * Intel OmniPath devices extend and/or replace the InfiniBand Management
2993 * datagrams with their own versions. These OPA MADs share many but not all of
2994 * the characteristics of InfiniBand MADs.
2995 *
2996 * OPA MADs differ in the following ways:
2997 *
2998 * 1) MADs are variable size up to 2K
2999 * IBTA defined MADs remain fixed at 256 bytes
3000 * 2) OPA SMPs must carry valid PKeys
3001 * 3) OPA SMP packets are a different format
3002 *
3003 * Return: true if the port supports OPA MAD packet formats.
3004 */
3005static inline bool rdma_cap_opa_mad(struct ib_device *device, u8 port_num)
3006{
Leon Romanovskyd3243da2019-03-10 17:27:46 +02003007 return device->port_data[port_num].immutable.core_cap_flags &
3008 RDMA_CORE_CAP_OPA_MAD;
Ira Weiny65995fe2015-06-06 14:38:32 -04003009}
3010
3011/**
Michael Wang296ec002015-05-18 10:41:45 +02003012 * rdma_cap_ib_smi - Check if the port of a device provides an Infiniband
3013 * Subnet Management Agent (SMA) on the Subnet Management Interface (SMI).
3014 * @device: Device to check
3015 * @port_num: Port number to check
Michael Wang29541e32015-05-05 14:50:33 +02003016 *
Michael Wang296ec002015-05-18 10:41:45 +02003017 * Each InfiniBand node is required to provide a Subnet Management Agent
3018 * that the subnet manager can access. Prior to the fabric being fully
3019 * configured by the subnet manager, the SMA is accessed via a well known
3020 * interface called the Subnet Management Interface (SMI). This interface
3021 * uses directed route packets to communicate with the SM to get around the
3022 * chicken and egg problem of the SM needing to know what's on the fabric
3023 * in order to configure the fabric, and needing to configure the fabric in
3024 * order to send packets to the devices on the fabric. These directed
3025 * route packets do not need the fabric fully configured in order to reach
3026 * their destination. The SMI is the only method allowed to send
3027 * directed route packets on an InfiniBand fabric.
Michael Wang29541e32015-05-05 14:50:33 +02003028 *
Michael Wang296ec002015-05-18 10:41:45 +02003029 * Return: true if the port provides an SMI.
Michael Wang29541e32015-05-05 14:50:33 +02003030 */
Ira Weiny5ede9282015-05-31 17:15:29 -04003031static inline bool rdma_cap_ib_smi(const struct ib_device *device, u8 port_num)
Michael Wang29541e32015-05-05 14:50:33 +02003032{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07003033 return device->port_data[port_num].immutable.core_cap_flags &
3034 RDMA_CORE_CAP_IB_SMI;
Michael Wang29541e32015-05-05 14:50:33 +02003035}
3036
Michael Wang72219cea2015-05-05 14:50:34 +02003037/**
3038 * rdma_cap_ib_cm - Check if the port of device has the capability Infiniband
3039 * Communication Manager.
Michael Wang296ec002015-05-18 10:41:45 +02003040 * @device: Device to check
3041 * @port_num: Port number to check
Michael Wang72219cea2015-05-05 14:50:34 +02003042 *
Michael Wang296ec002015-05-18 10:41:45 +02003043 * The InfiniBand Communication Manager is one of many pre-defined General
3044 * Service Agents (GSA) that are accessed via the General Service
3045 * Interface (GSI). It's role is to facilitate establishment of connections
3046 * between nodes as well as other management related tasks for established
3047 * connections.
Michael Wang72219cea2015-05-05 14:50:34 +02003048 *
Michael Wang296ec002015-05-18 10:41:45 +02003049 * Return: true if the port supports an IB CM (this does not guarantee that
3050 * a CM is actually running however).
Michael Wang72219cea2015-05-05 14:50:34 +02003051 */
Ira Weiny5ede9282015-05-31 17:15:29 -04003052static inline bool rdma_cap_ib_cm(const struct ib_device *device, u8 port_num)
Michael Wang72219cea2015-05-05 14:50:34 +02003053{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07003054 return device->port_data[port_num].immutable.core_cap_flags &
3055 RDMA_CORE_CAP_IB_CM;
Michael Wang72219cea2015-05-05 14:50:34 +02003056}
3057
Michael Wang04215332015-05-05 14:50:35 +02003058/**
3059 * rdma_cap_iw_cm - Check if the port of device has the capability IWARP
3060 * Communication Manager.
Michael Wang296ec002015-05-18 10:41:45 +02003061 * @device: Device to check
3062 * @port_num: Port number to check
Michael Wang04215332015-05-05 14:50:35 +02003063 *
Michael Wang296ec002015-05-18 10:41:45 +02003064 * Similar to above, but specific to iWARP connections which have a different
3065 * managment protocol than InfiniBand.
Michael Wang04215332015-05-05 14:50:35 +02003066 *
Michael Wang296ec002015-05-18 10:41:45 +02003067 * Return: true if the port supports an iWARP CM (this does not guarantee that
3068 * a CM is actually running however).
Michael Wang04215332015-05-05 14:50:35 +02003069 */
Ira Weiny5ede9282015-05-31 17:15:29 -04003070static inline bool rdma_cap_iw_cm(const struct ib_device *device, u8 port_num)
Michael Wang04215332015-05-05 14:50:35 +02003071{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07003072 return device->port_data[port_num].immutable.core_cap_flags &
3073 RDMA_CORE_CAP_IW_CM;
Michael Wang04215332015-05-05 14:50:35 +02003074}
3075
Michael Wangfe53ba22015-05-05 14:50:36 +02003076/**
3077 * rdma_cap_ib_sa - Check if the port of device has the capability Infiniband
3078 * Subnet Administration.
Michael Wang296ec002015-05-18 10:41:45 +02003079 * @device: Device to check
3080 * @port_num: Port number to check
Michael Wangfe53ba22015-05-05 14:50:36 +02003081 *
Michael Wang296ec002015-05-18 10:41:45 +02003082 * An InfiniBand Subnet Administration (SA) service is a pre-defined General
3083 * Service Agent (GSA) provided by the Subnet Manager (SM). On InfiniBand
3084 * fabrics, devices should resolve routes to other hosts by contacting the
3085 * SA to query the proper route.
Michael Wangfe53ba22015-05-05 14:50:36 +02003086 *
Michael Wang296ec002015-05-18 10:41:45 +02003087 * Return: true if the port should act as a client to the fabric Subnet
3088 * Administration interface. This does not imply that the SA service is
3089 * running locally.
Michael Wangfe53ba22015-05-05 14:50:36 +02003090 */
Ira Weiny5ede9282015-05-31 17:15:29 -04003091static inline bool rdma_cap_ib_sa(const struct ib_device *device, u8 port_num)
Michael Wangfe53ba22015-05-05 14:50:36 +02003092{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07003093 return device->port_data[port_num].immutable.core_cap_flags &
3094 RDMA_CORE_CAP_IB_SA;
Michael Wangfe53ba22015-05-05 14:50:36 +02003095}
3096
Michael Wanga31ad3b2015-05-05 14:50:37 +02003097/**
3098 * rdma_cap_ib_mcast - Check if the port of device has the capability Infiniband
3099 * Multicast.
Michael Wang296ec002015-05-18 10:41:45 +02003100 * @device: Device to check
3101 * @port_num: Port number to check
Michael Wanga31ad3b2015-05-05 14:50:37 +02003102 *
Michael Wang296ec002015-05-18 10:41:45 +02003103 * InfiniBand multicast registration is more complex than normal IPv4 or
3104 * IPv6 multicast registration. Each Host Channel Adapter must register
3105 * with the Subnet Manager when it wishes to join a multicast group. It
3106 * should do so only once regardless of how many queue pairs it subscribes
3107 * to this group. And it should leave the group only after all queue pairs
3108 * attached to the group have been detached.
Michael Wanga31ad3b2015-05-05 14:50:37 +02003109 *
Michael Wang296ec002015-05-18 10:41:45 +02003110 * Return: true if the port must undertake the additional adminstrative
3111 * overhead of registering/unregistering with the SM and tracking of the
3112 * total number of queue pairs attached to the multicast group.
Michael Wanga31ad3b2015-05-05 14:50:37 +02003113 */
Ira Weiny5ede9282015-05-31 17:15:29 -04003114static inline bool rdma_cap_ib_mcast(const struct ib_device *device, u8 port_num)
Michael Wanga31ad3b2015-05-05 14:50:37 +02003115{
3116 return rdma_cap_ib_sa(device, port_num);
3117}
3118
Michael Wangbc0f1d72015-05-05 14:50:38 +02003119/**
Michael Wang30a74ef2015-05-05 14:50:39 +02003120 * rdma_cap_af_ib - Check if the port of device has the capability
3121 * Native Infiniband Address.
Michael Wang296ec002015-05-18 10:41:45 +02003122 * @device: Device to check
3123 * @port_num: Port number to check
Michael Wang30a74ef2015-05-05 14:50:39 +02003124 *
Michael Wang296ec002015-05-18 10:41:45 +02003125 * InfiniBand addressing uses a port's GUID + Subnet Prefix to make a default
3126 * GID. RoCE uses a different mechanism, but still generates a GID via
3127 * a prescribed mechanism and port specific data.
Michael Wang30a74ef2015-05-05 14:50:39 +02003128 *
Michael Wang296ec002015-05-18 10:41:45 +02003129 * Return: true if the port uses a GID address to identify devices on the
3130 * network.
Michael Wang30a74ef2015-05-05 14:50:39 +02003131 */
Ira Weiny5ede9282015-05-31 17:15:29 -04003132static inline bool rdma_cap_af_ib(const struct ib_device *device, u8 port_num)
Michael Wang30a74ef2015-05-05 14:50:39 +02003133{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07003134 return device->port_data[port_num].immutable.core_cap_flags &
3135 RDMA_CORE_CAP_AF_IB;
Michael Wang30a74ef2015-05-05 14:50:39 +02003136}
3137
3138/**
Michael Wang227128f2015-05-05 14:50:40 +02003139 * rdma_cap_eth_ah - Check if the port of device has the capability
Michael Wang296ec002015-05-18 10:41:45 +02003140 * Ethernet Address Handle.
3141 * @device: Device to check
3142 * @port_num: Port number to check
Michael Wang227128f2015-05-05 14:50:40 +02003143 *
Michael Wang296ec002015-05-18 10:41:45 +02003144 * RoCE is InfiniBand over Ethernet, and it uses a well defined technique
3145 * to fabricate GIDs over Ethernet/IP specific addresses native to the
3146 * port. Normally, packet headers are generated by the sending host
3147 * adapter, but when sending connectionless datagrams, we must manually
3148 * inject the proper headers for the fabric we are communicating over.
Michael Wang227128f2015-05-05 14:50:40 +02003149 *
Michael Wang296ec002015-05-18 10:41:45 +02003150 * Return: true if we are running as a RoCE port and must force the
3151 * addition of a Global Route Header built from our Ethernet Address
3152 * Handle into our header list for connectionless packets.
Michael Wang227128f2015-05-05 14:50:40 +02003153 */
Ira Weiny5ede9282015-05-31 17:15:29 -04003154static inline bool rdma_cap_eth_ah(const struct ib_device *device, u8 port_num)
Michael Wang227128f2015-05-05 14:50:40 +02003155{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07003156 return device->port_data[port_num].immutable.core_cap_flags &
3157 RDMA_CORE_CAP_ETH_AH;
Michael Wang227128f2015-05-05 14:50:40 +02003158}
3159
3160/**
Dasaratharaman Chandramouli94d595c2017-03-20 19:38:09 -04003161 * rdma_cap_opa_ah - Check if the port of device supports
3162 * OPA Address handles
3163 * @device: Device to check
3164 * @port_num: Port number to check
3165 *
3166 * Return: true if we are running on an OPA device which supports
3167 * the extended OPA addressing.
3168 */
3169static inline bool rdma_cap_opa_ah(struct ib_device *device, u8 port_num)
3170{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07003171 return (device->port_data[port_num].immutable.core_cap_flags &
Dasaratharaman Chandramouli94d595c2017-03-20 19:38:09 -04003172 RDMA_CORE_CAP_OPA_AH) == RDMA_CORE_CAP_OPA_AH;
3173}
3174
3175/**
Ira Weiny337877a2015-06-06 14:38:29 -04003176 * rdma_max_mad_size - Return the max MAD size required by this RDMA Port.
3177 *
3178 * @device: Device
3179 * @port_num: Port number
3180 *
3181 * This MAD size includes the MAD headers and MAD payload. No other headers
3182 * are included.
3183 *
3184 * Return the max MAD size required by the Port. Will return 0 if the port
3185 * does not support MADs
3186 */
3187static inline size_t rdma_max_mad_size(const struct ib_device *device, u8 port_num)
3188{
Jason Gunthorpe8ceb1352019-02-12 21:12:48 -07003189 return device->port_data[port_num].immutable.max_mad_size;
Ira Weiny337877a2015-06-06 14:38:29 -04003190}
3191
Matan Barak03db3a22015-07-30 18:33:26 +03003192/**
3193 * rdma_cap_roce_gid_table - Check if the port of device uses roce_gid_table
3194 * @device: Device to check
3195 * @port_num: Port number to check
3196 *
3197 * RoCE GID table mechanism manages the various GIDs for a device.
3198 *
3199 * NOTE: if allocating the port's GID table has failed, this call will still
3200 * return true, but any RoCE GID table API will fail.
3201 *
3202 * Return: true if the port uses RoCE GID table mechanism in order to manage
3203 * its GIDs.
3204 */
3205static inline bool rdma_cap_roce_gid_table(const struct ib_device *device,
3206 u8 port_num)
3207{
3208 return rdma_protocol_roce(device, port_num) &&
Kamal Heib3023a1e2018-12-10 21:09:48 +02003209 device->ops.add_gid && device->ops.del_gid;
Matan Barak03db3a22015-07-30 18:33:26 +03003210}
3211
Christoph Hellwig002516e2016-05-03 18:01:05 +02003212/*
3213 * Check if the device supports READ W/ INVALIDATE.
3214 */
3215static inline bool rdma_cap_read_inv(struct ib_device *dev, u32 port_num)
3216{
3217 /*
3218 * iWarp drivers must support READ W/ INVALIDATE. No other protocol
3219 * has support for it yet.
3220 */
3221 return rdma_protocol_iwarp(dev, port_num);
3222}
3223
Shiraz Saleem4a353392019-05-06 08:53:32 -05003224/**
3225 * rdma_find_pg_bit - Find page bit given address and HW supported page sizes
3226 *
3227 * @addr: address
3228 * @pgsz_bitmap: bitmap of HW supported page sizes
3229 */
3230static inline unsigned int rdma_find_pg_bit(unsigned long addr,
3231 unsigned long pgsz_bitmap)
3232{
3233 unsigned long align;
3234 unsigned long pgsz;
3235
3236 align = addr & -addr;
3237
3238 /* Find page bit such that addr is aligned to the highest supported
3239 * HW page size
3240 */
3241 pgsz = pgsz_bitmap & ~(-align << 1);
3242 if (!pgsz)
3243 return __ffs(pgsz_bitmap);
3244
3245 return __fls(pgsz);
3246}
3247
Eli Cohen50174a72016-03-11 22:58:38 +02003248int ib_set_vf_link_state(struct ib_device *device, int vf, u8 port,
3249 int state);
3250int ib_get_vf_config(struct ib_device *device, int vf, u8 port,
3251 struct ifla_vf_info *info);
3252int ib_get_vf_stats(struct ib_device *device, int vf, u8 port,
3253 struct ifla_vf_stats *stats);
3254int ib_set_vf_guid(struct ib_device *device, int vf, u8 port, u64 guid,
3255 int type);
3256
Linus Torvalds1da177e2005-04-16 15:20:36 -07003257int ib_query_pkey(struct ib_device *device,
3258 u8 port_num, u16 index, u16 *pkey);
3259
3260int ib_modify_device(struct ib_device *device,
3261 int device_modify_mask,
3262 struct ib_device_modify *device_modify);
3263
3264int ib_modify_port(struct ib_device *device,
3265 u8 port_num, int port_modify_mask,
3266 struct ib_port_modify *port_modify);
3267
Yosef Etigin5eb620c2007-05-14 07:26:51 +03003268int ib_find_gid(struct ib_device *device, union ib_gid *gid,
Parav Panditb26c4a12018-03-13 16:06:12 +02003269 u8 *port_num, u16 *index);
Yosef Etigin5eb620c2007-05-14 07:26:51 +03003270
3271int ib_find_pkey(struct ib_device *device,
3272 u8 port_num, u16 pkey, u16 *index);
3273
Christoph Hellwiged082d32016-09-05 12:56:17 +02003274enum ib_pd_flags {
3275 /*
3276 * Create a memory registration for all memory in the system and place
3277 * the rkey for it into pd->unsafe_global_rkey. This can be used by
3278 * ULPs to avoid the overhead of dynamic MRs.
3279 *
3280 * This flag is generally considered unsafe and must only be used in
3281 * extremly trusted environments. Every use of it will log a warning
3282 * in the kernel log.
3283 */
3284 IB_PD_UNSAFE_GLOBAL_RKEY = 0x01,
3285};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003286
Christoph Hellwiged082d32016-09-05 12:56:17 +02003287struct ib_pd *__ib_alloc_pd(struct ib_device *device, unsigned int flags,
3288 const char *caller);
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003289
Christoph Hellwiged082d32016-09-05 12:56:17 +02003290#define ib_alloc_pd(device, flags) \
Leon Romanovskye4496442018-01-28 11:17:18 +02003291 __ib_alloc_pd((device), (flags), KBUILD_MODNAME)
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003292
3293/**
3294 * ib_dealloc_pd_user - Deallocate kernel/user PD
3295 * @pd: The protection domain
3296 * @udata: Valid user data or NULL for kernel objects
3297 */
3298void ib_dealloc_pd_user(struct ib_pd *pd, struct ib_udata *udata);
3299
3300/**
3301 * ib_dealloc_pd - Deallocate kernel PD
3302 * @pd: The protection domain
3303 *
3304 * NOTE: for user PD use ib_dealloc_pd_user with valid udata!
3305 */
3306static inline void ib_dealloc_pd(struct ib_pd *pd)
3307{
3308 ib_dealloc_pd_user(pd, NULL);
3309}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310
Gal Pressmanb090c4e2018-12-12 11:09:05 +02003311enum rdma_create_ah_flags {
3312 /* In a sleepable context */
3313 RDMA_CREATE_AH_SLEEPABLE = BIT(0),
3314};
3315
Linus Torvalds1da177e2005-04-16 15:20:36 -07003316/**
Dasaratharaman Chandramouli0a18cfe2017-04-29 14:41:19 -04003317 * rdma_create_ah - Creates an address handle for the given address vector.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003318 * @pd: The protection domain associated with the address handle.
3319 * @ah_attr: The attributes of the address vector.
Gal Pressmanb090c4e2018-12-12 11:09:05 +02003320 * @flags: Create address handle flags (see enum rdma_create_ah_flags).
Linus Torvalds1da177e2005-04-16 15:20:36 -07003321 *
3322 * The address handle is used to reference a local or global destination
3323 * in all UD QP post sends.
3324 */
Gal Pressmanb090c4e2018-12-12 11:09:05 +02003325struct ib_ah *rdma_create_ah(struct ib_pd *pd, struct rdma_ah_attr *ah_attr,
3326 u32 flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003327
3328/**
Parav Pandit5cda6582017-10-16 08:45:12 +03003329 * rdma_create_user_ah - Creates an address handle for the given address vector.
3330 * It resolves destination mac address for ah attribute of RoCE type.
3331 * @pd: The protection domain associated with the address handle.
3332 * @ah_attr: The attributes of the address vector.
3333 * @udata: pointer to user's input output buffer information need by
3334 * provider driver.
3335 *
3336 * It returns 0 on success and returns appropriate error code on error.
3337 * The address handle is used to reference a local or global destination
3338 * in all UD QP post sends.
3339 */
3340struct ib_ah *rdma_create_user_ah(struct ib_pd *pd,
3341 struct rdma_ah_attr *ah_attr,
3342 struct ib_udata *udata);
3343/**
Moni Shoua850d8fd2016-11-10 11:30:56 +02003344 * ib_get_gids_from_rdma_hdr - Get sgid and dgid from GRH or IPv4 header
3345 * work completion.
3346 * @hdr: the L3 header to parse
3347 * @net_type: type of header to parse
3348 * @sgid: place to store source gid
3349 * @dgid: place to store destination gid
3350 */
3351int ib_get_gids_from_rdma_hdr(const union rdma_network_hdr *hdr,
3352 enum rdma_network_type net_type,
3353 union ib_gid *sgid, union ib_gid *dgid);
3354
3355/**
3356 * ib_get_rdma_header_version - Get the header version
3357 * @hdr: the L3 header to parse
3358 */
3359int ib_get_rdma_header_version(const union rdma_network_hdr *hdr);
3360
3361/**
Parav Panditf6bdb142017-11-14 14:52:17 +02003362 * ib_init_ah_attr_from_wc - Initializes address handle attributes from a
Sean Hefty4e00d692006-06-17 20:37:39 -07003363 * work completion.
3364 * @device: Device on which the received message arrived.
3365 * @port_num: Port on which the received message arrived.
3366 * @wc: Work completion associated with the received message.
3367 * @grh: References the received global route header. This parameter is
3368 * ignored unless the work completion indicates that the GRH is valid.
3369 * @ah_attr: Returned attributes that can be used when creating an address
3370 * handle for replying to the message.
Parav Panditb7403212018-06-19 10:59:14 +03003371 * When ib_init_ah_attr_from_wc() returns success,
3372 * (a) for IB link layer it optionally contains a reference to SGID attribute
3373 * when GRH is present for IB link layer.
3374 * (b) for RoCE link layer it contains a reference to SGID attribute.
3375 * User must invoke rdma_cleanup_ah_attr_gid_attr() to release reference to SGID
3376 * attributes which are initialized using ib_init_ah_attr_from_wc().
3377 *
Sean Hefty4e00d692006-06-17 20:37:39 -07003378 */
Parav Panditf6bdb142017-11-14 14:52:17 +02003379int ib_init_ah_attr_from_wc(struct ib_device *device, u8 port_num,
3380 const struct ib_wc *wc, const struct ib_grh *grh,
3381 struct rdma_ah_attr *ah_attr);
Sean Hefty4e00d692006-06-17 20:37:39 -07003382
3383/**
Hal Rosenstock513789e2005-07-27 11:45:34 -07003384 * ib_create_ah_from_wc - Creates an address handle associated with the
3385 * sender of the specified work completion.
3386 * @pd: The protection domain associated with the address handle.
3387 * @wc: Work completion information associated with a received message.
3388 * @grh: References the received global route header. This parameter is
3389 * ignored unless the work completion indicates that the GRH is valid.
3390 * @port_num: The outbound port number to associate with the address.
3391 *
3392 * The address handle is used to reference a local or global destination
3393 * in all UD QP post sends.
3394 */
Ira Weiny73cdaae2015-05-31 17:15:31 -04003395struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, const struct ib_wc *wc,
3396 const struct ib_grh *grh, u8 port_num);
Hal Rosenstock513789e2005-07-27 11:45:34 -07003397
3398/**
Dasaratharaman Chandramouli67b985b2017-04-29 14:41:20 -04003399 * rdma_modify_ah - Modifies the address vector associated with an address
Linus Torvalds1da177e2005-04-16 15:20:36 -07003400 * handle.
3401 * @ah: The address handle to modify.
3402 * @ah_attr: The new address vector attributes to associate with the
3403 * address handle.
3404 */
Dasaratharaman Chandramouli67b985b2017-04-29 14:41:20 -04003405int rdma_modify_ah(struct ib_ah *ah, struct rdma_ah_attr *ah_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003406
3407/**
Dasaratharaman Chandramoulibfbfd662017-04-29 14:41:21 -04003408 * rdma_query_ah - Queries the address vector associated with an address
Linus Torvalds1da177e2005-04-16 15:20:36 -07003409 * handle.
3410 * @ah: The address handle to query.
3411 * @ah_attr: The address vector attributes associated with the address
3412 * handle.
3413 */
Dasaratharaman Chandramoulibfbfd662017-04-29 14:41:21 -04003414int rdma_query_ah(struct ib_ah *ah, struct rdma_ah_attr *ah_attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003415
Gal Pressman2553ba22018-12-12 11:09:06 +02003416enum rdma_destroy_ah_flags {
3417 /* In a sleepable context */
3418 RDMA_DESTROY_AH_SLEEPABLE = BIT(0),
3419};
3420
Linus Torvalds1da177e2005-04-16 15:20:36 -07003421/**
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003422 * rdma_destroy_ah_user - Destroys an address handle.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003423 * @ah: The address handle to destroy.
Gal Pressman2553ba22018-12-12 11:09:06 +02003424 * @flags: Destroy address handle flags (see enum rdma_destroy_ah_flags).
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003425 * @udata: Valid user data or NULL for kernel objects
Linus Torvalds1da177e2005-04-16 15:20:36 -07003426 */
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003427int rdma_destroy_ah_user(struct ib_ah *ah, u32 flags, struct ib_udata *udata);
3428
3429/**
3430 * rdma_destroy_ah - Destroys an kernel address handle.
3431 * @ah: The address handle to destroy.
3432 * @flags: Destroy address handle flags (see enum rdma_destroy_ah_flags).
3433 *
3434 * NOTE: for user ah use rdma_destroy_ah_user with valid udata!
3435 */
3436static inline int rdma_destroy_ah(struct ib_ah *ah, u32 flags)
3437{
3438 return rdma_destroy_ah_user(ah, flags, NULL);
3439}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003440
3441/**
Roland Dreierd41fcc62005-08-18 12:23:08 -07003442 * ib_create_srq - Creates a SRQ associated with the specified protection
3443 * domain.
3444 * @pd: The protection domain associated with the SRQ.
Dotan Barakabb6e9b2006-02-23 12:13:51 -08003445 * @srq_init_attr: A list of initial attributes required to create the
3446 * SRQ. If SRQ creation succeeds, then the attributes are updated to
3447 * the actual capabilities of the created SRQ.
Roland Dreierd41fcc62005-08-18 12:23:08 -07003448 *
3449 * srq_attr->max_wr and srq_attr->max_sge are read the determine the
3450 * requested size of the SRQ, and set to the actual values allocated
3451 * on return. If ib_create_srq() succeeds, then max_wr and max_sge
3452 * will always be at least as large as the requested values.
3453 */
3454struct ib_srq *ib_create_srq(struct ib_pd *pd,
3455 struct ib_srq_init_attr *srq_init_attr);
3456
3457/**
3458 * ib_modify_srq - Modifies the attributes for the specified SRQ.
3459 * @srq: The SRQ to modify.
3460 * @srq_attr: On input, specifies the SRQ attributes to modify. On output,
3461 * the current values of selected SRQ attributes are returned.
3462 * @srq_attr_mask: A bit-mask used to specify which attributes of the SRQ
3463 * are being modified.
3464 *
3465 * The mask may contain IB_SRQ_MAX_WR to resize the SRQ and/or
3466 * IB_SRQ_LIMIT to set the SRQ's limit and request notification when
3467 * the number of receives queued drops below the limit.
3468 */
3469int ib_modify_srq(struct ib_srq *srq,
3470 struct ib_srq_attr *srq_attr,
3471 enum ib_srq_attr_mask srq_attr_mask);
3472
3473/**
3474 * ib_query_srq - Returns the attribute list and current values for the
3475 * specified SRQ.
3476 * @srq: The SRQ to query.
3477 * @srq_attr: The attributes of the specified SRQ.
3478 */
3479int ib_query_srq(struct ib_srq *srq,
3480 struct ib_srq_attr *srq_attr);
3481
3482/**
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003483 * ib_destroy_srq_user - Destroys the specified SRQ.
Roland Dreierd41fcc62005-08-18 12:23:08 -07003484 * @srq: The SRQ to destroy.
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003485 * @udata: Valid user data or NULL for kernel objects
Roland Dreierd41fcc62005-08-18 12:23:08 -07003486 */
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003487int ib_destroy_srq_user(struct ib_srq *srq, struct ib_udata *udata);
3488
3489/**
3490 * ib_destroy_srq - Destroys the specified kernel SRQ.
3491 * @srq: The SRQ to destroy.
3492 *
3493 * NOTE: for user srq use ib_destroy_srq_user with valid udata!
3494 */
3495static inline int ib_destroy_srq(struct ib_srq *srq)
3496{
3497 return ib_destroy_srq_user(srq, NULL);
3498}
Roland Dreierd41fcc62005-08-18 12:23:08 -07003499
3500/**
3501 * ib_post_srq_recv - Posts a list of work requests to the specified SRQ.
3502 * @srq: The SRQ to post the work request on.
3503 * @recv_wr: A list of work requests to post on the receive queue.
3504 * @bad_recv_wr: On an immediate failure, this parameter will reference
3505 * the work request that failed to be posted on the QP.
3506 */
3507static inline int ib_post_srq_recv(struct ib_srq *srq,
Bart Van Assched34ac5c2018-07-18 09:25:32 -07003508 const struct ib_recv_wr *recv_wr,
3509 const struct ib_recv_wr **bad_recv_wr)
Roland Dreierd41fcc62005-08-18 12:23:08 -07003510{
Bart Van Assched34ac5c2018-07-18 09:25:32 -07003511 const struct ib_recv_wr *dummy;
Bart Van Asschebb039a82018-07-18 09:25:16 -07003512
Kamal Heib3023a1e2018-12-10 21:09:48 +02003513 return srq->device->ops.post_srq_recv(srq, recv_wr,
3514 bad_recv_wr ? : &dummy);
Roland Dreierd41fcc62005-08-18 12:23:08 -07003515}
3516
3517/**
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003518 * ib_create_qp_user - Creates a QP associated with the specified protection
Linus Torvalds1da177e2005-04-16 15:20:36 -07003519 * domain.
3520 * @pd: The protection domain associated with the QP.
Dotan Barakabb6e9b2006-02-23 12:13:51 -08003521 * @qp_init_attr: A list of initial attributes required to create the
3522 * QP. If QP creation succeeds, then the attributes are updated to
3523 * the actual capabilities of the created QP.
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003524 * @udata: Valid user data or NULL for kernel objects
Linus Torvalds1da177e2005-04-16 15:20:36 -07003525 */
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003526struct ib_qp *ib_create_qp_user(struct ib_pd *pd,
3527 struct ib_qp_init_attr *qp_init_attr,
3528 struct ib_udata *udata);
3529
3530/**
3531 * ib_create_qp - Creates a kernel QP associated with the specified protection
3532 * domain.
3533 * @pd: The protection domain associated with the QP.
3534 * @qp_init_attr: A list of initial attributes required to create the
3535 * QP. If QP creation succeeds, then the attributes are updated to
3536 * the actual capabilities of the created QP.
3537 * @udata: Valid user data or NULL for kernel objects
3538 *
3539 * NOTE: for user qp use ib_create_qp_user with valid udata!
3540 */
3541static inline struct ib_qp *ib_create_qp(struct ib_pd *pd,
3542 struct ib_qp_init_attr *qp_init_attr)
3543{
3544 return ib_create_qp_user(pd, qp_init_attr, NULL);
3545}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003546
3547/**
Parav Pandita512c2f2017-05-23 11:26:08 +03003548 * ib_modify_qp_with_udata - Modifies the attributes for the specified QP.
3549 * @qp: The QP to modify.
3550 * @attr: On input, specifies the QP attributes to modify. On output,
3551 * the current values of selected QP attributes are returned.
3552 * @attr_mask: A bit-mask used to specify which attributes of the QP
3553 * are being modified.
3554 * @udata: pointer to user's input output buffer information
3555 * are being modified.
3556 * It returns 0 on success and returns appropriate error code on error.
3557 */
3558int ib_modify_qp_with_udata(struct ib_qp *qp,
3559 struct ib_qp_attr *attr,
3560 int attr_mask,
3561 struct ib_udata *udata);
3562
3563/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07003564 * ib_modify_qp - Modifies the attributes for the specified QP and then
3565 * transitions the QP to the given state.
3566 * @qp: The QP to modify.
3567 * @qp_attr: On input, specifies the QP attributes to modify. On output,
3568 * the current values of selected QP attributes are returned.
3569 * @qp_attr_mask: A bit-mask used to specify which attributes of the QP
3570 * are being modified.
3571 */
3572int ib_modify_qp(struct ib_qp *qp,
3573 struct ib_qp_attr *qp_attr,
3574 int qp_attr_mask);
3575
3576/**
3577 * ib_query_qp - Returns the attribute list and current values for the
3578 * specified QP.
3579 * @qp: The QP to query.
3580 * @qp_attr: The attributes of the specified QP.
3581 * @qp_attr_mask: A bit-mask used to select specific attributes to query.
3582 * @qp_init_attr: Additional attributes of the selected QP.
3583 *
3584 * The qp_attr_mask may be used to limit the query to gathering only the
3585 * selected attributes.
3586 */
3587int ib_query_qp(struct ib_qp *qp,
3588 struct ib_qp_attr *qp_attr,
3589 int qp_attr_mask,
3590 struct ib_qp_init_attr *qp_init_attr);
3591
3592/**
3593 * ib_destroy_qp - Destroys the specified QP.
3594 * @qp: The QP to destroy.
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003595 * @udata: Valid udata or NULL for kernel objects
Linus Torvalds1da177e2005-04-16 15:20:36 -07003596 */
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003597int ib_destroy_qp_user(struct ib_qp *qp, struct ib_udata *udata);
3598
3599/**
3600 * ib_destroy_qp - Destroys the specified kernel QP.
3601 * @qp: The QP to destroy.
3602 *
3603 * NOTE: for user qp use ib_destroy_qp_user with valid udata!
3604 */
3605static inline int ib_destroy_qp(struct ib_qp *qp)
3606{
3607 return ib_destroy_qp_user(qp, NULL);
3608}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003609
3610/**
Sean Hefty0e0ec7e2011-08-08 15:31:51 -07003611 * ib_open_qp - Obtain a reference to an existing sharable QP.
3612 * @xrcd - XRC domain
3613 * @qp_open_attr: Attributes identifying the QP to open.
3614 *
3615 * Returns a reference to a sharable QP.
3616 */
3617struct ib_qp *ib_open_qp(struct ib_xrcd *xrcd,
3618 struct ib_qp_open_attr *qp_open_attr);
3619
3620/**
3621 * ib_close_qp - Release an external reference to a QP.
Sean Heftyd3d72d92011-05-26 23:06:44 -07003622 * @qp: The QP handle to release
3623 *
Sean Hefty0e0ec7e2011-08-08 15:31:51 -07003624 * The opened QP handle is released by the caller. The underlying
3625 * shared QP is not destroyed until all internal references are released.
Sean Heftyd3d72d92011-05-26 23:06:44 -07003626 */
Sean Hefty0e0ec7e2011-08-08 15:31:51 -07003627int ib_close_qp(struct ib_qp *qp);
Sean Heftyd3d72d92011-05-26 23:06:44 -07003628
3629/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07003630 * ib_post_send - Posts a list of work requests to the send queue of
3631 * the specified QP.
3632 * @qp: The QP to post the work request on.
3633 * @send_wr: A list of work requests to post on the send queue.
3634 * @bad_send_wr: On an immediate failure, this parameter will reference
3635 * the work request that failed to be posted on the QP.
Bart Van Assche55464d42009-12-09 14:20:04 -08003636 *
3637 * While IBA Vol. 1 section 11.4.1.1 specifies that if an immediate
3638 * error is returned, the QP state shall not be affected,
3639 * ib_post_send() will return an immediate error after queueing any
3640 * earlier work requests in the list.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003641 */
3642static inline int ib_post_send(struct ib_qp *qp,
Bart Van Assched34ac5c2018-07-18 09:25:32 -07003643 const struct ib_send_wr *send_wr,
3644 const struct ib_send_wr **bad_send_wr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003645{
Bart Van Assched34ac5c2018-07-18 09:25:32 -07003646 const struct ib_send_wr *dummy;
Bart Van Asschebb039a82018-07-18 09:25:16 -07003647
Kamal Heib3023a1e2018-12-10 21:09:48 +02003648 return qp->device->ops.post_send(qp, send_wr, bad_send_wr ? : &dummy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003649}
3650
3651/**
3652 * ib_post_recv - Posts a list of work requests to the receive queue of
3653 * the specified QP.
3654 * @qp: The QP to post the work request on.
3655 * @recv_wr: A list of work requests to post on the receive queue.
3656 * @bad_recv_wr: On an immediate failure, this parameter will reference
3657 * the work request that failed to be posted on the QP.
3658 */
3659static inline int ib_post_recv(struct ib_qp *qp,
Bart Van Assched34ac5c2018-07-18 09:25:32 -07003660 const struct ib_recv_wr *recv_wr,
3661 const struct ib_recv_wr **bad_recv_wr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003662{
Bart Van Assched34ac5c2018-07-18 09:25:32 -07003663 const struct ib_recv_wr *dummy;
Bart Van Asschebb039a82018-07-18 09:25:16 -07003664
Kamal Heib3023a1e2018-12-10 21:09:48 +02003665 return qp->device->ops.post_recv(qp, recv_wr, bad_recv_wr ? : &dummy);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003666}
3667
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003668struct ib_cq *__ib_alloc_cq_user(struct ib_device *dev, void *private,
3669 int nr_cqe, int comp_vector,
3670 enum ib_poll_context poll_ctx,
3671 const char *caller, struct ib_udata *udata);
Leon Romanovskyf66c8ba2018-01-28 11:17:19 +02003672
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003673/**
3674 * ib_alloc_cq_user: Allocate kernel/user CQ
3675 * @dev: The IB device
3676 * @private: Private data attached to the CQE
3677 * @nr_cqe: Number of CQEs in the CQ
3678 * @comp_vector: Completion vector used for the IRQs
3679 * @poll_ctx: Context used for polling the CQ
3680 * @udata: Valid user data or NULL for kernel objects
3681 */
3682static inline struct ib_cq *ib_alloc_cq_user(struct ib_device *dev,
3683 void *private, int nr_cqe,
3684 int comp_vector,
3685 enum ib_poll_context poll_ctx,
3686 struct ib_udata *udata)
3687{
3688 return __ib_alloc_cq_user(dev, private, nr_cqe, comp_vector, poll_ctx,
3689 KBUILD_MODNAME, udata);
3690}
3691
3692/**
3693 * ib_alloc_cq: Allocate kernel CQ
3694 * @dev: The IB device
3695 * @private: Private data attached to the CQE
3696 * @nr_cqe: Number of CQEs in the CQ
3697 * @comp_vector: Completion vector used for the IRQs
3698 * @poll_ctx: Context used for polling the CQ
3699 *
3700 * NOTE: for user cq use ib_alloc_cq_user with valid udata!
3701 */
3702static inline struct ib_cq *ib_alloc_cq(struct ib_device *dev, void *private,
3703 int nr_cqe, int comp_vector,
3704 enum ib_poll_context poll_ctx)
3705{
3706 return ib_alloc_cq_user(dev, private, nr_cqe, comp_vector, poll_ctx,
3707 NULL);
3708}
3709
3710/**
3711 * ib_free_cq_user - Free kernel/user CQ
3712 * @cq: The CQ to free
3713 * @udata: Valid user data or NULL for kernel objects
3714 */
3715void ib_free_cq_user(struct ib_cq *cq, struct ib_udata *udata);
3716
3717/**
3718 * ib_free_cq - Free kernel CQ
3719 * @cq: The CQ to free
3720 *
3721 * NOTE: for user cq use ib_free_cq_user with valid udata!
3722 */
3723static inline void ib_free_cq(struct ib_cq *cq)
3724{
3725 ib_free_cq_user(cq, NULL);
3726}
3727
Christoph Hellwig14d3a3b2015-12-11 11:53:03 -08003728int ib_process_cq_direct(struct ib_cq *cq, int budget);
3729
Linus Torvalds1da177e2005-04-16 15:20:36 -07003730/**
3731 * ib_create_cq - Creates a CQ on the specified device.
3732 * @device: The device on which to create the CQ.
3733 * @comp_handler: A user-specified callback that is invoked when a
3734 * completion event occurs on the CQ.
3735 * @event_handler: A user-specified callback that is invoked when an
3736 * asynchronous event not associated with a completion occurs on the CQ.
3737 * @cq_context: Context associated with the CQ returned to the user via
3738 * the associated completion and event handlers.
Matan Barak8e372102015-06-11 16:35:21 +03003739 * @cq_attr: The attributes the CQ should be created upon.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003740 *
3741 * Users can examine the cq structure to determine the actual CQ size.
3742 */
Bharat Potnuri7350cdd2018-06-15 20:52:33 +05303743struct ib_cq *__ib_create_cq(struct ib_device *device,
3744 ib_comp_handler comp_handler,
3745 void (*event_handler)(struct ib_event *, void *),
3746 void *cq_context,
3747 const struct ib_cq_init_attr *cq_attr,
3748 const char *caller);
3749#define ib_create_cq(device, cmp_hndlr, evt_hndlr, cq_ctxt, cq_attr) \
3750 __ib_create_cq((device), (cmp_hndlr), (evt_hndlr), (cq_ctxt), (cq_attr), KBUILD_MODNAME)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003751
3752/**
3753 * ib_resize_cq - Modifies the capacity of the CQ.
3754 * @cq: The CQ to resize.
3755 * @cqe: The minimum size of the CQ.
3756 *
3757 * Users can examine the cq structure to determine the actual CQ size.
3758 */
3759int ib_resize_cq(struct ib_cq *cq, int cqe);
3760
3761/**
Leon Romanovsky4190b4e2017-11-13 10:51:19 +02003762 * rdma_set_cq_moderation - Modifies moderation params of the CQ
Eli Cohen2dd57162008-04-16 21:09:33 -07003763 * @cq: The CQ to modify.
3764 * @cq_count: number of CQEs that will trigger an event
3765 * @cq_period: max period of time in usec before triggering an event
3766 *
3767 */
Leon Romanovsky4190b4e2017-11-13 10:51:19 +02003768int rdma_set_cq_moderation(struct ib_cq *cq, u16 cq_count, u16 cq_period);
Eli Cohen2dd57162008-04-16 21:09:33 -07003769
3770/**
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003771 * ib_destroy_cq_user - Destroys the specified CQ.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003772 * @cq: The CQ to destroy.
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003773 * @udata: Valid user data or NULL for kernel objects
Linus Torvalds1da177e2005-04-16 15:20:36 -07003774 */
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003775int ib_destroy_cq_user(struct ib_cq *cq, struct ib_udata *udata);
3776
3777/**
3778 * ib_destroy_cq - Destroys the specified kernel CQ.
3779 * @cq: The CQ to destroy.
3780 *
3781 * NOTE: for user cq use ib_destroy_cq_user with valid udata!
3782 */
Leon Romanovsky890ac8d2019-05-20 09:54:21 +03003783static inline void ib_destroy_cq(struct ib_cq *cq)
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003784{
Leon Romanovsky890ac8d2019-05-20 09:54:21 +03003785 ib_destroy_cq_user(cq, NULL);
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03003786}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003787
3788/**
3789 * ib_poll_cq - poll a CQ for completion(s)
3790 * @cq:the CQ being polled
3791 * @num_entries:maximum number of completions to return
3792 * @wc:array of at least @num_entries &struct ib_wc where completions
3793 * will be returned
3794 *
3795 * Poll a CQ for (possibly multiple) completions. If the return value
3796 * is < 0, an error occurred. If the return value is >= 0, it is the
3797 * number of completions returned. If the return value is
3798 * non-negative and < num_entries, then the CQ was emptied.
3799 */
3800static inline int ib_poll_cq(struct ib_cq *cq, int num_entries,
3801 struct ib_wc *wc)
3802{
Kamal Heib3023a1e2018-12-10 21:09:48 +02003803 return cq->device->ops.poll_cq(cq, num_entries, wc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003804}
3805
3806/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07003807 * ib_req_notify_cq - Request completion notification on a CQ.
3808 * @cq: The CQ to generate an event for.
Roland Dreiered23a722007-05-06 21:02:48 -07003809 * @flags:
3810 * Must contain exactly one of %IB_CQ_SOLICITED or %IB_CQ_NEXT_COMP
3811 * to request an event on the next solicited event or next work
3812 * completion at any type, respectively. %IB_CQ_REPORT_MISSED_EVENTS
3813 * may also be |ed in to request a hint about missed events, as
3814 * described below.
3815 *
3816 * Return Value:
3817 * < 0 means an error occurred while requesting notification
3818 * == 0 means notification was requested successfully, and if
3819 * IB_CQ_REPORT_MISSED_EVENTS was passed in, then no events
3820 * were missed and it is safe to wait for another event. In
3821 * this case is it guaranteed that any work completions added
3822 * to the CQ since the last CQ poll will trigger a completion
3823 * notification event.
3824 * > 0 is only returned if IB_CQ_REPORT_MISSED_EVENTS was passed
3825 * in. It means that the consumer must poll the CQ again to
3826 * make sure it is empty to avoid missing an event because of a
3827 * race between requesting notification and an entry being
3828 * added to the CQ. This return value means it is possible
3829 * (but not guaranteed) that a work completion has been added
3830 * to the CQ since the last poll without triggering a
3831 * completion notification event.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003832 */
3833static inline int ib_req_notify_cq(struct ib_cq *cq,
Roland Dreiered23a722007-05-06 21:02:48 -07003834 enum ib_cq_notify_flags flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003835{
Kamal Heib3023a1e2018-12-10 21:09:48 +02003836 return cq->device->ops.req_notify_cq(cq, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003837}
3838
3839/**
3840 * ib_req_ncomp_notif - Request completion notification when there are
3841 * at least the specified number of unreaped completions on the CQ.
3842 * @cq: The CQ to generate an event for.
3843 * @wc_cnt: The number of unreaped completions that should be on the
3844 * CQ before an event is generated.
3845 */
3846static inline int ib_req_ncomp_notif(struct ib_cq *cq, int wc_cnt)
3847{
Kamal Heib3023a1e2018-12-10 21:09:48 +02003848 return cq->device->ops.req_ncomp_notif ?
3849 cq->device->ops.req_ncomp_notif(cq, wc_cnt) :
Linus Torvalds1da177e2005-04-16 15:20:36 -07003850 -ENOSYS;
3851}
3852
3853/**
Ralph Campbell9b513092006-12-12 14:27:41 -08003854 * ib_dma_mapping_error - check a DMA addr for error
3855 * @dev: The device for which the dma_addr was created
3856 * @dma_addr: The DMA address to check
3857 */
3858static inline int ib_dma_mapping_error(struct ib_device *dev, u64 dma_addr)
3859{
Bart Van Assche0957c292017-03-07 22:56:53 +00003860 return dma_mapping_error(dev->dma_device, dma_addr);
Ralph Campbell9b513092006-12-12 14:27:41 -08003861}
3862
3863/**
3864 * ib_dma_map_single - Map a kernel virtual address to DMA address
3865 * @dev: The device for which the dma_addr is to be created
3866 * @cpu_addr: The kernel virtual address
3867 * @size: The size of the region in bytes
3868 * @direction: The direction of the DMA
3869 */
3870static inline u64 ib_dma_map_single(struct ib_device *dev,
3871 void *cpu_addr, size_t size,
3872 enum dma_data_direction direction)
3873{
Bart Van Assche0957c292017-03-07 22:56:53 +00003874 return dma_map_single(dev->dma_device, cpu_addr, size, direction);
Ralph Campbell9b513092006-12-12 14:27:41 -08003875}
3876
3877/**
3878 * ib_dma_unmap_single - Destroy a mapping created by ib_dma_map_single()
3879 * @dev: The device for which the DMA address was created
3880 * @addr: The DMA address
3881 * @size: The size of the region in bytes
3882 * @direction: The direction of the DMA
3883 */
3884static inline void ib_dma_unmap_single(struct ib_device *dev,
3885 u64 addr, size_t size,
3886 enum dma_data_direction direction)
3887{
Bart Van Assche0957c292017-03-07 22:56:53 +00003888 dma_unmap_single(dev->dma_device, addr, size, direction);
Arthur Kepnercb9fbc52008-04-29 01:00:34 -07003889}
3890
Ralph Campbell9b513092006-12-12 14:27:41 -08003891/**
3892 * ib_dma_map_page - Map a physical page to DMA address
3893 * @dev: The device for which the dma_addr is to be created
3894 * @page: The page to be mapped
3895 * @offset: The offset within the page
3896 * @size: The size of the region in bytes
3897 * @direction: The direction of the DMA
3898 */
3899static inline u64 ib_dma_map_page(struct ib_device *dev,
3900 struct page *page,
3901 unsigned long offset,
3902 size_t size,
3903 enum dma_data_direction direction)
3904{
Bart Van Assche0957c292017-03-07 22:56:53 +00003905 return dma_map_page(dev->dma_device, page, offset, size, direction);
Ralph Campbell9b513092006-12-12 14:27:41 -08003906}
3907
3908/**
3909 * ib_dma_unmap_page - Destroy a mapping created by ib_dma_map_page()
3910 * @dev: The device for which the DMA address was created
3911 * @addr: The DMA address
3912 * @size: The size of the region in bytes
3913 * @direction: The direction of the DMA
3914 */
3915static inline void ib_dma_unmap_page(struct ib_device *dev,
3916 u64 addr, size_t size,
3917 enum dma_data_direction direction)
3918{
Bart Van Assche0957c292017-03-07 22:56:53 +00003919 dma_unmap_page(dev->dma_device, addr, size, direction);
Ralph Campbell9b513092006-12-12 14:27:41 -08003920}
3921
3922/**
3923 * ib_dma_map_sg - Map a scatter/gather list to DMA addresses
3924 * @dev: The device for which the DMA addresses are to be created
3925 * @sg: The array of scatter/gather entries
3926 * @nents: The number of scatter/gather entries
3927 * @direction: The direction of the DMA
3928 */
3929static inline int ib_dma_map_sg(struct ib_device *dev,
3930 struct scatterlist *sg, int nents,
3931 enum dma_data_direction direction)
3932{
Bart Van Assche0957c292017-03-07 22:56:53 +00003933 return dma_map_sg(dev->dma_device, sg, nents, direction);
Ralph Campbell9b513092006-12-12 14:27:41 -08003934}
3935
3936/**
3937 * ib_dma_unmap_sg - Unmap a scatter/gather list of DMA addresses
3938 * @dev: The device for which the DMA addresses were created
3939 * @sg: The array of scatter/gather entries
3940 * @nents: The number of scatter/gather entries
3941 * @direction: The direction of the DMA
3942 */
3943static inline void ib_dma_unmap_sg(struct ib_device *dev,
3944 struct scatterlist *sg, int nents,
3945 enum dma_data_direction direction)
3946{
Bart Van Assche0957c292017-03-07 22:56:53 +00003947 dma_unmap_sg(dev->dma_device, sg, nents, direction);
Ralph Campbell9b513092006-12-12 14:27:41 -08003948}
3949
Arthur Kepnercb9fbc52008-04-29 01:00:34 -07003950static inline int ib_dma_map_sg_attrs(struct ib_device *dev,
3951 struct scatterlist *sg, int nents,
3952 enum dma_data_direction direction,
Krzysztof Kozlowski00085f12016-08-03 13:46:00 -07003953 unsigned long dma_attrs)
Arthur Kepnercb9fbc52008-04-29 01:00:34 -07003954{
Bart Van Assche0957c292017-03-07 22:56:53 +00003955 return dma_map_sg_attrs(dev->dma_device, sg, nents, direction,
3956 dma_attrs);
Arthur Kepnercb9fbc52008-04-29 01:00:34 -07003957}
3958
3959static inline void ib_dma_unmap_sg_attrs(struct ib_device *dev,
3960 struct scatterlist *sg, int nents,
3961 enum dma_data_direction direction,
Krzysztof Kozlowski00085f12016-08-03 13:46:00 -07003962 unsigned long dma_attrs)
Arthur Kepnercb9fbc52008-04-29 01:00:34 -07003963{
Bart Van Assche0957c292017-03-07 22:56:53 +00003964 dma_unmap_sg_attrs(dev->dma_device, sg, nents, direction, dma_attrs);
Arthur Kepnercb9fbc52008-04-29 01:00:34 -07003965}
Ralph Campbell9b513092006-12-12 14:27:41 -08003966
3967/**
Bart Van Assche0b5cb332019-01-22 10:25:20 -08003968 * ib_dma_max_seg_size - Return the size limit of a single DMA transfer
3969 * @dev: The device to query
3970 *
3971 * The returned value represents a size in bytes.
3972 */
3973static inline unsigned int ib_dma_max_seg_size(struct ib_device *dev)
3974{
3975 struct device_dma_parameters *p = dev->dma_device->dma_parms;
3976
3977 return p ? p->max_segment_size : UINT_MAX;
3978}
3979
3980/**
Ralph Campbell9b513092006-12-12 14:27:41 -08003981 * ib_dma_sync_single_for_cpu - Prepare DMA region to be accessed by CPU
3982 * @dev: The device for which the DMA address was created
3983 * @addr: The DMA address
3984 * @size: The size of the region in bytes
3985 * @dir: The direction of the DMA
3986 */
3987static inline void ib_dma_sync_single_for_cpu(struct ib_device *dev,
3988 u64 addr,
3989 size_t size,
3990 enum dma_data_direction dir)
3991{
Bart Van Assche0957c292017-03-07 22:56:53 +00003992 dma_sync_single_for_cpu(dev->dma_device, addr, size, dir);
Ralph Campbell9b513092006-12-12 14:27:41 -08003993}
3994
3995/**
3996 * ib_dma_sync_single_for_device - Prepare DMA region to be accessed by device
3997 * @dev: The device for which the DMA address was created
3998 * @addr: The DMA address
3999 * @size: The size of the region in bytes
4000 * @dir: The direction of the DMA
4001 */
4002static inline void ib_dma_sync_single_for_device(struct ib_device *dev,
4003 u64 addr,
4004 size_t size,
4005 enum dma_data_direction dir)
4006{
Bart Van Assche0957c292017-03-07 22:56:53 +00004007 dma_sync_single_for_device(dev->dma_device, addr, size, dir);
Ralph Campbell9b513092006-12-12 14:27:41 -08004008}
4009
4010/**
4011 * ib_dma_alloc_coherent - Allocate memory and map it for DMA
4012 * @dev: The device for which the DMA address is requested
4013 * @size: The size of the region to allocate in bytes
4014 * @dma_handle: A pointer for returning the DMA address of the region
4015 * @flag: memory allocator flags
4016 */
4017static inline void *ib_dma_alloc_coherent(struct ib_device *dev,
4018 size_t size,
Bart Van Assched43dbac2017-01-20 13:04:10 -08004019 dma_addr_t *dma_handle,
Ralph Campbell9b513092006-12-12 14:27:41 -08004020 gfp_t flag)
4021{
Bart Van Assche0957c292017-03-07 22:56:53 +00004022 return dma_alloc_coherent(dev->dma_device, size, dma_handle, flag);
Ralph Campbell9b513092006-12-12 14:27:41 -08004023}
4024
4025/**
4026 * ib_dma_free_coherent - Free memory allocated by ib_dma_alloc_coherent()
4027 * @dev: The device for which the DMA addresses were allocated
4028 * @size: The size of the region
4029 * @cpu_addr: the address returned by ib_dma_alloc_coherent()
4030 * @dma_handle: the DMA address returned by ib_dma_alloc_coherent()
4031 */
4032static inline void ib_dma_free_coherent(struct ib_device *dev,
4033 size_t size, void *cpu_addr,
Bart Van Assched43dbac2017-01-20 13:04:10 -08004034 dma_addr_t dma_handle)
Ralph Campbell9b513092006-12-12 14:27:41 -08004035{
Bart Van Assche0957c292017-03-07 22:56:53 +00004036 dma_free_coherent(dev->dma_device, size, cpu_addr, dma_handle);
Ralph Campbell9b513092006-12-12 14:27:41 -08004037}
4038
4039/**
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03004040 * ib_dereg_mr_user - Deregisters a memory region and removes it from the
4041 * HCA translation table.
4042 * @mr: The memory region to deregister.
4043 * @udata: Valid user data or NULL for kernel object
4044 *
4045 * This function can fail, if the memory region has memory windows bound to it.
4046 */
4047int ib_dereg_mr_user(struct ib_mr *mr, struct ib_udata *udata);
4048
4049/**
4050 * ib_dereg_mr - Deregisters a kernel memory region and removes it from the
Linus Torvalds1da177e2005-04-16 15:20:36 -07004051 * HCA translation table.
4052 * @mr: The memory region to deregister.
Shani Michaeli7083e422013-02-06 16:19:12 +00004053 *
4054 * This function can fail, if the memory region has memory windows bound to it.
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03004055 *
4056 * NOTE: for user mr use ib_dereg_mr_user with valid udata!
Linus Torvalds1da177e2005-04-16 15:20:36 -07004057 */
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03004058static inline int ib_dereg_mr(struct ib_mr *mr)
4059{
4060 return ib_dereg_mr_user(mr, NULL);
4061}
Linus Torvalds1da177e2005-04-16 15:20:36 -07004062
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03004063struct ib_mr *ib_alloc_mr_user(struct ib_pd *pd, enum ib_mr_type mr_type,
4064 u32 max_num_sg, struct ib_udata *udata);
4065
4066static inline struct ib_mr *ib_alloc_mr(struct ib_pd *pd,
4067 enum ib_mr_type mr_type, u32 max_num_sg)
4068{
4069 return ib_alloc_mr_user(pd, mr_type, max_num_sg, NULL);
4070}
Steve Wise00f7ec32008-07-14 23:48:45 -07004071
Israel Rukshin26bc7ea2019-06-11 18:52:39 +03004072struct ib_mr *ib_alloc_mr_integrity(struct ib_pd *pd,
4073 u32 max_num_data_sg,
4074 u32 max_num_meta_sg);
4075
Steve Wise00f7ec32008-07-14 23:48:45 -07004076/**
Steve Wise00f7ec32008-07-14 23:48:45 -07004077 * ib_update_fast_reg_key - updates the key portion of the fast_reg MR
4078 * R_Key and L_Key.
4079 * @mr - struct ib_mr pointer to be updated.
4080 * @newkey - new key to be used.
4081 */
4082static inline void ib_update_fast_reg_key(struct ib_mr *mr, u8 newkey)
4083{
4084 mr->lkey = (mr->lkey & 0xffffff00) | newkey;
4085 mr->rkey = (mr->rkey & 0xffffff00) | newkey;
4086}
4087
4088/**
Shani Michaeli7083e422013-02-06 16:19:12 +00004089 * ib_inc_rkey - increments the key portion of the given rkey. Can be used
4090 * for calculating a new rkey for type 2 memory windows.
4091 * @rkey - the rkey to increment.
4092 */
4093static inline u32 ib_inc_rkey(u32 rkey)
4094{
4095 const u32 mask = 0x000000ff;
4096 return ((rkey + 1) & mask) | (rkey & ~mask);
4097}
4098
4099/**
Linus Torvalds1da177e2005-04-16 15:20:36 -07004100 * ib_alloc_fmr - Allocates a unmapped fast memory region.
4101 * @pd: The protection domain associated with the unmapped region.
4102 * @mr_access_flags: Specifies the memory access rights.
4103 * @fmr_attr: Attributes of the unmapped region.
4104 *
4105 * A fast memory region must be mapped before it can be used as part of
4106 * a work request.
4107 */
4108struct ib_fmr *ib_alloc_fmr(struct ib_pd *pd,
4109 int mr_access_flags,
4110 struct ib_fmr_attr *fmr_attr);
4111
4112/**
4113 * ib_map_phys_fmr - Maps a list of physical pages to a fast memory region.
4114 * @fmr: The fast memory region to associate with the pages.
4115 * @page_list: An array of physical pages to map to the fast memory region.
4116 * @list_len: The number of pages in page_list.
4117 * @iova: The I/O virtual address to use with the mapped region.
4118 */
4119static inline int ib_map_phys_fmr(struct ib_fmr *fmr,
4120 u64 *page_list, int list_len,
4121 u64 iova)
4122{
Kamal Heib3023a1e2018-12-10 21:09:48 +02004123 return fmr->device->ops.map_phys_fmr(fmr, page_list, list_len, iova);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004124}
4125
4126/**
4127 * ib_unmap_fmr - Removes the mapping from a list of fast memory regions.
4128 * @fmr_list: A linked list of fast memory regions to unmap.
4129 */
4130int ib_unmap_fmr(struct list_head *fmr_list);
4131
4132/**
4133 * ib_dealloc_fmr - Deallocates a fast memory region.
4134 * @fmr: The fast memory region to deallocate.
4135 */
4136int ib_dealloc_fmr(struct ib_fmr *fmr);
4137
4138/**
4139 * ib_attach_mcast - Attaches the specified QP to a multicast group.
4140 * @qp: QP to attach to the multicast group. The QP must be type
4141 * IB_QPT_UD.
4142 * @gid: Multicast group GID.
4143 * @lid: Multicast group LID in host byte order.
4144 *
4145 * In order to send and receive multicast packets, subnet
4146 * administration must have created the multicast group and configured
4147 * the fabric appropriately. The port associated with the specified
4148 * QP must also be a member of the multicast group.
4149 */
4150int ib_attach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);
4151
4152/**
4153 * ib_detach_mcast - Detaches the specified QP from a multicast group.
4154 * @qp: QP to detach from the multicast group.
4155 * @gid: Multicast group GID.
4156 * @lid: Multicast group LID in host byte order.
4157 */
4158int ib_detach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);
4159
Sean Hefty59991f92011-05-23 17:52:46 -07004160/**
4161 * ib_alloc_xrcd - Allocates an XRC domain.
4162 * @device: The device on which to allocate the XRC domain.
Leon Romanovskyf66c8ba2018-01-28 11:17:19 +02004163 * @caller: Module name for kernel consumers
Sean Hefty59991f92011-05-23 17:52:46 -07004164 */
Leon Romanovskyf66c8ba2018-01-28 11:17:19 +02004165struct ib_xrcd *__ib_alloc_xrcd(struct ib_device *device, const char *caller);
4166#define ib_alloc_xrcd(device) \
4167 __ib_alloc_xrcd((device), KBUILD_MODNAME)
Sean Hefty59991f92011-05-23 17:52:46 -07004168
4169/**
4170 * ib_dealloc_xrcd - Deallocates an XRC domain.
4171 * @xrcd: The XRC domain to deallocate.
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03004172 * @udata: Valid user data or NULL for kernel object
Sean Hefty59991f92011-05-23 17:52:46 -07004173 */
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03004174int ib_dealloc_xrcd(struct ib_xrcd *xrcd, struct ib_udata *udata);
Sean Hefty59991f92011-05-23 17:52:46 -07004175
Eli Cohen1c636f82013-10-31 15:26:32 +02004176static inline int ib_check_mr_access(int flags)
4177{
4178 /*
4179 * Local write permission is required if remote write or
4180 * remote atomic permission is also requested.
4181 */
4182 if (flags & (IB_ACCESS_REMOTE_ATOMIC | IB_ACCESS_REMOTE_WRITE) &&
4183 !(flags & IB_ACCESS_LOCAL_WRITE))
4184 return -EINVAL;
4185
4186 return 0;
4187}
4188
Jack Morgenstein08bb5582018-05-23 15:30:30 +03004189static inline bool ib_access_writable(int access_flags)
4190{
4191 /*
4192 * We have writable memory backing the MR if any of the following
4193 * access flags are set. "Local write" and "remote write" obviously
4194 * require write access. "Remote atomic" can do things like fetch and
4195 * add, which will modify memory, and "MW bind" can change permissions
4196 * by binding a window.
4197 */
4198 return access_flags &
4199 (IB_ACCESS_LOCAL_WRITE | IB_ACCESS_REMOTE_WRITE |
4200 IB_ACCESS_REMOTE_ATOMIC | IB_ACCESS_MW_BIND);
4201}
4202
Sagi Grimberg1b01d332014-02-23 14:19:05 +02004203/**
4204 * ib_check_mr_status: lightweight check of MR status.
4205 * This routine may provide status checks on a selected
4206 * ib_mr. first use is for signature status check.
4207 *
4208 * @mr: A memory region.
4209 * @check_mask: Bitmask of which checks to perform from
4210 * ib_mr_status_check enumeration.
4211 * @mr_status: The container of relevant status checks.
4212 * failed checks will be indicated in the status bitmask
4213 * and the relevant info shall be in the error item.
4214 */
4215int ib_check_mr_status(struct ib_mr *mr, u32 check_mask,
4216 struct ib_mr_status *mr_status);
4217
Jason Gunthorped79af722019-01-10 14:02:24 -07004218/**
4219 * ib_device_try_get: Hold a registration lock
4220 * device: The device to lock
4221 *
4222 * A device under an active registration lock cannot become unregistered. It
4223 * is only possible to obtain a registration lock on a device that is fully
4224 * registered, otherwise this function returns false.
4225 *
4226 * The registration lock is only necessary for actions which require the
4227 * device to still be registered. Uses that only require the device pointer to
4228 * be valid should use get_device(&ibdev->dev) to hold the memory.
4229 *
4230 */
4231static inline bool ib_device_try_get(struct ib_device *dev)
4232{
4233 return refcount_inc_not_zero(&dev->refcount);
4234}
4235
4236void ib_device_put(struct ib_device *device);
Jason Gunthorpe324e2272019-02-12 21:12:51 -07004237struct ib_device *ib_device_get_by_netdev(struct net_device *ndev,
4238 enum rdma_driver_id driver_id);
4239struct ib_device *ib_device_get_by_name(const char *name,
4240 enum rdma_driver_id driver_id);
Yotam Kenneth9268f722015-07-30 17:50:15 +03004241struct net_device *ib_get_net_dev_by_params(struct ib_device *dev, u8 port,
4242 u16 pkey, const union ib_gid *gid,
4243 const struct sockaddr *addr);
Jason Gunthorpec2261dd2019-02-12 21:12:50 -07004244int ib_device_set_netdev(struct ib_device *ib_dev, struct net_device *ndev,
4245 unsigned int port);
4246struct net_device *ib_device_netdev(struct ib_device *dev, u8 port);
4247
Yishai Hadas5fd251c2016-05-23 15:20:48 +03004248struct ib_wq *ib_create_wq(struct ib_pd *pd,
4249 struct ib_wq_init_attr *init_attr);
Shamir Rabinovitchc4367a22019-03-31 19:10:05 +03004250int ib_destroy_wq(struct ib_wq *wq, struct ib_udata *udata);
Yishai Hadas5fd251c2016-05-23 15:20:48 +03004251int ib_modify_wq(struct ib_wq *wq, struct ib_wq_attr *attr,
4252 u32 wq_attr_mask);
Yishai Hadas6d397862016-05-23 15:20:51 +03004253struct ib_rwq_ind_table *ib_create_rwq_ind_table(struct ib_device *device,
4254 struct ib_rwq_ind_table_init_attr*
4255 wq_ind_table_init_attr);
4256int ib_destroy_rwq_ind_table(struct ib_rwq_ind_table *wq_ind_table);
Yotam Kenneth9268f722015-07-30 17:50:15 +03004257
Christoph Hellwigff2ba992016-05-03 18:01:04 +02004258int ib_map_mr_sg(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,
Bart Van Assche9aa8b322016-05-12 10:49:15 -07004259 unsigned int *sg_offset, unsigned int page_size);
Max Gurtovoy2cdfcdd2019-06-11 18:52:40 +03004260int ib_map_mr_sg_pi(struct ib_mr *mr, struct scatterlist *data_sg,
4261 int data_sg_nents, unsigned int *data_sg_offset,
4262 struct scatterlist *meta_sg, int meta_sg_nents,
4263 unsigned int *meta_sg_offset, unsigned int page_size);
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03004264
4265static inline int
Christoph Hellwigff2ba992016-05-03 18:01:04 +02004266ib_map_mr_sg_zbva(struct ib_mr *mr, struct scatterlist *sg, int sg_nents,
Bart Van Assche9aa8b322016-05-12 10:49:15 -07004267 unsigned int *sg_offset, unsigned int page_size)
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03004268{
4269 int n;
4270
Christoph Hellwigff2ba992016-05-03 18:01:04 +02004271 n = ib_map_mr_sg(mr, sg, sg_nents, sg_offset, page_size);
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03004272 mr->iova = 0;
4273
4274 return n;
4275}
4276
Christoph Hellwigff2ba992016-05-03 18:01:04 +02004277int ib_sg_to_pages(struct ib_mr *mr, struct scatterlist *sgl, int sg_nents,
Bart Van Assche9aa8b322016-05-12 10:49:15 -07004278 unsigned int *sg_offset, int (*set_page)(struct ib_mr *, u64));
Sagi Grimberg4c67e2b2015-10-13 19:11:24 +03004279
Steve Wise765d6772016-02-17 08:15:41 -08004280void ib_drain_rq(struct ib_qp *qp);
4281void ib_drain_sq(struct ib_qp *qp);
4282void ib_drain_qp(struct ib_qp *qp);
Moni Shoua850d8fd2016-11-10 11:30:56 +02004283
Yuval Shaiad4186192017-06-14 23:13:34 +03004284int ib_get_eth_speed(struct ib_device *dev, u8 port_num, u8 *speed, u8 *width);
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04004285
4286static inline u8 *rdma_ah_retrieve_dmac(struct rdma_ah_attr *attr)
4287{
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04004288 if (attr->type == RDMA_AH_ATTR_TYPE_ROCE)
4289 return attr->roce.dmac;
4290 return NULL;
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04004291}
4292
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -04004293static inline void rdma_ah_set_dlid(struct rdma_ah_attr *attr, u32 dlid)
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04004294{
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04004295 if (attr->type == RDMA_AH_ATTR_TYPE_IB)
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -04004296 attr->ib.dlid = (u16)dlid;
4297 else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
4298 attr->opa.dlid = dlid;
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04004299}
4300
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -04004301static inline u32 rdma_ah_get_dlid(const struct rdma_ah_attr *attr)
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04004302{
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04004303 if (attr->type == RDMA_AH_ATTR_TYPE_IB)
4304 return attr->ib.dlid;
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -04004305 else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
4306 return attr->opa.dlid;
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04004307 return 0;
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04004308}
4309
4310static inline void rdma_ah_set_sl(struct rdma_ah_attr *attr, u8 sl)
4311{
4312 attr->sl = sl;
4313}
4314
4315static inline u8 rdma_ah_get_sl(const struct rdma_ah_attr *attr)
4316{
4317 return attr->sl;
4318}
4319
4320static inline void rdma_ah_set_path_bits(struct rdma_ah_attr *attr,
4321 u8 src_path_bits)
4322{
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04004323 if (attr->type == RDMA_AH_ATTR_TYPE_IB)
4324 attr->ib.src_path_bits = src_path_bits;
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -04004325 else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
4326 attr->opa.src_path_bits = src_path_bits;
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04004327}
4328
4329static inline u8 rdma_ah_get_path_bits(const struct rdma_ah_attr *attr)
4330{
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04004331 if (attr->type == RDMA_AH_ATTR_TYPE_IB)
4332 return attr->ib.src_path_bits;
Dasaratharaman Chandramouli64b46462017-04-29 14:41:30 -04004333 else if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
4334 return attr->opa.src_path_bits;
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04004335 return 0;
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04004336}
4337
Don Hiattd98bb7f2017-08-04 13:54:16 -07004338static inline void rdma_ah_set_make_grd(struct rdma_ah_attr *attr,
4339 bool make_grd)
4340{
4341 if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
4342 attr->opa.make_grd = make_grd;
4343}
4344
4345static inline bool rdma_ah_get_make_grd(const struct rdma_ah_attr *attr)
4346{
4347 if (attr->type == RDMA_AH_ATTR_TYPE_OPA)
4348 return attr->opa.make_grd;
4349 return false;
4350}
4351
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04004352static inline void rdma_ah_set_port_num(struct rdma_ah_attr *attr, u8 port_num)
4353{
4354 attr->port_num = port_num;
4355}
4356
4357static inline u8 rdma_ah_get_port_num(const struct rdma_ah_attr *attr)
4358{
4359 return attr->port_num;
4360}
4361
4362static inline void rdma_ah_set_static_rate(struct rdma_ah_attr *attr,
4363 u8 static_rate)
4364{
4365 attr->static_rate = static_rate;
4366}
4367
4368static inline u8 rdma_ah_get_static_rate(const struct rdma_ah_attr *attr)
4369{
4370 return attr->static_rate;
4371}
4372
4373static inline void rdma_ah_set_ah_flags(struct rdma_ah_attr *attr,
4374 enum ib_ah_flags flag)
4375{
4376 attr->ah_flags = flag;
4377}
4378
4379static inline enum ib_ah_flags
4380 rdma_ah_get_ah_flags(const struct rdma_ah_attr *attr)
4381{
4382 return attr->ah_flags;
4383}
4384
4385static inline const struct ib_global_route
4386 *rdma_ah_read_grh(const struct rdma_ah_attr *attr)
4387{
4388 return &attr->grh;
4389}
4390
4391/*To retrieve and modify the grh */
4392static inline struct ib_global_route
4393 *rdma_ah_retrieve_grh(struct rdma_ah_attr *attr)
4394{
4395 return &attr->grh;
4396}
4397
4398static inline void rdma_ah_set_dgid_raw(struct rdma_ah_attr *attr, void *dgid)
4399{
4400 struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
4401
4402 memcpy(grh->dgid.raw, dgid, sizeof(grh->dgid));
4403}
4404
4405static inline void rdma_ah_set_subnet_prefix(struct rdma_ah_attr *attr,
4406 __be64 prefix)
4407{
4408 struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
4409
4410 grh->dgid.global.subnet_prefix = prefix;
4411}
4412
4413static inline void rdma_ah_set_interface_id(struct rdma_ah_attr *attr,
4414 __be64 if_id)
4415{
4416 struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
4417
4418 grh->dgid.global.interface_id = if_id;
4419}
4420
4421static inline void rdma_ah_set_grh(struct rdma_ah_attr *attr,
4422 union ib_gid *dgid, u32 flow_label,
4423 u8 sgid_index, u8 hop_limit,
4424 u8 traffic_class)
4425{
4426 struct ib_global_route *grh = rdma_ah_retrieve_grh(attr);
4427
4428 attr->ah_flags = IB_AH_GRH;
4429 if (dgid)
4430 grh->dgid = *dgid;
4431 grh->flow_label = flow_label;
4432 grh->sgid_index = sgid_index;
4433 grh->hop_limit = hop_limit;
4434 grh->traffic_class = traffic_class;
Jason Gunthorpe8d9ec9a2018-06-13 10:22:03 +03004435 grh->sgid_attr = NULL;
Dasaratharaman Chandramouli2224c472017-04-29 14:41:27 -04004436}
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04004437
Jason Gunthorpe8d9ec9a2018-06-13 10:22:03 +03004438void rdma_destroy_ah_attr(struct rdma_ah_attr *ah_attr);
4439void rdma_move_grh_sgid_attr(struct rdma_ah_attr *attr, union ib_gid *dgid,
4440 u32 flow_label, u8 hop_limit, u8 traffic_class,
4441 const struct ib_gid_attr *sgid_attr);
Jason Gunthorped97099f2018-06-13 10:22:05 +03004442void rdma_copy_ah_attr(struct rdma_ah_attr *dest,
4443 const struct rdma_ah_attr *src);
4444void rdma_replace_ah_attr(struct rdma_ah_attr *old,
4445 const struct rdma_ah_attr *new);
4446void rdma_move_ah_attr(struct rdma_ah_attr *dest, struct rdma_ah_attr *src);
Jason Gunthorpe8d9ec9a2018-06-13 10:22:03 +03004447
Don Hiatt87daac62018-02-01 10:57:03 -08004448/**
4449 * rdma_ah_find_type - Return address handle type.
4450 *
4451 * @dev: Device to be checked
4452 * @port_num: Port number
4453 */
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04004454static inline enum rdma_ah_attr_type rdma_ah_find_type(struct ib_device *dev,
Don Hiatt87daac62018-02-01 10:57:03 -08004455 u8 port_num)
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04004456{
Parav Pandita6532e72018-01-12 07:58:42 +02004457 if (rdma_protocol_roce(dev, port_num))
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04004458 return RDMA_AH_ATTR_TYPE_ROCE;
Don Hiatt87daac62018-02-01 10:57:03 -08004459 if (rdma_protocol_ib(dev, port_num)) {
4460 if (rdma_cap_opa_ah(dev, port_num))
4461 return RDMA_AH_ATTR_TYPE_OPA;
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04004462 return RDMA_AH_ATTR_TYPE_IB;
Don Hiatt87daac62018-02-01 10:57:03 -08004463 }
4464
4465 return RDMA_AH_ATTR_TYPE_UNDEFINED;
Dasaratharaman Chandramouli44c58482017-04-29 14:41:29 -04004466}
Hiatt, Don7db20ec2017-06-08 13:37:49 -04004467
Hiatt, Don62ede772017-08-14 14:17:43 -04004468/**
4469 * ib_lid_cpu16 - Return lid in 16bit CPU encoding.
4470 * In the current implementation the only way to get
4471 * get the 32bit lid is from other sources for OPA.
4472 * For IB, lids will always be 16bits so cast the
4473 * value accordingly.
4474 *
4475 * @lid: A 32bit LID
4476 */
4477static inline u16 ib_lid_cpu16(u32 lid)
Hiatt, Don7db20ec2017-06-08 13:37:49 -04004478{
Hiatt, Don62ede772017-08-14 14:17:43 -04004479 WARN_ON_ONCE(lid & 0xFFFF0000);
4480 return (u16)lid;
Hiatt, Don7db20ec2017-06-08 13:37:49 -04004481}
4482
Hiatt, Don62ede772017-08-14 14:17:43 -04004483/**
4484 * ib_lid_be16 - Return lid in 16bit BE encoding.
4485 *
4486 * @lid: A 32bit LID
4487 */
4488static inline __be16 ib_lid_be16(u32 lid)
Hiatt, Don7db20ec2017-06-08 13:37:49 -04004489{
Hiatt, Don62ede772017-08-14 14:17:43 -04004490 WARN_ON_ONCE(lid & 0xFFFF0000);
4491 return cpu_to_be16((u16)lid);
Hiatt, Don7db20ec2017-06-08 13:37:49 -04004492}
Doug Ledford32043832017-08-10 14:31:29 -04004493
Sagi Grimbergc66cd352017-07-13 11:09:41 +03004494/**
4495 * ib_get_vector_affinity - Get the affinity mappings of a given completion
4496 * vector
4497 * @device: the rdma device
4498 * @comp_vector: index of completion vector
4499 *
4500 * Returns NULL on failure, otherwise a corresponding cpu map of the
4501 * completion vector (returns all-cpus map if the device driver doesn't
4502 * implement get_vector_affinity).
4503 */
4504static inline const struct cpumask *
4505ib_get_vector_affinity(struct ib_device *device, int comp_vector)
4506{
4507 if (comp_vector < 0 || comp_vector >= device->num_comp_vectors ||
Kamal Heib3023a1e2018-12-10 21:09:48 +02004508 !device->ops.get_vector_affinity)
Sagi Grimbergc66cd352017-07-13 11:09:41 +03004509 return NULL;
4510
Kamal Heib3023a1e2018-12-10 21:09:48 +02004511 return device->ops.get_vector_affinity(device, comp_vector);
Sagi Grimbergc66cd352017-07-13 11:09:41 +03004512
4513}
4514
Daniel Jurgens32f69e42018-01-04 17:25:36 +02004515/**
4516 * rdma_roce_rescan_device - Rescan all of the network devices in the system
4517 * and add their gids, as needed, to the relevant RoCE devices.
4518 *
4519 * @device: the rdma device
4520 */
4521void rdma_roce_rescan_device(struct ib_device *ibdev);
4522
Jason Gunthorpe8313c102018-11-25 20:51:13 +02004523struct ib_ucontext *ib_uverbs_get_ucontext_file(struct ib_uverbs_file *ufile);
Yishai Hadas7dc08dc2018-06-17 12:59:59 +03004524
Jason Gunthorpe15a1b4b2018-11-25 20:51:15 +02004525int uverbs_destroy_def_handler(struct uverbs_attr_bundle *attrs);
Denis Drozdovf6a8a192018-08-14 14:08:51 +03004526
4527struct net_device *rdma_alloc_netdev(struct ib_device *device, u8 port_num,
4528 enum rdma_netdev_t type, const char *name,
4529 unsigned char name_assign_type,
4530 void (*setup)(struct net_device *));
Denis Drozdov5d6b0cb2018-08-14 14:22:35 +03004531
4532int rdma_init_netdev(struct ib_device *device, u8 port_num,
4533 enum rdma_netdev_t type, const char *name,
4534 unsigned char name_assign_type,
4535 void (*setup)(struct net_device *),
4536 struct net_device *netdev);
4537
Parav Panditd4122f52018-10-11 22:31:53 +03004538/**
4539 * rdma_set_device_sysfs_group - Set device attributes group to have
4540 * driver specific sysfs entries at
4541 * for infiniband class.
4542 *
4543 * @device: device pointer for which attributes to be created
4544 * @group: Pointer to group which should be added when device
4545 * is registered with sysfs.
4546 * rdma_set_device_sysfs_group() allows existing drivers to expose one
4547 * group per device to have sysfs attributes.
4548 *
4549 * NOTE: New drivers should not make use of this API; instead new device
4550 * parameter should be exposed via netlink command. This API and mechanism
4551 * exist only for existing drivers.
4552 */
4553static inline void
4554rdma_set_device_sysfs_group(struct ib_device *dev,
4555 const struct attribute_group *group)
4556{
4557 dev->groups[1] = group;
4558}
4559
Parav Pandit54747232018-12-18 14:15:56 +02004560/**
4561 * rdma_device_to_ibdev - Get ib_device pointer from device pointer
4562 *
4563 * @device: device pointer for which ib_device pointer to retrieve
4564 *
4565 * rdma_device_to_ibdev() retrieves ib_device pointer from device.
4566 *
4567 */
4568static inline struct ib_device *rdma_device_to_ibdev(struct device *device)
4569{
Parav Panditcebe5562019-02-26 13:56:11 +02004570 struct ib_core_device *coredev =
4571 container_of(device, struct ib_core_device, dev);
4572
4573 return coredev->owner;
Parav Pandit54747232018-12-18 14:15:56 +02004574}
4575
4576/**
4577 * rdma_device_to_drv_device - Helper macro to reach back to driver's
4578 * ib_device holder structure from device pointer.
4579 *
4580 * NOTE: New drivers should not make use of this API; This API is only for
4581 * existing drivers who have exposed sysfs entries using
4582 * rdma_set_device_sysfs_group().
4583 */
4584#define rdma_device_to_drv_device(dev, drv_dev_struct, ibdev_member) \
4585 container_of(rdma_device_to_ibdev(dev), drv_dev_struct, ibdev_member)
Parav Pandit41c61402019-02-26 14:01:46 +02004586
4587bool rdma_dev_access_netns(const struct ib_device *device,
4588 const struct net *net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004589#endif /* IB_VERBS_H */