Commit | Line | Data |
---|---|---|
6bf9d8f6 | 1 | /* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */ |
e51060f0 SH |
2 | /* |
3 | * Copyright (c) 2005 Voltaire Inc. All rights reserved. | |
4 | * Copyright (c) 2005 Intel Corporation. All rights reserved. | |
e51060f0 SH |
5 | */ |
6 | ||
6bf9d8f6 | 7 | #ifndef RDMA_CM_H |
e51060f0 SH |
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> | |
2253fc0c | 14 | #include <uapi/rdma/rdma_user_cm.h> |
e51060f0 SH |
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, | |
c8f6a362 | 33 | RDMA_CM_EVENT_MULTICAST_JOIN, |
dd5bdff8 | 34 | RDMA_CM_EVENT_MULTICAST_ERROR, |
38ca83a5 AV |
35 | RDMA_CM_EVENT_ADDR_CHANGE, |
36 | RDMA_CM_EVENT_TIMEWAIT_EXIT | |
e51060f0 SH |
37 | }; |
38 | ||
db7489e0 | 39 | const char *__attribute_const__ rdma_event_msg(enum rdma_cm_event_type event); |
2b1b5b60 | 40 | |
58afdcb7 SH |
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 | ||
e51060f0 | 46 | struct rdma_addr { |
3f446754 RD |
47 | struct sockaddr_storage src_addr; |
48 | struct sockaddr_storage dst_addr; | |
e51060f0 SH |
49 | struct rdma_dev_addr dev_addr; |
50 | }; | |
51 | ||
52 | struct rdma_route { | |
53 | struct rdma_addr addr; | |
c2f8fc4e | 54 | struct sa_path_rec *path_rec; |
5a374949 MZ |
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 | ||
bf9a9928 MZ |
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; | |
e51060f0 SH |
66 | }; |
67 | ||
a1b1b61f SH |
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; | |
5c438135 | 79 | u32 qkey; |
a1b1b61f SH |
80 | }; |
81 | ||
628e5f6d SH |
82 | struct rdma_ud_param { |
83 | const void *private_data; | |
84 | u8 private_data_len; | |
90898850 | 85 | struct rdma_ah_attr ah_attr; |
628e5f6d SH |
86 | u32 qp_num; |
87 | u32 qkey; | |
88 | }; | |
89 | ||
e51060f0 SH |
90 | struct rdma_cm_event { |
91 | enum rdma_cm_event_type event; | |
92 | int status; | |
a1b1b61f SH |
93 | union { |
94 | struct rdma_conn_param conn; | |
628e5f6d | 95 | struct rdma_ud_param ud; |
a1b1b61f | 96 | } param; |
93531ee7 | 97 | struct rdma_ucm_ece ece; |
e51060f0 SH |
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; | |
2253fc0c | 118 | enum rdma_ucm_port_space ps; |
b26f9b99 | 119 | enum ib_qp_type qp_type; |
1fb7f897 | 120 | u32 port_num; |
925d046e | 121 | struct work_struct net_work; |
e51060f0 SH |
122 | }; |
123 | ||
b09c4d70 LR |
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); | |
00313983 | 132 | |
e51060f0 SH |
133 | /** |
134 | * rdma_create_id - Create an RDMA identifier. | |
135 | * | |
fa20105e | 136 | * @net: The network namespace in which to create the new id. |
e51060f0 SH |
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. | |
b26f9b99 | 141 | * @qp_type: type of queue pair associated with the id. |
fa20105e | 142 | * |
42690246 CL |
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. | |
e51060f0 | 148 | */ |
b09c4d70 LR |
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) | |
e51060f0 | 152 | |
07eeec06 OG |
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 | */ | |
e51060f0 SH |
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, | |
dbace111 LR |
187 | const struct sockaddr *dst_addr, |
188 | unsigned long timeout_ms); | |
e51060f0 SH |
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 | */ | |
dbace111 | 198 | int rdma_resolve_route(struct rdma_cm_id *id, unsigned long timeout_ms); |
e51060f0 SH |
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 | ||
e51060f0 | 241 | int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param); |
071ba4cc JG |
242 | int rdma_connect_locked(struct rdma_cm_id *id, |
243 | struct rdma_conn_param *conn_param); | |
e51060f0 | 244 | |
34e2ab57 LR |
245 | int rdma_connect_ece(struct rdma_cm_id *id, struct rdma_conn_param *conn_param, |
246 | struct rdma_ucm_ece *ece); | |
247 | ||
e51060f0 SH |
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 | ||
b09c4d70 | 257 | int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param); |
00313983 | 258 | |
d114c6fe JG |
259 | void rdma_lock_handler(struct rdma_cm_id *id); |
260 | void rdma_unlock_handler(struct rdma_cm_id *id); | |
b09c4d70 LR |
261 | int rdma_accept_ece(struct rdma_cm_id *id, struct rdma_conn_param *conn_param, |
262 | struct rdma_ucm_ece *ece); | |
e51060f0 | 263 | |
0fe313b0 SH |
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 | ||
e51060f0 SH |
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, | |
8094ba0a | 283 | u8 private_data_len, u8 reason); |
e51060f0 SH |
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 | ||
c8f6a362 SH |
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. | |
ab15c95a AV |
296 | * @join_state: Multicast JoinState bitmap requested by port. |
297 | * Bitmap is based on IB_SA_MCMEMBER_REC_JOIN_STATE bits. | |
c8f6a362 SH |
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, | |
ab15c95a | 302 | u8 join_state, void *context); |
e51060f0 | 303 | |
c8f6a362 SH |
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 | ||
a81c994d SH |
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 | ||
a9bb7912 HS |
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 | ||
68602120 SH |
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 | ||
2c1619ed | 344 | int rdma_set_ack_timeout(struct rdma_cm_id *id, u8 timeout); |
3aeffc46 HB |
345 | |
346 | int rdma_set_min_rnr_timer(struct rdma_cm_id *id, u8 min_rnr_timer); | |
cf53936f SH |
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 | ||
77a5db13 SW |
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); | |
5f244104 SW |
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 | ||
411460ac PP |
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 | ||
fbdb0a91 SW |
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 | ||
c8f6a362 | 393 | #endif /* RDMA_CM_H */ |