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