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 | ||
80 | struct rdma_cm_event { | |
81 | enum rdma_cm_event_type event; | |
82 | int status; | |
83 | void *private_data; | |
84 | u8 private_data_len; | |
85 | }; | |
86 | ||
87 | struct rdma_cm_id; | |
88 | ||
89 | /** | |
90 | * rdma_cm_event_handler - Callback used to report user events. | |
91 | * | |
92 | * Notes: Users may not call rdma_destroy_id from this callback to destroy | |
93 | * the passed in id, or a corresponding listen id. Returning a | |
94 | * non-zero value from the callback will destroy the passed in id. | |
95 | */ | |
96 | typedef int (*rdma_cm_event_handler)(struct rdma_cm_id *id, | |
97 | struct rdma_cm_event *event); | |
98 | ||
99 | struct rdma_cm_id { | |
100 | struct ib_device *device; | |
101 | void *context; | |
102 | struct ib_qp *qp; | |
103 | rdma_cm_event_handler event_handler; | |
104 | struct rdma_route route; | |
105 | enum rdma_port_space ps; | |
106 | u8 port_num; | |
107 | }; | |
108 | ||
109 | /** | |
110 | * rdma_create_id - Create an RDMA identifier. | |
111 | * | |
112 | * @event_handler: User callback invoked to report events associated with the | |
113 | * returned rdma_id. | |
114 | * @context: User specified context associated with the id. | |
115 | * @ps: RDMA port space. | |
116 | */ | |
117 | struct rdma_cm_id *rdma_create_id(rdma_cm_event_handler event_handler, | |
118 | void *context, enum rdma_port_space ps); | |
119 | ||
120 | void rdma_destroy_id(struct rdma_cm_id *id); | |
121 | ||
122 | /** | |
123 | * rdma_bind_addr - Bind an RDMA identifier to a source address and | |
124 | * associated RDMA device, if needed. | |
125 | * | |
126 | * @id: RDMA identifier. | |
127 | * @addr: Local address information. Wildcard values are permitted. | |
128 | * | |
129 | * This associates a source address with the RDMA identifier before calling | |
130 | * rdma_listen. If a specific local address is given, the RDMA identifier will | |
131 | * be bound to a local RDMA device. | |
132 | */ | |
133 | int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr); | |
134 | ||
135 | /** | |
136 | * rdma_resolve_addr - Resolve destination and optional source addresses | |
137 | * from IP addresses to an RDMA address. If successful, the specified | |
138 | * rdma_cm_id will be bound to a local device. | |
139 | * | |
140 | * @id: RDMA identifier. | |
141 | * @src_addr: Source address information. This parameter may be NULL. | |
142 | * @dst_addr: Destination address information. | |
143 | * @timeout_ms: Time to wait for resolution to complete. | |
144 | */ | |
145 | int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr, | |
146 | struct sockaddr *dst_addr, int timeout_ms); | |
147 | ||
148 | /** | |
149 | * rdma_resolve_route - Resolve the RDMA address bound to the RDMA identifier | |
150 | * into route information needed to establish a connection. | |
151 | * | |
152 | * This is called on the client side of a connection. | |
153 | * Users must have first called rdma_resolve_addr to resolve a dst_addr | |
154 | * into an RDMA address before calling this routine. | |
155 | */ | |
156 | int rdma_resolve_route(struct rdma_cm_id *id, int timeout_ms); | |
157 | ||
158 | /** | |
159 | * rdma_create_qp - Allocate a QP and associate it with the specified RDMA | |
160 | * identifier. | |
161 | * | |
162 | * QPs allocated to an rdma_cm_id will automatically be transitioned by the CMA | |
163 | * through their states. | |
164 | */ | |
165 | int rdma_create_qp(struct rdma_cm_id *id, struct ib_pd *pd, | |
166 | struct ib_qp_init_attr *qp_init_attr); | |
167 | ||
168 | /** | |
169 | * rdma_destroy_qp - Deallocate the QP associated with the specified RDMA | |
170 | * identifier. | |
171 | * | |
172 | * Users must destroy any QP associated with an RDMA identifier before | |
173 | * destroying the RDMA ID. | |
174 | */ | |
175 | void rdma_destroy_qp(struct rdma_cm_id *id); | |
176 | ||
177 | /** | |
178 | * rdma_init_qp_attr - Initializes the QP attributes for use in transitioning | |
179 | * to a specified QP state. | |
180 | * @id: Communication identifier associated with the QP attributes to | |
181 | * initialize. | |
182 | * @qp_attr: On input, specifies the desired QP state. On output, the | |
183 | * mandatory and desired optional attributes will be set in order to | |
184 | * modify the QP to the specified state. | |
185 | * @qp_attr_mask: The QP attribute mask that may be used to transition the | |
186 | * QP to the specified state. | |
187 | * | |
188 | * Users must set the @qp_attr->qp_state to the desired QP state. This call | |
189 | * will set all required attributes for the given transition, along with | |
190 | * known optional attributes. Users may override the attributes returned from | |
191 | * this call before calling ib_modify_qp. | |
192 | * | |
193 | * Users that wish to have their QP automatically transitioned through its | |
194 | * states can associate a QP with the rdma_cm_id by calling rdma_create_qp(). | |
195 | */ | |
196 | int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr, | |
197 | int *qp_attr_mask); | |
198 | ||
199 | struct rdma_conn_param { | |
200 | const void *private_data; | |
201 | u8 private_data_len; | |
202 | u8 responder_resources; | |
203 | u8 initiator_depth; | |
204 | u8 flow_control; | |
205 | u8 retry_count; /* ignored when accepting */ | |
206 | u8 rnr_retry_count; | |
207 | /* Fields below ignored if a QP is created on the rdma_cm_id. */ | |
208 | u8 srq; | |
209 | u32 qp_num; | |
210 | enum ib_qp_type qp_type; | |
211 | }; | |
212 | ||
213 | /** | |
214 | * rdma_connect - Initiate an active connection request. | |
215 | * | |
216 | * Users must have resolved a route for the rdma_cm_id to connect with | |
217 | * by having called rdma_resolve_route before calling this routine. | |
218 | */ | |
219 | int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param); | |
220 | ||
221 | /** | |
222 | * rdma_listen - This function is called by the passive side to | |
223 | * listen for incoming connection requests. | |
224 | * | |
225 | * Users must have bound the rdma_cm_id to a local address by calling | |
226 | * rdma_bind_addr before calling this routine. | |
227 | */ | |
228 | int rdma_listen(struct rdma_cm_id *id, int backlog); | |
229 | ||
230 | /** | |
231 | * rdma_accept - Called to accept a connection request or response. | |
232 | * @id: Connection identifier associated with the request. | |
233 | * @conn_param: Information needed to establish the connection. This must be | |
234 | * provided if accepting a connection request. If accepting a connection | |
235 | * response, this parameter must be NULL. | |
236 | * | |
237 | * Typically, this routine is only called by the listener to accept a connection | |
238 | * request. It must also be called on the active side of a connection if the | |
239 | * user is performing their own QP transitions. | |
240 | */ | |
241 | int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param); | |
242 | ||
243 | /** | |
244 | * rdma_reject - Called to reject a connection request or response. | |
245 | */ | |
246 | int rdma_reject(struct rdma_cm_id *id, const void *private_data, | |
247 | u8 private_data_len); | |
248 | ||
249 | /** | |
250 | * rdma_disconnect - This function disconnects the associated QP and | |
251 | * transitions it into the error state. | |
252 | */ | |
253 | int rdma_disconnect(struct rdma_cm_id *id); | |
254 | ||
255 | #endif /* RDMA_CM_H */ | |
256 |