]>
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, | |
55 | }; | |
56 | ||
57 | enum rdma_port_space { | |
58 | RDMA_PS_SDP = 0x0001, | |
59 | RDMA_PS_TCP = 0x0106, | |
60 | RDMA_PS_UDP = 0x0111, | |
61 | RDMA_PS_SCTP = 0x0183 | |
62 | }; | |
63 | ||
64 | struct rdma_addr { | |
65 | struct sockaddr src_addr; | |
66 | u8 src_pad[sizeof(struct sockaddr_in6) - | |
67 | sizeof(struct sockaddr)]; | |
68 | struct sockaddr dst_addr; | |
69 | u8 dst_pad[sizeof(struct sockaddr_in6) - | |
70 | sizeof(struct sockaddr)]; | |
71 | struct rdma_dev_addr dev_addr; | |
72 | }; | |
73 | ||
74 | struct rdma_route { | |
75 | struct rdma_addr addr; | |
76 | struct ib_sa_path_rec *path_rec; | |
77 | int num_paths; | |
78 | }; | |
79 | ||
a1b1b61f SH |
80 | struct rdma_conn_param { |
81 | const void *private_data; | |
82 | u8 private_data_len; | |
83 | u8 responder_resources; | |
84 | u8 initiator_depth; | |
85 | u8 flow_control; | |
86 | u8 retry_count; /* ignored when accepting */ | |
87 | u8 rnr_retry_count; | |
88 | /* Fields below ignored if a QP is created on the rdma_cm_id. */ | |
89 | u8 srq; | |
90 | u32 qp_num; | |
91 | }; | |
92 | ||
628e5f6d SH |
93 | struct rdma_ud_param { |
94 | const void *private_data; | |
95 | u8 private_data_len; | |
96 | struct ib_ah_attr ah_attr; | |
97 | u32 qp_num; | |
98 | u32 qkey; | |
99 | }; | |
100 | ||
e51060f0 SH |
101 | struct rdma_cm_event { |
102 | enum rdma_cm_event_type event; | |
103 | int status; | |
a1b1b61f SH |
104 | union { |
105 | struct rdma_conn_param conn; | |
628e5f6d | 106 | struct rdma_ud_param ud; |
a1b1b61f | 107 | } param; |
e51060f0 SH |
108 | }; |
109 | ||
110 | struct rdma_cm_id; | |
111 | ||
112 | /** | |
113 | * rdma_cm_event_handler - Callback used to report user events. | |
114 | * | |
115 | * Notes: Users may not call rdma_destroy_id from this callback to destroy | |
116 | * the passed in id, or a corresponding listen id. Returning a | |
117 | * non-zero value from the callback will destroy the passed in id. | |
118 | */ | |
119 | typedef int (*rdma_cm_event_handler)(struct rdma_cm_id *id, | |
120 | struct rdma_cm_event *event); | |
121 | ||
122 | struct rdma_cm_id { | |
123 | struct ib_device *device; | |
124 | void *context; | |
125 | struct ib_qp *qp; | |
126 | rdma_cm_event_handler event_handler; | |
127 | struct rdma_route route; | |
128 | enum rdma_port_space ps; | |
129 | u8 port_num; | |
130 | }; | |
131 | ||
132 | /** | |
133 | * rdma_create_id - Create an RDMA identifier. | |
134 | * | |
135 | * @event_handler: User callback invoked to report events associated with the | |
136 | * returned rdma_id. | |
137 | * @context: User specified context associated with the id. | |
138 | * @ps: RDMA port space. | |
139 | */ | |
140 | struct rdma_cm_id *rdma_create_id(rdma_cm_event_handler event_handler, | |
141 | void *context, enum rdma_port_space ps); | |
142 | ||
07eeec06 OG |
143 | /** |
144 | * rdma_destroy_id - Destroys an RDMA identifier. | |
145 | * | |
146 | * @id: RDMA identifier. | |
147 | * | |
148 | * Note: calling this function has the effect of canceling in-flight | |
149 | * asynchronous operations associated with the id. | |
150 | */ | |
e51060f0 SH |
151 | void rdma_destroy_id(struct rdma_cm_id *id); |
152 | ||
153 | /** | |
154 | * rdma_bind_addr - Bind an RDMA identifier to a source address and | |
155 | * associated RDMA device, if needed. | |
156 | * | |
157 | * @id: RDMA identifier. | |
158 | * @addr: Local address information. Wildcard values are permitted. | |
159 | * | |
160 | * This associates a source address with the RDMA identifier before calling | |
161 | * rdma_listen. If a specific local address is given, the RDMA identifier will | |
162 | * be bound to a local RDMA device. | |
163 | */ | |
164 | int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr); | |
165 | ||
166 | /** | |
167 | * rdma_resolve_addr - Resolve destination and optional source addresses | |
168 | * from IP addresses to an RDMA address. If successful, the specified | |
169 | * rdma_cm_id will be bound to a local device. | |
170 | * | |
171 | * @id: RDMA identifier. | |
172 | * @src_addr: Source address information. This parameter may be NULL. | |
173 | * @dst_addr: Destination address information. | |
174 | * @timeout_ms: Time to wait for resolution to complete. | |
175 | */ | |
176 | int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr, | |
177 | struct sockaddr *dst_addr, int timeout_ms); | |
178 | ||
179 | /** | |
180 | * rdma_resolve_route - Resolve the RDMA address bound to the RDMA identifier | |
181 | * into route information needed to establish a connection. | |
182 | * | |
183 | * This is called on the client side of a connection. | |
184 | * Users must have first called rdma_resolve_addr to resolve a dst_addr | |
185 | * into an RDMA address before calling this routine. | |
186 | */ | |
187 | int rdma_resolve_route(struct rdma_cm_id *id, int timeout_ms); | |
188 | ||
189 | /** | |
190 | * rdma_create_qp - Allocate a QP and associate it with the specified RDMA | |
191 | * identifier. | |
192 | * | |
193 | * QPs allocated to an rdma_cm_id will automatically be transitioned by the CMA | |
194 | * through their states. | |
195 | */ | |
196 | int rdma_create_qp(struct rdma_cm_id *id, struct ib_pd *pd, | |
197 | struct ib_qp_init_attr *qp_init_attr); | |
198 | ||
199 | /** | |
200 | * rdma_destroy_qp - Deallocate the QP associated with the specified RDMA | |
201 | * identifier. | |
202 | * | |
203 | * Users must destroy any QP associated with an RDMA identifier before | |
204 | * destroying the RDMA ID. | |
205 | */ | |
206 | void rdma_destroy_qp(struct rdma_cm_id *id); | |
207 | ||
208 | /** | |
209 | * rdma_init_qp_attr - Initializes the QP attributes for use in transitioning | |
210 | * to a specified QP state. | |
211 | * @id: Communication identifier associated with the QP attributes to | |
212 | * initialize. | |
213 | * @qp_attr: On input, specifies the desired QP state. On output, the | |
214 | * mandatory and desired optional attributes will be set in order to | |
215 | * modify the QP to the specified state. | |
216 | * @qp_attr_mask: The QP attribute mask that may be used to transition the | |
217 | * QP to the specified state. | |
218 | * | |
219 | * Users must set the @qp_attr->qp_state to the desired QP state. This call | |
220 | * will set all required attributes for the given transition, along with | |
221 | * known optional attributes. Users may override the attributes returned from | |
222 | * this call before calling ib_modify_qp. | |
223 | * | |
224 | * Users that wish to have their QP automatically transitioned through its | |
225 | * states can associate a QP with the rdma_cm_id by calling rdma_create_qp(). | |
226 | */ | |
227 | int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr, | |
228 | int *qp_attr_mask); | |
229 | ||
e51060f0 SH |
230 | /** |
231 | * rdma_connect - Initiate an active connection request. | |
628e5f6d SH |
232 | * @id: Connection identifier to connect. |
233 | * @conn_param: Connection information used for connected QPs. | |
e51060f0 SH |
234 | * |
235 | * Users must have resolved a route for the rdma_cm_id to connect with | |
236 | * by having called rdma_resolve_route before calling this routine. | |
628e5f6d SH |
237 | * |
238 | * This call will either connect to a remote QP or obtain remote QP | |
239 | * information for unconnected rdma_cm_id's. The actual operation is | |
240 | * based on the rdma_cm_id's port space. | |
e51060f0 SH |
241 | */ |
242 | int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param); | |
243 | ||
244 | /** | |
245 | * rdma_listen - This function is called by the passive side to | |
246 | * listen for incoming connection requests. | |
247 | * | |
248 | * Users must have bound the rdma_cm_id to a local address by calling | |
249 | * rdma_bind_addr before calling this routine. | |
250 | */ | |
251 | int rdma_listen(struct rdma_cm_id *id, int backlog); | |
252 | ||
253 | /** | |
254 | * rdma_accept - Called to accept a connection request or response. | |
255 | * @id: Connection identifier associated with the request. | |
256 | * @conn_param: Information needed to establish the connection. This must be | |
257 | * provided if accepting a connection request. If accepting a connection | |
258 | * response, this parameter must be NULL. | |
259 | * | |
260 | * Typically, this routine is only called by the listener to accept a connection | |
261 | * request. It must also be called on the active side of a connection if the | |
262 | * user is performing their own QP transitions. | |
951f7fc1 OG |
263 | * |
264 | * In the case of error, a reject message is sent to the remote side and the | |
265 | * state of the qp associated with the id is modified to error, such that any | |
266 | * previously posted receive buffers would be flushed. | |
e51060f0 SH |
267 | */ |
268 | int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param); | |
269 | ||
0fe313b0 SH |
270 | /** |
271 | * rdma_notify - Notifies the RDMA CM of an asynchronous event that has | |
272 | * occurred on the connection. | |
273 | * @id: Connection identifier to transition to established. | |
274 | * @event: Asynchronous event. | |
275 | * | |
276 | * This routine should be invoked by users to notify the CM of relevant | |
277 | * communication events. Events that should be reported to the CM and | |
278 | * when to report them are: | |
279 | * | |
280 | * IB_EVENT_COMM_EST - Used when a message is received on a connected | |
281 | * QP before an RTU has been received. | |
282 | */ | |
283 | int rdma_notify(struct rdma_cm_id *id, enum ib_event_type event); | |
284 | ||
e51060f0 SH |
285 | /** |
286 | * rdma_reject - Called to reject a connection request or response. | |
287 | */ | |
288 | int rdma_reject(struct rdma_cm_id *id, const void *private_data, | |
289 | u8 private_data_len); | |
290 | ||
291 | /** | |
292 | * rdma_disconnect - This function disconnects the associated QP and | |
293 | * transitions it into the error state. | |
294 | */ | |
295 | int rdma_disconnect(struct rdma_cm_id *id); | |
296 | ||
297 | #endif /* RDMA_CM_H */ | |
298 |