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 | * | |
5 | * This Software is licensed under one of the following licenses: | |
6 | * | |
7 | * 1) under the terms of the "Common Public License 1.0" a copy of which is | |
8 | * available from the Open Source Initiative, see | |
9 | * http://www.opensource.org/licenses/cpl.php. | |
10 | * | |
11 | * 2) under the terms of the "The BSD License" a copy of which is | |
12 | * available from the Open Source Initiative, see | |
13 | * http://www.opensource.org/licenses/bsd-license.php. | |
14 | * | |
15 | * 3) under the terms of the "GNU General Public License (GPL) Version 2" a | |
16 | * copy of which is available from the Open Source Initiative, see | |
17 | * http://www.opensource.org/licenses/gpl-license.php. | |
18 | * | |
19 | * Licensee has the right to choose one of the above licenses. | |
20 | * | |
21 | * Redistributions of source code must retain the above copyright | |
22 | * notice and one of the license notices. | |
23 | * | |
24 | * Redistributions in binary form must reproduce both the above copyright | |
25 | * notice, one of the license notices in the documentation | |
26 | * and/or other materials provided with the distribution. | |
27 | * | |
28 | */ | |
29 | ||
30 | #if !defined(RDMA_CM_H) | |
31 | #define RDMA_CM_H | |
32 | ||
33 | #include <linux/socket.h> | |
34 | #include <linux/in6.h> | |
35 | #include <rdma/ib_addr.h> | |
36 | #include <rdma/ib_sa.h> | |
37 | ||
38 | /* | |
39 | * Upon receiving a device removal event, users must destroy the associated | |
40 | * RDMA identifier and release all resources allocated with the device. | |
41 | */ | |
42 | enum rdma_cm_event_type { | |
43 | RDMA_CM_EVENT_ADDR_RESOLVED, | |
44 | RDMA_CM_EVENT_ADDR_ERROR, | |
45 | RDMA_CM_EVENT_ROUTE_RESOLVED, | |
46 | RDMA_CM_EVENT_ROUTE_ERROR, | |
47 | RDMA_CM_EVENT_CONNECT_REQUEST, | |
48 | RDMA_CM_EVENT_CONNECT_RESPONSE, | |
49 | RDMA_CM_EVENT_CONNECT_ERROR, | |
50 | RDMA_CM_EVENT_UNREACHABLE, | |
51 | RDMA_CM_EVENT_REJECTED, | |
52 | RDMA_CM_EVENT_ESTABLISHED, | |
53 | RDMA_CM_EVENT_DISCONNECTED, | |
54 | RDMA_CM_EVENT_DEVICE_REMOVAL, | |
c8f6a362 SH |
55 | RDMA_CM_EVENT_MULTICAST_JOIN, |
56 | RDMA_CM_EVENT_MULTICAST_ERROR | |
e51060f0 SH |
57 | }; |
58 | ||
59 | enum rdma_port_space { | |
60 | RDMA_PS_SDP = 0x0001, | |
c8f6a362 | 61 | RDMA_PS_IPOIB= 0x0002, |
e51060f0 SH |
62 | RDMA_PS_TCP = 0x0106, |
63 | RDMA_PS_UDP = 0x0111, | |
64 | RDMA_PS_SCTP = 0x0183 | |
65 | }; | |
66 | ||
67 | struct rdma_addr { | |
68 | struct sockaddr src_addr; | |
69 | u8 src_pad[sizeof(struct sockaddr_in6) - | |
70 | sizeof(struct sockaddr)]; | |
71 | struct sockaddr dst_addr; | |
72 | u8 dst_pad[sizeof(struct sockaddr_in6) - | |
73 | sizeof(struct sockaddr)]; | |
74 | struct rdma_dev_addr dev_addr; | |
75 | }; | |
76 | ||
77 | struct rdma_route { | |
78 | struct rdma_addr addr; | |
79 | struct ib_sa_path_rec *path_rec; | |
80 | int num_paths; | |
81 | }; | |
82 | ||
a1b1b61f SH |
83 | struct rdma_conn_param { |
84 | const void *private_data; | |
85 | u8 private_data_len; | |
86 | u8 responder_resources; | |
87 | u8 initiator_depth; | |
88 | u8 flow_control; | |
89 | u8 retry_count; /* ignored when accepting */ | |
90 | u8 rnr_retry_count; | |
91 | /* Fields below ignored if a QP is created on the rdma_cm_id. */ | |
92 | u8 srq; | |
93 | u32 qp_num; | |
94 | }; | |
95 | ||
628e5f6d SH |
96 | struct rdma_ud_param { |
97 | const void *private_data; | |
98 | u8 private_data_len; | |
99 | struct ib_ah_attr ah_attr; | |
100 | u32 qp_num; | |
101 | u32 qkey; | |
102 | }; | |
103 | ||
e51060f0 SH |
104 | struct rdma_cm_event { |
105 | enum rdma_cm_event_type event; | |
106 | int status; | |
a1b1b61f SH |
107 | union { |
108 | struct rdma_conn_param conn; | |
628e5f6d | 109 | struct rdma_ud_param ud; |
a1b1b61f | 110 | } param; |
e51060f0 SH |
111 | }; |
112 | ||
113 | struct rdma_cm_id; | |
114 | ||
115 | /** | |
116 | * rdma_cm_event_handler - Callback used to report user events. | |
117 | * | |
118 | * Notes: Users may not call rdma_destroy_id from this callback to destroy | |
119 | * the passed in id, or a corresponding listen id. Returning a | |
120 | * non-zero value from the callback will destroy the passed in id. | |
121 | */ | |
122 | typedef int (*rdma_cm_event_handler)(struct rdma_cm_id *id, | |
123 | struct rdma_cm_event *event); | |
124 | ||
125 | struct rdma_cm_id { | |
126 | struct ib_device *device; | |
127 | void *context; | |
128 | struct ib_qp *qp; | |
129 | rdma_cm_event_handler event_handler; | |
130 | struct rdma_route route; | |
131 | enum rdma_port_space ps; | |
132 | u8 port_num; | |
133 | }; | |
134 | ||
135 | /** | |
136 | * rdma_create_id - Create an RDMA identifier. | |
137 | * | |
138 | * @event_handler: User callback invoked to report events associated with the | |
139 | * returned rdma_id. | |
140 | * @context: User specified context associated with the id. | |
141 | * @ps: RDMA port space. | |
142 | */ | |
143 | struct rdma_cm_id *rdma_create_id(rdma_cm_event_handler event_handler, | |
144 | void *context, enum rdma_port_space ps); | |
145 | ||
07eeec06 OG |
146 | /** |
147 | * rdma_destroy_id - Destroys an RDMA identifier. | |
148 | * | |
149 | * @id: RDMA identifier. | |
150 | * | |
151 | * Note: calling this function has the effect of canceling in-flight | |
152 | * asynchronous operations associated with the id. | |
153 | */ | |
e51060f0 SH |
154 | void rdma_destroy_id(struct rdma_cm_id *id); |
155 | ||
156 | /** | |
157 | * rdma_bind_addr - Bind an RDMA identifier to a source address and | |
158 | * associated RDMA device, if needed. | |
159 | * | |
160 | * @id: RDMA identifier. | |
161 | * @addr: Local address information. Wildcard values are permitted. | |
162 | * | |
163 | * This associates a source address with the RDMA identifier before calling | |
164 | * rdma_listen. If a specific local address is given, the RDMA identifier will | |
165 | * be bound to a local RDMA device. | |
166 | */ | |
167 | int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr); | |
168 | ||
169 | /** | |
170 | * rdma_resolve_addr - Resolve destination and optional source addresses | |
171 | * from IP addresses to an RDMA address. If successful, the specified | |
172 | * rdma_cm_id will be bound to a local device. | |
173 | * | |
174 | * @id: RDMA identifier. | |
175 | * @src_addr: Source address information. This parameter may be NULL. | |
176 | * @dst_addr: Destination address information. | |
177 | * @timeout_ms: Time to wait for resolution to complete. | |
178 | */ | |
179 | int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr, | |
180 | struct sockaddr *dst_addr, int timeout_ms); | |
181 | ||
182 | /** | |
183 | * rdma_resolve_route - Resolve the RDMA address bound to the RDMA identifier | |
184 | * into route information needed to establish a connection. | |
185 | * | |
186 | * This is called on the client side of a connection. | |
187 | * Users must have first called rdma_resolve_addr to resolve a dst_addr | |
188 | * into an RDMA address before calling this routine. | |
189 | */ | |
190 | int rdma_resolve_route(struct rdma_cm_id *id, int timeout_ms); | |
191 | ||
192 | /** | |
193 | * rdma_create_qp - Allocate a QP and associate it with the specified RDMA | |
194 | * identifier. | |
195 | * | |
196 | * QPs allocated to an rdma_cm_id will automatically be transitioned by the CMA | |
197 | * through their states. | |
198 | */ | |
199 | int rdma_create_qp(struct rdma_cm_id *id, struct ib_pd *pd, | |
200 | struct ib_qp_init_attr *qp_init_attr); | |
201 | ||
202 | /** | |
203 | * rdma_destroy_qp - Deallocate the QP associated with the specified RDMA | |
204 | * identifier. | |
205 | * | |
206 | * Users must destroy any QP associated with an RDMA identifier before | |
207 | * destroying the RDMA ID. | |
208 | */ | |
209 | void rdma_destroy_qp(struct rdma_cm_id *id); | |
210 | ||
211 | /** | |
212 | * rdma_init_qp_attr - Initializes the QP attributes for use in transitioning | |
213 | * to a specified QP state. | |
214 | * @id: Communication identifier associated with the QP attributes to | |
215 | * initialize. | |
216 | * @qp_attr: On input, specifies the desired QP state. On output, the | |
217 | * mandatory and desired optional attributes will be set in order to | |
218 | * modify the QP to the specified state. | |
219 | * @qp_attr_mask: The QP attribute mask that may be used to transition the | |
220 | * QP to the specified state. | |
221 | * | |
222 | * Users must set the @qp_attr->qp_state to the desired QP state. This call | |
223 | * will set all required attributes for the given transition, along with | |
224 | * known optional attributes. Users may override the attributes returned from | |
225 | * this call before calling ib_modify_qp. | |
226 | * | |
227 | * Users that wish to have their QP automatically transitioned through its | |
228 | * states can associate a QP with the rdma_cm_id by calling rdma_create_qp(). | |
229 | */ | |
230 | int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr, | |
231 | int *qp_attr_mask); | |
232 | ||
e51060f0 SH |
233 | /** |
234 | * rdma_connect - Initiate an active connection request. | |
628e5f6d SH |
235 | * @id: Connection identifier to connect. |
236 | * @conn_param: Connection information used for connected QPs. | |
e51060f0 SH |
237 | * |
238 | * Users must have resolved a route for the rdma_cm_id to connect with | |
239 | * by having called rdma_resolve_route before calling this routine. | |
628e5f6d SH |
240 | * |
241 | * This call will either connect to a remote QP or obtain remote QP | |
242 | * information for unconnected rdma_cm_id's. The actual operation is | |
243 | * based on the rdma_cm_id's port space. | |
e51060f0 SH |
244 | */ |
245 | int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param); | |
246 | ||
247 | /** | |
248 | * rdma_listen - This function is called by the passive side to | |
249 | * listen for incoming connection requests. | |
250 | * | |
251 | * Users must have bound the rdma_cm_id to a local address by calling | |
252 | * rdma_bind_addr before calling this routine. | |
253 | */ | |
254 | int rdma_listen(struct rdma_cm_id *id, int backlog); | |
255 | ||
256 | /** | |
257 | * rdma_accept - Called to accept a connection request or response. | |
258 | * @id: Connection identifier associated with the request. | |
259 | * @conn_param: Information needed to establish the connection. This must be | |
260 | * provided if accepting a connection request. If accepting a connection | |
261 | * response, this parameter must be NULL. | |
262 | * | |
263 | * Typically, this routine is only called by the listener to accept a connection | |
264 | * request. It must also be called on the active side of a connection if the | |
265 | * user is performing their own QP transitions. | |
951f7fc1 OG |
266 | * |
267 | * In the case of error, a reject message is sent to the remote side and the | |
268 | * state of the qp associated with the id is modified to error, such that any | |
269 | * previously posted receive buffers would be flushed. | |
e51060f0 SH |
270 | */ |
271 | int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param); | |
272 | ||
0fe313b0 SH |
273 | /** |
274 | * rdma_notify - Notifies the RDMA CM of an asynchronous event that has | |
275 | * occurred on the connection. | |
276 | * @id: Connection identifier to transition to established. | |
277 | * @event: Asynchronous event. | |
278 | * | |
279 | * This routine should be invoked by users to notify the CM of relevant | |
280 | * communication events. Events that should be reported to the CM and | |
281 | * when to report them are: | |
282 | * | |
283 | * IB_EVENT_COMM_EST - Used when a message is received on a connected | |
284 | * QP before an RTU has been received. | |
285 | */ | |
286 | int rdma_notify(struct rdma_cm_id *id, enum ib_event_type event); | |
287 | ||
e51060f0 SH |
288 | /** |
289 | * rdma_reject - Called to reject a connection request or response. | |
290 | */ | |
291 | int rdma_reject(struct rdma_cm_id *id, const void *private_data, | |
292 | u8 private_data_len); | |
293 | ||
294 | /** | |
295 | * rdma_disconnect - This function disconnects the associated QP and | |
296 | * transitions it into the error state. | |
297 | */ | |
298 | int rdma_disconnect(struct rdma_cm_id *id); | |
299 | ||
c8f6a362 SH |
300 | /** |
301 | * rdma_join_multicast - Join the multicast group specified by the given | |
302 | * address. | |
303 | * @id: Communication identifier associated with the request. | |
304 | * @addr: Multicast address identifying the group to join. | |
305 | * @context: User-defined context associated with the join request, returned | |
306 | * to the user through the private_data pointer in multicast events. | |
307 | */ | |
308 | int rdma_join_multicast(struct rdma_cm_id *id, struct sockaddr *addr, | |
309 | void *context); | |
e51060f0 | 310 | |
c8f6a362 SH |
311 | /** |
312 | * rdma_leave_multicast - Leave the multicast group specified by the given | |
313 | * address. | |
314 | */ | |
315 | void rdma_leave_multicast(struct rdma_cm_id *id, struct sockaddr *addr); | |
316 | ||
317 | #endif /* RDMA_CM_H */ |