Commit | Line | Data |
---|---|---|
e51060f0 SH |
1 | /* |
2 | * Copyright (c) 2005 Voltaire Inc. All rights reserved. | |
3 | * Copyright (c) 2005 Intel Corporation. All rights reserved. | |
4 | * | |
a9474917 SH |
5 | * This software is available to you under a choice of one of two |
6 | * licenses. You may choose to be licensed under the terms of the GNU | |
7 | * General Public License (GPL) Version 2, available from the file | |
8 | * COPYING in the main directory of this source tree, or the | |
9 | * OpenIB.org BSD license below: | |
10 | * | |
11 | * Redistribution and use in source and binary forms, with or | |
12 | * without modification, are permitted provided that the following | |
13 | * conditions are met: | |
14 | * | |
15 | * - Redistributions of source code must retain the above | |
16 | * copyright notice, this list of conditions and the following | |
17 | * disclaimer. | |
18 | * | |
19 | * - Redistributions in binary form must reproduce the above | |
20 | * copyright notice, this list of conditions and the following | |
21 | * disclaimer in the documentation and/or other materials | |
22 | * provided with the distribution. | |
23 | * | |
24 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
25 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
26 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
27 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | |
28 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |
29 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
30 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
31 | * SOFTWARE. | |
e51060f0 SH |
32 | */ |
33 | ||
34 | #if !defined(RDMA_CM_H) | |
35 | #define RDMA_CM_H | |
36 | ||
37 | #include <linux/socket.h> | |
38 | #include <linux/in6.h> | |
39 | #include <rdma/ib_addr.h> | |
40 | #include <rdma/ib_sa.h> | |
41 | ||
42 | /* | |
43 | * Upon receiving a device removal event, users must destroy the associated | |
44 | * RDMA identifier and release all resources allocated with the device. | |
45 | */ | |
46 | enum rdma_cm_event_type { | |
47 | RDMA_CM_EVENT_ADDR_RESOLVED, | |
48 | RDMA_CM_EVENT_ADDR_ERROR, | |
49 | RDMA_CM_EVENT_ROUTE_RESOLVED, | |
50 | RDMA_CM_EVENT_ROUTE_ERROR, | |
51 | RDMA_CM_EVENT_CONNECT_REQUEST, | |
52 | RDMA_CM_EVENT_CONNECT_RESPONSE, | |
53 | RDMA_CM_EVENT_CONNECT_ERROR, | |
54 | RDMA_CM_EVENT_UNREACHABLE, | |
55 | RDMA_CM_EVENT_REJECTED, | |
56 | RDMA_CM_EVENT_ESTABLISHED, | |
57 | RDMA_CM_EVENT_DISCONNECTED, | |
58 | RDMA_CM_EVENT_DEVICE_REMOVAL, | |
c8f6a362 | 59 | RDMA_CM_EVENT_MULTICAST_JOIN, |
dd5bdff8 | 60 | RDMA_CM_EVENT_MULTICAST_ERROR, |
38ca83a5 AV |
61 | RDMA_CM_EVENT_ADDR_CHANGE, |
62 | RDMA_CM_EVENT_TIMEWAIT_EXIT | |
e51060f0 SH |
63 | }; |
64 | ||
db7489e0 | 65 | const char *__attribute_const__ rdma_event_msg(enum rdma_cm_event_type event); |
2b1b5b60 | 66 | |
e51060f0 | 67 | enum rdma_port_space { |
4deccd6d DB |
68 | RDMA_PS_SDP = 0x0001, |
69 | RDMA_PS_IPOIB = 0x0002, | |
2d2e9415 | 70 | RDMA_PS_IB = 0x013F, |
4deccd6d DB |
71 | RDMA_PS_TCP = 0x0106, |
72 | RDMA_PS_UDP = 0x0111, | |
e51060f0 SH |
73 | }; |
74 | ||
58afdcb7 SH |
75 | #define RDMA_IB_IP_PS_MASK 0xFFFFFFFFFFFF0000ULL |
76 | #define RDMA_IB_IP_PS_TCP 0x0000000001060000ULL | |
77 | #define RDMA_IB_IP_PS_UDP 0x0000000001110000ULL | |
78 | #define RDMA_IB_IP_PS_IB 0x00000000013F0000ULL | |
79 | ||
e51060f0 | 80 | struct rdma_addr { |
3f446754 RD |
81 | struct sockaddr_storage src_addr; |
82 | struct sockaddr_storage dst_addr; | |
e51060f0 SH |
83 | struct rdma_dev_addr dev_addr; |
84 | }; | |
85 | ||
86 | struct rdma_route { | |
87 | struct rdma_addr addr; | |
88 | struct ib_sa_path_rec *path_rec; | |
89 | int num_paths; | |
90 | }; | |
91 | ||
a1b1b61f SH |
92 | struct rdma_conn_param { |
93 | const void *private_data; | |
94 | u8 private_data_len; | |
95 | u8 responder_resources; | |
96 | u8 initiator_depth; | |
97 | u8 flow_control; | |
98 | u8 retry_count; /* ignored when accepting */ | |
99 | u8 rnr_retry_count; | |
100 | /* Fields below ignored if a QP is created on the rdma_cm_id. */ | |
101 | u8 srq; | |
102 | u32 qp_num; | |
5c438135 | 103 | u32 qkey; |
a1b1b61f SH |
104 | }; |
105 | ||
628e5f6d SH |
106 | struct rdma_ud_param { |
107 | const void *private_data; | |
108 | u8 private_data_len; | |
109 | struct ib_ah_attr ah_attr; | |
110 | u32 qp_num; | |
111 | u32 qkey; | |
112 | }; | |
113 | ||
e51060f0 SH |
114 | struct rdma_cm_event { |
115 | enum rdma_cm_event_type event; | |
116 | int status; | |
a1b1b61f SH |
117 | union { |
118 | struct rdma_conn_param conn; | |
628e5f6d | 119 | struct rdma_ud_param ud; |
a1b1b61f | 120 | } param; |
e51060f0 SH |
121 | }; |
122 | ||
550e5ca7 NM |
123 | enum rdma_cm_state { |
124 | RDMA_CM_IDLE, | |
125 | RDMA_CM_ADDR_QUERY, | |
126 | RDMA_CM_ADDR_RESOLVED, | |
127 | RDMA_CM_ROUTE_QUERY, | |
128 | RDMA_CM_ROUTE_RESOLVED, | |
129 | RDMA_CM_CONNECT, | |
130 | RDMA_CM_DISCONNECT, | |
131 | RDMA_CM_ADDR_BOUND, | |
132 | RDMA_CM_LISTEN, | |
133 | RDMA_CM_DEVICE_REMOVAL, | |
134 | RDMA_CM_DESTROYING | |
135 | }; | |
136 | ||
e51060f0 SH |
137 | struct rdma_cm_id; |
138 | ||
139 | /** | |
140 | * rdma_cm_event_handler - Callback used to report user events. | |
141 | * | |
142 | * Notes: Users may not call rdma_destroy_id from this callback to destroy | |
143 | * the passed in id, or a corresponding listen id. Returning a | |
144 | * non-zero value from the callback will destroy the passed in id. | |
145 | */ | |
146 | typedef int (*rdma_cm_event_handler)(struct rdma_cm_id *id, | |
147 | struct rdma_cm_event *event); | |
148 | ||
149 | struct rdma_cm_id { | |
150 | struct ib_device *device; | |
151 | void *context; | |
152 | struct ib_qp *qp; | |
153 | rdma_cm_event_handler event_handler; | |
154 | struct rdma_route route; | |
155 | enum rdma_port_space ps; | |
b26f9b99 | 156 | enum ib_qp_type qp_type; |
e51060f0 SH |
157 | u8 port_num; |
158 | }; | |
159 | ||
160 | /** | |
161 | * rdma_create_id - Create an RDMA identifier. | |
162 | * | |
fa20105e | 163 | * @net: The network namespace in which to create the new id. |
e51060f0 SH |
164 | * @event_handler: User callback invoked to report events associated with the |
165 | * returned rdma_id. | |
166 | * @context: User specified context associated with the id. | |
167 | * @ps: RDMA port space. | |
b26f9b99 | 168 | * @qp_type: type of queue pair associated with the id. |
fa20105e GS |
169 | * |
170 | * The id holds a reference on the network namespace until it is destroyed. | |
e51060f0 | 171 | */ |
fa20105e GS |
172 | struct rdma_cm_id *rdma_create_id(struct net *net, |
173 | rdma_cm_event_handler event_handler, | |
b26f9b99 SH |
174 | void *context, enum rdma_port_space ps, |
175 | enum ib_qp_type qp_type); | |
e51060f0 | 176 | |
07eeec06 OG |
177 | /** |
178 | * rdma_destroy_id - Destroys an RDMA identifier. | |
179 | * | |
180 | * @id: RDMA identifier. | |
181 | * | |
182 | * Note: calling this function has the effect of canceling in-flight | |
183 | * asynchronous operations associated with the id. | |
184 | */ | |
e51060f0 SH |
185 | void rdma_destroy_id(struct rdma_cm_id *id); |
186 | ||
187 | /** | |
188 | * rdma_bind_addr - Bind an RDMA identifier to a source address and | |
189 | * associated RDMA device, if needed. | |
190 | * | |
191 | * @id: RDMA identifier. | |
192 | * @addr: Local address information. Wildcard values are permitted. | |
193 | * | |
194 | * This associates a source address with the RDMA identifier before calling | |
195 | * rdma_listen. If a specific local address is given, the RDMA identifier will | |
196 | * be bound to a local RDMA device. | |
197 | */ | |
198 | int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr); | |
199 | ||
200 | /** | |
201 | * rdma_resolve_addr - Resolve destination and optional source addresses | |
202 | * from IP addresses to an RDMA address. If successful, the specified | |
203 | * rdma_cm_id will be bound to a local device. | |
204 | * | |
205 | * @id: RDMA identifier. | |
206 | * @src_addr: Source address information. This parameter may be NULL. | |
207 | * @dst_addr: Destination address information. | |
208 | * @timeout_ms: Time to wait for resolution to complete. | |
209 | */ | |
210 | int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr, | |
211 | struct sockaddr *dst_addr, int timeout_ms); | |
212 | ||
213 | /** | |
214 | * rdma_resolve_route - Resolve the RDMA address bound to the RDMA identifier | |
215 | * into route information needed to establish a connection. | |
216 | * | |
217 | * This is called on the client side of a connection. | |
218 | * Users must have first called rdma_resolve_addr to resolve a dst_addr | |
219 | * into an RDMA address before calling this routine. | |
220 | */ | |
221 | int rdma_resolve_route(struct rdma_cm_id *id, int timeout_ms); | |
222 | ||
223 | /** | |
224 | * rdma_create_qp - Allocate a QP and associate it with the specified RDMA | |
225 | * identifier. | |
226 | * | |
227 | * QPs allocated to an rdma_cm_id will automatically be transitioned by the CMA | |
228 | * through their states. | |
229 | */ | |
230 | int rdma_create_qp(struct rdma_cm_id *id, struct ib_pd *pd, | |
231 | struct ib_qp_init_attr *qp_init_attr); | |
232 | ||
233 | /** | |
234 | * rdma_destroy_qp - Deallocate the QP associated with the specified RDMA | |
235 | * identifier. | |
236 | * | |
237 | * Users must destroy any QP associated with an RDMA identifier before | |
238 | * destroying the RDMA ID. | |
239 | */ | |
240 | void rdma_destroy_qp(struct rdma_cm_id *id); | |
241 | ||
242 | /** | |
243 | * rdma_init_qp_attr - Initializes the QP attributes for use in transitioning | |
244 | * to a specified QP state. | |
245 | * @id: Communication identifier associated with the QP attributes to | |
246 | * initialize. | |
247 | * @qp_attr: On input, specifies the desired QP state. On output, the | |
248 | * mandatory and desired optional attributes will be set in order to | |
249 | * modify the QP to the specified state. | |
250 | * @qp_attr_mask: The QP attribute mask that may be used to transition the | |
251 | * QP to the specified state. | |
252 | * | |
253 | * Users must set the @qp_attr->qp_state to the desired QP state. This call | |
254 | * will set all required attributes for the given transition, along with | |
255 | * known optional attributes. Users may override the attributes returned from | |
256 | * this call before calling ib_modify_qp. | |
257 | * | |
258 | * Users that wish to have their QP automatically transitioned through its | |
259 | * states can associate a QP with the rdma_cm_id by calling rdma_create_qp(). | |
260 | */ | |
261 | int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr, | |
262 | int *qp_attr_mask); | |
263 | ||
e51060f0 SH |
264 | /** |
265 | * rdma_connect - Initiate an active connection request. | |
628e5f6d SH |
266 | * @id: Connection identifier to connect. |
267 | * @conn_param: Connection information used for connected QPs. | |
e51060f0 SH |
268 | * |
269 | * Users must have resolved a route for the rdma_cm_id to connect with | |
270 | * by having called rdma_resolve_route before calling this routine. | |
628e5f6d SH |
271 | * |
272 | * This call will either connect to a remote QP or obtain remote QP | |
273 | * information for unconnected rdma_cm_id's. The actual operation is | |
274 | * based on the rdma_cm_id's port space. | |
e51060f0 SH |
275 | */ |
276 | int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param); | |
277 | ||
278 | /** | |
279 | * rdma_listen - This function is called by the passive side to | |
280 | * listen for incoming connection requests. | |
281 | * | |
282 | * Users must have bound the rdma_cm_id to a local address by calling | |
283 | * rdma_bind_addr before calling this routine. | |
284 | */ | |
285 | int rdma_listen(struct rdma_cm_id *id, int backlog); | |
286 | ||
287 | /** | |
288 | * rdma_accept - Called to accept a connection request or response. | |
289 | * @id: Connection identifier associated with the request. | |
290 | * @conn_param: Information needed to establish the connection. This must be | |
291 | * provided if accepting a connection request. If accepting a connection | |
292 | * response, this parameter must be NULL. | |
293 | * | |
294 | * Typically, this routine is only called by the listener to accept a connection | |
295 | * request. It must also be called on the active side of a connection if the | |
296 | * user is performing their own QP transitions. | |
951f7fc1 OG |
297 | * |
298 | * In the case of error, a reject message is sent to the remote side and the | |
299 | * state of the qp associated with the id is modified to error, such that any | |
300 | * previously posted receive buffers would be flushed. | |
e51060f0 SH |
301 | */ |
302 | int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param); | |
303 | ||
0fe313b0 SH |
304 | /** |
305 | * rdma_notify - Notifies the RDMA CM of an asynchronous event that has | |
306 | * occurred on the connection. | |
307 | * @id: Connection identifier to transition to established. | |
308 | * @event: Asynchronous event. | |
309 | * | |
310 | * This routine should be invoked by users to notify the CM of relevant | |
311 | * communication events. Events that should be reported to the CM and | |
312 | * when to report them are: | |
313 | * | |
314 | * IB_EVENT_COMM_EST - Used when a message is received on a connected | |
315 | * QP before an RTU has been received. | |
316 | */ | |
317 | int rdma_notify(struct rdma_cm_id *id, enum ib_event_type event); | |
318 | ||
e51060f0 SH |
319 | /** |
320 | * rdma_reject - Called to reject a connection request or response. | |
321 | */ | |
322 | int rdma_reject(struct rdma_cm_id *id, const void *private_data, | |
323 | u8 private_data_len); | |
324 | ||
325 | /** | |
326 | * rdma_disconnect - This function disconnects the associated QP and | |
327 | * transitions it into the error state. | |
328 | */ | |
329 | int rdma_disconnect(struct rdma_cm_id *id); | |
330 | ||
c8f6a362 SH |
331 | /** |
332 | * rdma_join_multicast - Join the multicast group specified by the given | |
333 | * address. | |
334 | * @id: Communication identifier associated with the request. | |
335 | * @addr: Multicast address identifying the group to join. | |
336 | * @context: User-defined context associated with the join request, returned | |
337 | * to the user through the private_data pointer in multicast events. | |
338 | */ | |
339 | int rdma_join_multicast(struct rdma_cm_id *id, struct sockaddr *addr, | |
340 | void *context); | |
e51060f0 | 341 | |
c8f6a362 SH |
342 | /** |
343 | * rdma_leave_multicast - Leave the multicast group specified by the given | |
344 | * address. | |
345 | */ | |
346 | void rdma_leave_multicast(struct rdma_cm_id *id, struct sockaddr *addr); | |
347 | ||
a81c994d SH |
348 | /** |
349 | * rdma_set_service_type - Set the type of service associated with a | |
350 | * connection identifier. | |
351 | * @id: Communication identifier to associated with service type. | |
352 | * @tos: Type of service. | |
353 | * | |
354 | * The type of service is interpretted as a differentiated service | |
355 | * field (RFC 2474). The service type should be specified before | |
356 | * performing route resolution, as existing communication on the | |
357 | * connection identifier may be unaffected. The type of service | |
358 | * requested may not be supported by the network to all destinations. | |
359 | */ | |
360 | void rdma_set_service_type(struct rdma_cm_id *id, int tos); | |
361 | ||
a9bb7912 HS |
362 | /** |
363 | * rdma_set_reuseaddr - Allow the reuse of local addresses when binding | |
364 | * the rdma_cm_id. | |
365 | * @id: Communication identifier to configure. | |
366 | * @reuse: Value indicating if the bound address is reusable. | |
367 | * | |
368 | * Reuse must be set before an address is bound to the id. | |
369 | */ | |
370 | int rdma_set_reuseaddr(struct rdma_cm_id *id, int reuse); | |
371 | ||
68602120 SH |
372 | /** |
373 | * rdma_set_afonly - Specify that listens are restricted to the | |
374 | * bound address family only. | |
375 | * @id: Communication identifer to configure. | |
376 | * @afonly: Value indicating if listens are restricted. | |
377 | * | |
378 | * Must be set before identifier is in the listening state. | |
379 | */ | |
380 | int rdma_set_afonly(struct rdma_cm_id *id, int afonly); | |
381 | ||
cf53936f SH |
382 | /** |
383 | * rdma_get_service_id - Return the IB service ID for a specified address. | |
384 | * @id: Communication identifier associated with the address. | |
385 | * @addr: Address for the service ID. | |
386 | */ | |
387 | __be64 rdma_get_service_id(struct rdma_cm_id *id, struct sockaddr *addr); | |
388 | ||
c8f6a362 | 389 | #endif /* RDMA_CM_H */ |