GNU Linux-libre 6.9.2-gnu
[releases.git] / include / rdma / rdma_cm.h
1 /* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */
2 /*
3  * Copyright (c) 2005 Voltaire Inc.  All rights reserved.
4  * Copyright (c) 2005 Intel Corporation.  All rights reserved.
5  */
6
7 #ifndef RDMA_CM_H
8 #define RDMA_CM_H
9
10 #include <linux/socket.h>
11 #include <linux/in6.h>
12 #include <rdma/ib_addr.h>
13 #include <rdma/ib_sa.h>
14 #include <uapi/rdma/rdma_user_cm.h>
15
16 /*
17  * Upon receiving a device removal event, users must destroy the associated
18  * RDMA identifier and release all resources allocated with the device.
19  */
20 enum rdma_cm_event_type {
21         RDMA_CM_EVENT_ADDR_RESOLVED,
22         RDMA_CM_EVENT_ADDR_ERROR,
23         RDMA_CM_EVENT_ROUTE_RESOLVED,
24         RDMA_CM_EVENT_ROUTE_ERROR,
25         RDMA_CM_EVENT_CONNECT_REQUEST,
26         RDMA_CM_EVENT_CONNECT_RESPONSE,
27         RDMA_CM_EVENT_CONNECT_ERROR,
28         RDMA_CM_EVENT_UNREACHABLE,
29         RDMA_CM_EVENT_REJECTED,
30         RDMA_CM_EVENT_ESTABLISHED,
31         RDMA_CM_EVENT_DISCONNECTED,
32         RDMA_CM_EVENT_DEVICE_REMOVAL,
33         RDMA_CM_EVENT_MULTICAST_JOIN,
34         RDMA_CM_EVENT_MULTICAST_ERROR,
35         RDMA_CM_EVENT_ADDR_CHANGE,
36         RDMA_CM_EVENT_TIMEWAIT_EXIT
37 };
38
39 const char *__attribute_const__ rdma_event_msg(enum rdma_cm_event_type event);
40
41 #define RDMA_IB_IP_PS_MASK   0xFFFFFFFFFFFF0000ULL
42 #define RDMA_IB_IP_PS_TCP    0x0000000001060000ULL
43 #define RDMA_IB_IP_PS_UDP    0x0000000001110000ULL
44 #define RDMA_IB_IP_PS_IB     0x00000000013F0000ULL
45
46 struct rdma_addr {
47         struct sockaddr_storage src_addr;
48         struct sockaddr_storage dst_addr;
49         struct rdma_dev_addr dev_addr;
50 };
51
52 struct rdma_route {
53         struct rdma_addr addr;
54         struct sa_path_rec *path_rec;
55
56         /* Optional path records of primary path */
57         struct sa_path_rec *path_rec_inbound;
58         struct sa_path_rec *path_rec_outbound;
59
60         /*
61          * 0 - No primary nor alternate path is available
62          * 1 - Only primary path is available
63          * 2 - Both primary and alternate path are available
64          */
65         int num_pri_alt_paths;
66 };
67
68 struct rdma_conn_param {
69         const void *private_data;
70         u8 private_data_len;
71         u8 responder_resources;
72         u8 initiator_depth;
73         u8 flow_control;
74         u8 retry_count;         /* ignored when accepting */
75         u8 rnr_retry_count;
76         /* Fields below ignored if a QP is created on the rdma_cm_id. */
77         u8 srq;
78         u32 qp_num;
79         u32 qkey;
80 };
81
82 struct rdma_ud_param {
83         const void *private_data;
84         u8 private_data_len;
85         struct rdma_ah_attr ah_attr;
86         u32 qp_num;
87         u32 qkey;
88 };
89
90 struct rdma_cm_event {
91         enum rdma_cm_event_type  event;
92         int                      status;
93         union {
94                 struct rdma_conn_param  conn;
95                 struct rdma_ud_param    ud;
96         } param;
97         struct rdma_ucm_ece ece;
98 };
99
100 struct rdma_cm_id;
101
102 /**
103  * rdma_cm_event_handler - Callback used to report user events.
104  *
105  * Notes: Users may not call rdma_destroy_id from this callback to destroy
106  *   the passed in id, or a corresponding listen id.  Returning a
107  *   non-zero value from the callback will destroy the passed in id.
108  */
109 typedef int (*rdma_cm_event_handler)(struct rdma_cm_id *id,
110                                      struct rdma_cm_event *event);
111
112 struct rdma_cm_id {
113         struct ib_device        *device;
114         void                    *context;
115         struct ib_qp            *qp;
116         rdma_cm_event_handler    event_handler;
117         struct rdma_route        route;
118         enum rdma_ucm_port_space ps;
119         enum ib_qp_type          qp_type;
120         u32                      port_num;
121         struct work_struct net_work;
122 };
123
124 struct rdma_cm_id *
125 __rdma_create_kernel_id(struct net *net, rdma_cm_event_handler event_handler,
126                         void *context, enum rdma_ucm_port_space ps,
127                         enum ib_qp_type qp_type, const char *caller);
128 struct rdma_cm_id *rdma_create_user_id(rdma_cm_event_handler event_handler,
129                                        void *context,
130                                        enum rdma_ucm_port_space ps,
131                                        enum ib_qp_type qp_type);
132
133 /**
134  * rdma_create_id - Create an RDMA identifier.
135  *
136  * @net: The network namespace in which to create the new id.
137  * @event_handler: User callback invoked to report events associated with the
138  *   returned rdma_id.
139  * @context: User specified context associated with the id.
140  * @ps: RDMA port space.
141  * @qp_type: type of queue pair associated with the id.
142  *
143  * Returns a new rdma_cm_id. The id holds a reference on the network
144  * namespace until it is destroyed.
145  *
146  * The event handler callback serializes on the id's mutex and is
147  * allowed to sleep.
148  */
149 #define rdma_create_id(net, event_handler, context, ps, qp_type)               \
150         __rdma_create_kernel_id(net, event_handler, context, ps, qp_type,      \
151                                 KBUILD_MODNAME)
152
153 /**
154   * rdma_destroy_id - Destroys an RDMA identifier.
155   *
156   * @id: RDMA identifier.
157   *
158   * Note: calling this function has the effect of canceling in-flight
159   * asynchronous operations associated with the id.
160   */
161 void rdma_destroy_id(struct rdma_cm_id *id);
162
163 /**
164  * rdma_bind_addr - Bind an RDMA identifier to a source address and
165  *   associated RDMA device, if needed.
166  *
167  * @id: RDMA identifier.
168  * @addr: Local address information.  Wildcard values are permitted.
169  *
170  * This associates a source address with the RDMA identifier before calling
171  * rdma_listen.  If a specific local address is given, the RDMA identifier will
172  * be bound to a local RDMA device.
173  */
174 int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr);
175
176 /**
177  * rdma_resolve_addr - Resolve destination and optional source addresses
178  *   from IP addresses to an RDMA address.  If successful, the specified
179  *   rdma_cm_id will be bound to a local device.
180  *
181  * @id: RDMA identifier.
182  * @src_addr: Source address information.  This parameter may be NULL.
183  * @dst_addr: Destination address information.
184  * @timeout_ms: Time to wait for resolution to complete.
185  */
186 int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr,
187                       const struct sockaddr *dst_addr,
188                       unsigned long timeout_ms);
189
190 /**
191  * rdma_resolve_route - Resolve the RDMA address bound to the RDMA identifier
192  *   into route information needed to establish a connection.
193  *
194  * This is called on the client side of a connection.
195  * Users must have first called rdma_resolve_addr to resolve a dst_addr
196  * into an RDMA address before calling this routine.
197  */
198 int rdma_resolve_route(struct rdma_cm_id *id, unsigned long timeout_ms);
199
200 /**
201  * rdma_create_qp - Allocate a QP and associate it with the specified RDMA
202  * identifier.
203  *
204  * QPs allocated to an rdma_cm_id will automatically be transitioned by the CMA
205  * through their states.
206  */
207 int rdma_create_qp(struct rdma_cm_id *id, struct ib_pd *pd,
208                    struct ib_qp_init_attr *qp_init_attr);
209
210 /**
211  * rdma_destroy_qp - Deallocate the QP associated with the specified RDMA
212  * identifier.
213  *
214  * Users must destroy any QP associated with an RDMA identifier before
215  * destroying the RDMA ID.
216  */
217 void rdma_destroy_qp(struct rdma_cm_id *id);
218
219 /**
220  * rdma_init_qp_attr - Initializes the QP attributes for use in transitioning
221  *   to a specified QP state.
222  * @id: Communication identifier associated with the QP attributes to
223  *   initialize.
224  * @qp_attr: On input, specifies the desired QP state.  On output, the
225  *   mandatory and desired optional attributes will be set in order to
226  *   modify the QP to the specified state.
227  * @qp_attr_mask: The QP attribute mask that may be used to transition the
228  *   QP to the specified state.
229  *
230  * Users must set the @qp_attr->qp_state to the desired QP state.  This call
231  * will set all required attributes for the given transition, along with
232  * known optional attributes.  Users may override the attributes returned from
233  * this call before calling ib_modify_qp.
234  *
235  * Users that wish to have their QP automatically transitioned through its
236  * states can associate a QP with the rdma_cm_id by calling rdma_create_qp().
237  */
238 int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr,
239                        int *qp_attr_mask);
240
241 int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param);
242 int rdma_connect_locked(struct rdma_cm_id *id,
243                         struct rdma_conn_param *conn_param);
244
245 int rdma_connect_ece(struct rdma_cm_id *id, struct rdma_conn_param *conn_param,
246                      struct rdma_ucm_ece *ece);
247
248 /**
249  * rdma_listen - This function is called by the passive side to
250  *   listen for incoming connection requests.
251  *
252  * Users must have bound the rdma_cm_id to a local address by calling
253  * rdma_bind_addr before calling this routine.
254  */
255 int rdma_listen(struct rdma_cm_id *id, int backlog);
256
257 int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param);
258
259 void rdma_lock_handler(struct rdma_cm_id *id);
260 void rdma_unlock_handler(struct rdma_cm_id *id);
261 int rdma_accept_ece(struct rdma_cm_id *id, struct rdma_conn_param *conn_param,
262                     struct rdma_ucm_ece *ece);
263
264 /**
265  * rdma_notify - Notifies the RDMA CM of an asynchronous event that has
266  * occurred on the connection.
267  * @id: Connection identifier to transition to established.
268  * @event: Asynchronous event.
269  *
270  * This routine should be invoked by users to notify the CM of relevant
271  * communication events.  Events that should be reported to the CM and
272  * when to report them are:
273  *
274  * IB_EVENT_COMM_EST - Used when a message is received on a connected
275  *    QP before an RTU has been received.
276  */
277 int rdma_notify(struct rdma_cm_id *id, enum ib_event_type event);
278
279 /**
280  * rdma_reject - Called to reject a connection request or response.
281  */
282 int rdma_reject(struct rdma_cm_id *id, const void *private_data,
283                 u8 private_data_len, u8 reason);
284
285 /**
286  * rdma_disconnect - This function disconnects the associated QP and
287  *   transitions it into the error state.
288  */
289 int rdma_disconnect(struct rdma_cm_id *id);
290
291 /**
292  * rdma_join_multicast - Join the multicast group specified by the given
293  *   address.
294  * @id: Communication identifier associated with the request.
295  * @addr: Multicast address identifying the group to join.
296  * @join_state: Multicast JoinState bitmap requested by port.
297  *              Bitmap is based on IB_SA_MCMEMBER_REC_JOIN_STATE bits.
298  * @context: User-defined context associated with the join request, returned
299  * to the user through the private_data pointer in multicast events.
300  */
301 int rdma_join_multicast(struct rdma_cm_id *id, struct sockaddr *addr,
302                         u8 join_state, void *context);
303
304 /**
305  * rdma_leave_multicast - Leave the multicast group specified by the given
306  *   address.
307  */
308 void rdma_leave_multicast(struct rdma_cm_id *id, struct sockaddr *addr);
309
310 /**
311  * rdma_set_service_type - Set the type of service associated with a
312  *   connection identifier.
313  * @id: Communication identifier to associated with service type.
314  * @tos: Type of service.
315  *
316  * The type of service is interpretted as a differentiated service
317  * field (RFC 2474).  The service type should be specified before
318  * performing route resolution, as existing communication on the
319  * connection identifier may be unaffected.  The type of service
320  * requested may not be supported by the network to all destinations.
321  */
322 void rdma_set_service_type(struct rdma_cm_id *id, int tos);
323
324 /**
325  * rdma_set_reuseaddr - Allow the reuse of local addresses when binding
326  *    the rdma_cm_id.
327  * @id: Communication identifier to configure.
328  * @reuse: Value indicating if the bound address is reusable.
329  *
330  * Reuse must be set before an address is bound to the id.
331  */
332 int rdma_set_reuseaddr(struct rdma_cm_id *id, int reuse);
333
334 /**
335  * rdma_set_afonly - Specify that listens are restricted to the
336  *    bound address family only.
337  * @id: Communication identifer to configure.
338  * @afonly: Value indicating if listens are restricted.
339  *
340  * Must be set before identifier is in the listening state.
341  */
342 int rdma_set_afonly(struct rdma_cm_id *id, int afonly);
343
344 int rdma_set_ack_timeout(struct rdma_cm_id *id, u8 timeout);
345
346 int rdma_set_min_rnr_timer(struct rdma_cm_id *id, u8 min_rnr_timer);
347  /**
348  * rdma_get_service_id - Return the IB service ID for a specified address.
349  * @id: Communication identifier associated with the address.
350  * @addr: Address for the service ID.
351  */
352 __be64 rdma_get_service_id(struct rdma_cm_id *id, struct sockaddr *addr);
353
354 /**
355  * rdma_reject_msg - return a pointer to a reject message string.
356  * @id: Communication identifier that received the REJECT event.
357  * @reason: Value returned in the REJECT event status field.
358  */
359 const char *__attribute_const__ rdma_reject_msg(struct rdma_cm_id *id,
360                                                 int reason);
361 /**
362  * rdma_consumer_reject_data - return the consumer reject private data and
363  *                             length, if any.
364  * @id: Communication identifier that received the REJECT event.
365  * @ev: RDMA CM reject event.
366  * @data_len: Pointer to the resulting length of the consumer data.
367  */
368 const void *rdma_consumer_reject_data(struct rdma_cm_id *id,
369                                       struct rdma_cm_event *ev, u8 *data_len);
370
371 /**
372  * rdma_read_gids - Return the SGID and DGID used for establishing
373  *                  connection. This can be used after rdma_resolve_addr()
374  *                  on client side. This can be use on new connection
375  *                  on server side. This is applicable to IB, RoCE, iWarp.
376  *                  If cm_id is not bound yet to the RDMA device, it doesn't
377  *                  copy and SGID or DGID to the given pointers.
378  * @id: Communication identifier whose GIDs are queried.
379  * @sgid: Pointer to SGID where SGID will be returned. It is optional.
380  * @dgid: Pointer to DGID where DGID will be returned. It is optional.
381  * Note: This API should not be used by any new ULPs or new code.
382  * Instead, users interested in querying GIDs should refer to path record
383  * of the rdma_cm_id to query the GIDs.
384  * This API is provided for compatibility for existing users.
385  */
386
387 void rdma_read_gids(struct rdma_cm_id *cm_id, union ib_gid *sgid,
388                     union ib_gid *dgid);
389
390 struct iw_cm_id *rdma_iw_cm_id(struct rdma_cm_id *cm_id);
391 struct rdma_cm_id *rdma_res_to_id(struct rdma_restrack_entry *res);
392
393 #endif /* RDMA_CM_H */