librdmacm: provide OFED compatibility library.
[mirror/winof/.git] / ulp / librdmacm / include / rdma / rdma_cma.h
1 /*\r
2  * Copyright (c) 2005-2009 Intel Corporation.  All rights reserved.\r
3  *\r
4  * This software is available to you under the OpenFabrics.org BSD license\r
5  * below:\r
6  *\r
7  *     Redistribution and use in source and binary forms, with or\r
8  *     without modification, are permitted provided that the following\r
9  *     conditions are met:\r
10  *\r
11  *      - Redistributions of source code must retain the above\r
12  *        copyright notice, this list of conditions and the following\r
13  *        disclaimer.\r
14  *\r
15  *      - Redistributions in binary form must reproduce the above\r
16  *        copyright notice, this list of conditions and the following\r
17  *        disclaimer in the documentation and/or other materials\r
18  *        provided with the distribution.\r
19  *\r
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
23  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
24  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
25  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
26  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
27  * SOFTWARE.\r
28  */\r
29 \r
30 #pragma once\r
31 \r
32 #if !defined(RDMA_CMA_H)\r
33 #define RDMA_CMA_H\r
34 \r
35 #include <windows.h>\r
36 #include <infiniband\verbs.h>\r
37 #include <rdma\winverbs.h>\r
38 \r
39 #ifdef __cplusplus\r
40 extern "C" {\r
41 #endif\r
42 \r
43 /*\r
44  * Interfaces based on librdmacm 1.0.8.\r
45  */\r
46 \r
47 typedef unsigned __int8         uint8_t;\r
48 typedef unsigned __int16        uint16_t;\r
49 typedef unsigned __int32        uint32_t;\r
50 typedef unsigned __int64        uint64_t;\r
51 \r
52 /*\r
53  * Upon receiving a device removal event, users must destroy the associated\r
54  * RDMA identifier and release all resources allocated with the device.\r
55  */\r
56 enum rdma_cm_event_type\r
57 {\r
58         RDMA_CM_EVENT_ADDR_RESOLVED,\r
59         RDMA_CM_EVENT_ADDR_ERROR,\r
60         RDMA_CM_EVENT_ROUTE_RESOLVED,\r
61         RDMA_CM_EVENT_ROUTE_ERROR,\r
62         RDMA_CM_EVENT_CONNECT_REQUEST,\r
63         RDMA_CM_EVENT_CONNECT_RESPONSE,\r
64         RDMA_CM_EVENT_CONNECT_ERROR,\r
65         RDMA_CM_EVENT_UNREACHABLE,\r
66         RDMA_CM_EVENT_REJECTED,\r
67         RDMA_CM_EVENT_ESTABLISHED,\r
68         RDMA_CM_EVENT_DISCONNECTED,\r
69         RDMA_CM_EVENT_DEVICE_REMOVAL,\r
70         RDMA_CM_EVENT_MULTICAST_JOIN,\r
71         RDMA_CM_EVENT_MULTICAST_ERROR,\r
72         RDMA_CM_EVENT_ADDR_CHANGE,\r
73         RDMA_CM_EVENT_TIMEWAIT_EXIT\r
74 };\r
75 \r
76 enum rdma_port_space\r
77 {\r
78         RDMA_PS_IPOIB   = 0x0002,\r
79         RDMA_PS_TCP             = 0x0106,\r
80         RDMA_PS_UDP             = 0x0111,\r
81 };\r
82 \r
83 /*\r
84  * Global qkey value for UDP QPs and multicast groups created via the \r
85  * RDMA CM.\r
86  */\r
87 #define RDMA_UDP_QKEY 0x01234567\r
88 \r
89 struct ib_addr\r
90 {\r
91         union ibv_gid   sgid;\r
92         union ibv_gid   dgid;\r
93         uint16_t                pkey;\r
94 };\r
95 \r
96 struct rdma_addr\r
97 {\r
98         struct sockaddr         src_addr;\r
99         uint8_t                         src_pad[sizeof(SOCKADDR_IN6) -\r
100                                                                 sizeof(struct sockaddr)];\r
101         struct sockaddr         dst_addr;\r
102         uint8_t                         dst_pad[sizeof(SOCKADDR_IN6) -\r
103                                                                 sizeof(struct sockaddr)];\r
104         union\r
105         {\r
106                 struct ib_addr  ibaddr;\r
107         }       addr;\r
108 };\r
109 \r
110 struct ibv_sa_path_rec\r
111 {\r
112         uint8_t                         data[64];\r
113 };\r
114 \r
115 struct rdma_route\r
116 {\r
117         struct rdma_addr                addr;\r
118         struct ibv_sa_path_rec  *path_rec;\r
119         int                                             num_paths;\r
120 };\r
121 \r
122 struct rdma_event_channel\r
123 {\r
124         uint32_t                timeout;\r
125 };\r
126 \r
127 struct rdma_cm_id\r
128 {\r
129         struct ibv_context                      *verbs;\r
130         struct rdma_event_channel       *channel;\r
131         void                                            *context;\r
132         struct ibv_qp                           *qp;\r
133         struct rdma_route                       route;\r
134         enum rdma_port_space            ps;\r
135         uint8_t                                         port_num;\r
136 \r
137         union {\r
138                 IWVConnectEndpoint              *connect;\r
139                 IWVDatagramEndpoint             *datagram;\r
140         }       ep;\r
141         OVERLAPPED                                      overlap;\r
142         uint32_t                                        events_completed;\r
143 };\r
144 \r
145 struct rdma_conn_param\r
146 {\r
147         const void *private_data;\r
148         uint8_t private_data_len;\r
149         uint8_t responder_resources;\r
150         uint8_t initiator_depth;\r
151         uint8_t flow_control;\r
152         uint8_t retry_count;            /* ignored when accepting */\r
153         uint8_t rnr_retry_count;\r
154         /* Fields below ignored if a QP is created on the rdma_cm_id. */\r
155         uint8_t srq;\r
156         uint32_t qp_num;\r
157 };\r
158 \r
159 struct rdma_ud_param\r
160 {\r
161         const void *private_data;\r
162         uint8_t private_data_len;\r
163         struct ibv_ah_attr ah_attr;\r
164         uint32_t qp_num;\r
165         uint32_t qkey;\r
166 };\r
167 \r
168 struct rdma_cm_event\r
169 {\r
170         struct rdma_cm_id               *id;\r
171         struct rdma_cm_id               *listen_id;\r
172         enum rdma_cm_event_type  event;\r
173         int                                              status;\r
174         union\r
175         {\r
176                 struct rdma_conn_param conn;\r
177                 struct rdma_ud_param   ud;\r
178 \r
179         }       param;\r
180 };\r
181 \r
182 /**\r
183  * rdma_create_event_channel - Open a channel used to report communication events.\r
184  * Description:\r
185  *   Asynchronous events are reported to users through event channels.  Each\r
186  *   event channel maps to a file descriptor.\r
187  * Notes:\r
188  *   All created event channels must be destroyed by calling\r
189  *   rdma_destroy_event_channel.  Users should call rdma_get_cm_event to\r
190  *   retrieve events on an event channel.\r
191  * See also:\r
192  *   rdma_get_cm_event, rdma_destroy_event_channel\r
193  */\r
194 __declspec(dllexport)\r
195 struct rdma_event_channel *rdma_create_event_channel(void);\r
196 \r
197 /**\r
198  * rdma_destroy_event_channel - Close an event communication channel.\r
199  * @channel: The communication channel to destroy.\r
200  * Description:\r
201  *   Release all resources associated with an event channel and closes the\r
202  *   associated file descriptor.\r
203  * Notes:\r
204  *   All rdma_cm_id's associated with the event channel must be destroyed,\r
205  *   and all returned events must be acked before calling this function.\r
206  * See also:\r
207  *  rdma_create_event_channel, rdma_get_cm_event, rdma_ack_cm_event\r
208  */\r
209 __declspec(dllexport)\r
210 void rdma_destroy_event_channel(struct rdma_event_channel *channel);\r
211 \r
212 /**\r
213  * rdma_create_id - Allocate a communication identifier.\r
214  * @channel: The communication channel that events associated with the\r
215  *   allocated rdma_cm_id will be reported on.\r
216  * @id: A reference where the allocated communication identifier will be\r
217  *   returned.\r
218  * @context: User specified context associated with the rdma_cm_id.\r
219  * @ps: RDMA port space.\r
220  * Description:\r
221  *   Creates an identifier that is used to track communication information.\r
222  * Notes:\r
223  *   Rdma_cm_id's are conceptually equivalent to a socket for RDMA\r
224  *   communication.  The difference is that RDMA communication requires\r
225  *   explicitly binding to a specified RDMA device before communication\r
226  *   can occur, and most operations are asynchronous in nature.  Communication\r
227  *   events on an rdma_cm_id are reported through the associated event\r
228  *   channel.  Users must release the rdma_cm_id by calling rdma_destroy_id.\r
229  * See also:\r
230  *   rdma_create_event_channel, rdma_destroy_id, rdma_get_devices,\r
231  *   rdma_bind_addr, rdma_resolve_addr, rdma_connect, rdma_listen,\r
232  */\r
233 __declspec(dllexport)\r
234 int rdma_create_id(struct rdma_event_channel *channel,\r
235                                    struct rdma_cm_id **id, void *context,\r
236                                    enum rdma_port_space ps);\r
237 \r
238 /**\r
239  * rdma_destroy_id - Release a communication identifier.\r
240  * @id: The communication identifier to destroy.\r
241  * Description:\r
242  *   Destroys the specified rdma_cm_id and cancels any outstanding\r
243  *   asynchronous operation.\r
244  * Notes:\r
245  *   Users must free any associated QP with the rdma_cm_id before\r
246  *   calling this routine and ack an related events.\r
247  * See also:\r
248  *   rdma_create_id, rdma_destroy_qp, rdma_ack_cm_event\r
249  */\r
250 __declspec(dllexport)\r
251 int rdma_destroy_id(struct rdma_cm_id *id);\r
252 \r
253 /**\r
254  * rdma_bind_addr - Bind an RDMA identifier to a source address.\r
255  * @id: RDMA identifier.\r
256  * @addr: Local address information.  Wildcard values are permitted.\r
257  * Description:\r
258  *   Associates a source address with an rdma_cm_id.  The address may be\r
259  *   wildcarded.  If binding to a specific local address, the rdma_cm_id\r
260  *   will also be bound to a local RDMA device.\r
261  * Notes:\r
262  *   Typically, this routine is called before calling rdma_listen to bind\r
263  *   to a specific port number, but it may also be called on the active side\r
264  *   of a connection before calling rdma_resolve_addr to bind to a specific\r
265  *   address.\r
266  * See also:\r
267  *   rdma_create_id, rdma_listen, rdma_resolve_addr, rdma_create_qp\r
268  */\r
269 __declspec(dllexport)\r
270 int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr);\r
271 \r
272 /**\r
273  * rdma_resolve_addr - Resolve destination and optional source addresses.\r
274  * @id: RDMA identifier.\r
275  * @src_addr: Source address information.  This parameter may be NULL.\r
276  * @dst_addr: Destination address information.\r
277  * @timeout_ms: Time to wait for resolution to complete.\r
278  * Description:\r
279  *   Resolve destination and optional source addresses from IP addresses\r
280  *   to an RDMA address.  If successful, the specified rdma_cm_id will\r
281  *   be bound to a local device.\r
282  * Notes:\r
283  *   This call is used to map a given destination IP address to a usable RDMA\r
284  *   address.  If a source address is given, the rdma_cm_id is bound to that\r
285  *   address, the same as if rdma_bind_addr were called.  If no source\r
286  *   address is given, and the rdma_cm_id has not yet been bound to a device,\r
287  *   then the rdma_cm_id will be bound to a source address based on the\r
288  *   local routing tables.  After this call, the rdma_cm_id will be bound to\r
289  *   an RDMA device.  This call is typically made from the active side of a\r
290  *   connection before calling rdma_resolve_route and rdma_connect.\r
291  * See also:\r
292  *   rdma_create_id, rdma_resolve_route, rdma_connect, rdma_create_qp,\r
293  *   rdma_get_cm_event, rdma_bind_addr\r
294  */\r
295 __declspec(dllexport)\r
296 int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr,\r
297                                           struct sockaddr *dst_addr, int timeout_ms);\r
298 \r
299 /**\r
300  * rdma_resolve_route - Resolve the route information needed to establish a connection.\r
301  * @id: RDMA identifier.\r
302  * @timeout_ms: Time to wait for resolution to complete.\r
303  * Description:\r
304  *   Resolves an RDMA route to the destination address in order to establish\r
305  *   a connection.  The destination address must have already been resolved\r
306  *   by calling rdma_resolve_addr.\r
307  * Notes:\r
308  *   This is called on the client side of a connection after calling\r
309  *   rdma_resolve_addr, but before calling rdma_connect.\r
310  * See also:\r
311  *   rdma_resolve_addr, rdma_connect, rdma_get_cm_event\r
312  */\r
313 __declspec(dllexport)\r
314 int rdma_resolve_route(struct rdma_cm_id *id, int timeout_ms);\r
315 \r
316 /**\r
317  * rdma_create_qp - Allocate a QP.\r
318  * @id: RDMA identifier.\r
319  * @pd: protection domain for the QP.\r
320  * @qp_init_attr: initial QP attributes.\r
321  * Description:\r
322  *  Allocate a QP associated with the specified rdma_cm_id and transition it\r
323  *  for sending and receiving.\r
324  * Notes:\r
325  *   The rdma_cm_id must be bound to a local RDMA device before calling this\r
326  *   function, and the protection domain must be for that same device.\r
327  *   QPs allocated to an rdma_cm_id are automatically transitioned by the\r
328  *   librdmacm through their states.  After being allocated, the QP will be\r
329  *   ready to handle posting of receives.  If the QP is unconnected, it will\r
330  *   be ready to post sends.\r
331  * See also:\r
332  *   rdma_bind_addr, rdma_resolve_addr, rdma_destroy_qp, ibv_create_qp,\r
333  *   ibv_modify_qp\r
334  */\r
335 __declspec(dllexport)\r
336 int rdma_create_qp(struct rdma_cm_id *id, struct ibv_pd *pd,\r
337                                    struct ibv_qp_init_attr *qp_init_attr);\r
338 \r
339 /**\r
340  * rdma_destroy_qp - Deallocate a QP.\r
341  * @id: RDMA identifier.\r
342  * Description:\r
343  *   Destroy a QP allocated on the rdma_cm_id.\r
344  * Notes:\r
345  *   Users must destroy any QP associated with an rdma_cm_id before\r
346  *   destroying the ID.\r
347  * See also:\r
348  *   rdma_create_qp, rdma_destroy_id, ibv_destroy_qp\r
349  */\r
350 __declspec(dllexport)\r
351 void rdma_destroy_qp(struct rdma_cm_id *id);\r
352 \r
353 /**\r
354  * rdma_connect - Initiate an active connection request.\r
355  * @id: RDMA identifier.\r
356  * @conn_param: connection parameters.\r
357  * Description:\r
358  *   For a connected rdma_cm_id, this call initiates a connection request\r
359  *   to a remote destination.  For an unconnected rdma_cm_id, it initiates\r
360  *   a lookup of the remote QP providing the datagram service.\r
361  * Notes:\r
362  *   Users must have resolved a route to the destination address\r
363  *   by having called rdma_resolve_route before calling this routine.\r
364  * See also:\r
365  *   rdma_resolve_route, rdma_disconnect, rdma_listen, rdma_get_cm_event\r
366  */\r
367 __declspec(dllexport)\r
368 int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param);\r
369 \r
370 /**\r
371  * rdma_listen - Listen for incoming connection requests.\r
372  * @id: RDMA identifier.\r
373  * @backlog: backlog of incoming connection requests.\r
374  * Description:\r
375  *   Initiates a listen for incoming connection requests or datagram service\r
376  *   lookup.  The listen will be restricted to the locally bound source\r
377  *   address.\r
378  * Notes:\r
379  *   Users must have bound the rdma_cm_id to a local address by calling\r
380  *   rdma_bind_addr before calling this routine.  If the rdma_cm_id is\r
381  *   bound to a specific IP address, the listen will be restricted to that\r
382  *   address and the associated RDMA device.  If the rdma_cm_id is bound\r
383  *   to an RDMA port number only, the listen will occur across all RDMA\r
384  *   devices.\r
385  * See also:\r
386  *   rdma_bind_addr, rdma_connect, rdma_accept, rdma_reject, rdma_get_cm_event\r
387  */\r
388 __declspec(dllexport)\r
389 int rdma_listen(struct rdma_cm_id *id, int backlog);\r
390 \r
391 /**\r
392  * rdma_accept - Called to accept a connection request.\r
393  * @id: Connection identifier associated with the request.\r
394  * @conn_param: Information needed to establish the connection.\r
395  * Description:\r
396  *   Called from the listening side to accept a connection or datagram\r
397  *   service lookup request.\r
398  * Notes:\r
399  *   Unlike the socket accept routine, rdma_accept is not called on a\r
400  *   listening rdma_cm_id.  Instead, after calling rdma_listen, the user\r
401  *   waits for a connection request event to occur.  Connection request\r
402  *   events give the user a newly created rdma_cm_id, similar to a new\r
403  *   socket, but the rdma_cm_id is bound to a specific RDMA device.\r
404  *   rdma_accept is called on the new rdma_cm_id.\r
405  * See also:\r
406  *   rdma_listen, rdma_reject, rdma_get_cm_event\r
407  */\r
408 __declspec(dllexport)\r
409 int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param);\r
410 \r
411 /**\r
412  * rdma_reject - Called to reject a connection request.\r
413  * @id: Connection identifier associated with the request.\r
414  * @private_data: Optional private data to send with the reject message.\r
415  * @private_data_len: Size of the private_data to send, in bytes.\r
416  * Description:\r
417  *   Called from the listening side to reject a connection or datagram\r
418  *   service lookup request.\r
419  * Notes:\r
420  *   After receiving a connection request event, a user may call rdma_reject\r
421  *   to reject the request.  If the underlying RDMA transport supports\r
422  *   private data in the reject message, the specified data will be passed to\r
423  *   the remote side.\r
424  * See also:\r
425  *   rdma_listen, rdma_accept, rdma_get_cm_event\r
426  */\r
427 __declspec(dllexport)\r
428 int rdma_reject(struct rdma_cm_id *id, const void *private_data,\r
429                                 uint8_t private_data_len);\r
430 \r
431 /**\r
432  * rdma_notify - Notifies the librdmacm of an asynchronous event.\r
433  * @id: RDMA identifier.\r
434  * @event: Asynchronous event.\r
435  * Description:\r
436  *   Used to notify the librdmacm of asynchronous events that have occurred\r
437  *   on a QP associated with the rdma_cm_id.\r
438  * Notes:\r
439  *   Asynchronous events that occur on a QP are reported through the user's\r
440  *   device event handler.  This routine is used to notify the librdmacm of\r
441  *   communication events.  In most cases, use of this routine is not\r
442  *   necessary, however if connection establishment is done out of band\r
443  *   (such as done through Infiniband), it's possible to receive data on a\r
444  *   QP that is not yet considered connected.  This routine forces the\r
445  *   connection into an established state in this case in order to handle\r
446  *   the rare situation where the connection never forms on its own.\r
447  *   Events that should be reported to the CM are: IB_EVENT_COMM_EST.\r
448  * See also:\r
449  *   rdma_connect, rdma_accept, rdma_listen\r
450  */\r
451 __declspec(dllexport)\r
452 int rdma_notify(struct rdma_cm_id *id, enum ibv_event_type event);\r
453 \r
454 /**\r
455  * rdma_disconnect - This function disconnects a connection.\r
456  * @id: RDMA identifier.\r
457  * Description:\r
458  *   Disconnects a connection and transitions any associated QP to the\r
459  *   error state.\r
460  * See also:\r
461  *   rdma_connect, rdma_listen, rdma_accept\r
462  */\r
463 __declspec(dllexport)\r
464 int rdma_disconnect(struct rdma_cm_id *id);\r
465 \r
466 /**\r
467  * rdma_join_multicast - Joins a multicast group.\r
468  * @id: Communication identifier associated with the request.\r
469  * @addr: Multicast address identifying the group to join.\r
470  * @context: User-defined context associated with the join request.\r
471  * Description:\r
472  *   Joins a multicast group and attaches an associated QP to the group.\r
473  * Notes:\r
474  *   Before joining a multicast group, the rdma_cm_id must be bound to\r
475  *   an RDMA device by calling rdma_bind_addr or rdma_resolve_addr.  Use of\r
476  *   rdma_resolve_addr requires the local routing tables to resolve the\r
477  *   multicast address to an RDMA device.  The user must call\r
478  *   rdma_leave_multicast to leave the multicast group and release any\r
479  *   multicast resources.  The context is returned to the user through\r
480  *   the private_data field in the rdma_cm_event.\r
481  * See also:\r
482  *   rdma_leave_multicast, rdma_bind_addr, rdma_resolve_addr, rdma_create_qp\r
483  */\r
484 __declspec(dllexport)\r
485 int rdma_join_multicast(struct rdma_cm_id *id, struct sockaddr *addr,\r
486                                                 void *context);\r
487 \r
488 /**\r
489  * rdma_leave_multicast - Leaves a multicast group.\r
490  * @id: Communication identifier associated with the request.\r
491  * @addr: Multicast address identifying the group to leave.\r
492  * Description:\r
493  *   Leaves a multicast group and detaches an associated QP from the group.\r
494  * Notes:\r
495  *   Calling this function before a group has been fully joined results in\r
496  *   canceling the join operation.  Users should be aware that messages\r
497  *   received from the multicast group may stilled be queued for\r
498  *   completion processing immediately after leaving a multicast group.\r
499  *   Destroying an rdma_cm_id will automatically leave all multicast groups.\r
500  * See also:\r
501  *   rdma_join_multicast, rdma_destroy_qp\r
502  */\r
503 __declspec(dllexport)\r
504 int rdma_leave_multicast(struct rdma_cm_id *id, struct sockaddr *addr);\r
505 \r
506 /**\r
507  * rdma_get_cm_event - Retrieves the next pending communication event.\r
508  * @channel: Event channel to check for events.\r
509  * @event: Allocated information about the next communication event.\r
510  * Description:\r
511  *   Retrieves a communication event.  If no events are pending, by default,\r
512  *   the call will block until an event is received.\r
513  * Notes:\r
514  *   The default synchronous behavior of this routine can be changed by\r
515  *   modifying the file descriptor associated with the given channel.  All\r
516  *   events that are reported must be acknowledged by calling rdma_ack_cm_event.\r
517  *   Destruction of an rdma_cm_id will block until related events have been\r
518  *   acknowledged.\r
519  * See also:\r
520  *   rdma_ack_cm_event, rdma_create_event_channel, rdma_event_str\r
521  */\r
522 __declspec(dllexport)\r
523 int rdma_get_cm_event(struct rdma_event_channel *channel,\r
524                                           struct rdma_cm_event **event);\r
525 \r
526 /**\r
527  * rdma_ack_cm_event - Free a communication event.\r
528  * @event: Event to be released.\r
529  * Description:\r
530  *   All events which are allocated by rdma_get_cm_event must be released,\r
531  *   there should be a one-to-one correspondence between successful gets\r
532  *   and acks.\r
533  * See also:\r
534  *   rdma_get_cm_event, rdma_destroy_id\r
535  */\r
536 __declspec(dllexport)\r
537 int rdma_ack_cm_event(struct rdma_cm_event *event);\r
538 \r
539 static uint16_t rdma_get_src_port(struct rdma_cm_id *id)\r
540 {\r
541         return  id->route.addr.src_addr.sa_family == PF_INET6 ?\r
542                 ((struct sockaddr_in6 *) &id->route.addr.src_addr)->sin6_port :\r
543                 ((struct sockaddr_in *) &id->route.addr.src_addr)->sin_port;\r
544 }\r
545 \r
546 static uint16_t rdma_get_dst_port(struct rdma_cm_id *id)\r
547 {\r
548         return  id->route.addr.dst_addr.sa_family == PF_INET6 ?\r
549                 ((struct sockaddr_in6 *) &id->route.addr.dst_addr)->sin6_port :\r
550                 ((struct sockaddr_in *) &id->route.addr.dst_addr)->sin_port;\r
551 }\r
552 \r
553 static struct sockaddr *rdma_get_local_addr(struct rdma_cm_id *id)\r
554 {\r
555         return &id->route.addr.src_addr;\r
556 }\r
557 \r
558 static struct sockaddr *rdma_get_peer_addr(struct rdma_cm_id *id)\r
559 {\r
560         return &id->route.addr.dst_addr;\r
561 }\r
562 \r
563 /**\r
564  * rdma_get_devices - Get list of RDMA devices currently available.\r
565  * @num_devices: If non-NULL, set to the number of devices returned.\r
566  * Description:\r
567  *   Return a NULL-terminated array of opened RDMA devices.  Callers can use\r
568  *   this routine to allocate resources on specific RDMA devices that will be\r
569  *   shared across multiple rdma_cm_id's.\r
570  * Notes:\r
571  *   The returned array must be released by calling rdma_free_devices.  Devices\r
572  *   remain opened while the librdmacm is loaded.\r
573  * See also:\r
574  *   rdma_free_devices\r
575  */\r
576 __declspec(dllexport)\r
577 struct ibv_context **rdma_get_devices(int *num_devices);\r
578 \r
579 /**\r
580  * rdma_free_devices - Frees the list of devices returned by rdma_get_devices.\r
581  * @list: List of devices returned from rdma_get_devices.\r
582  * Description:\r
583  *   Frees the device array returned by rdma_get_devices.\r
584  * See also:\r
585  *   rdma_get_devices\r
586  */\r
587 __declspec(dllexport)\r
588 void rdma_free_devices(struct ibv_context **list);\r
589 \r
590 /**\r
591  * rdma_event_str - Returns a string representation of an rdma cm event.\r
592  * @event: Asynchronous event.\r
593  * Description:\r
594  *   Returns a string representation of an asynchronous event.\r
595  * See also:\r
596  *   rdma_get_cm_event\r
597  */\r
598 __declspec(dllexport)\r
599 const char *rdma_event_str(enum rdma_cm_event_type event);\r
600 \r
601 /* Option levels */\r
602 enum\r
603 {\r
604         RDMA_OPTION_ID          = 0\r
605 };\r
606 \r
607 /* Option details */\r
608 enum\r
609 {\r
610         RDMA_OPTION_ID_TOS      = 0     /* uint8_t: RFC 2474 */\r
611 };\r
612 \r
613 /**\r
614  * rdma_set_option - Set options for an rdma_cm_id.\r
615  * @id: Communication identifier to set option for.\r
616  * @level: Protocol level of the option to set.\r
617  * @optname: Name of the option to set.\r
618  * @optval: Reference to the option data.\r
619  * @optlen: The size of the %optval buffer.\r
620  */\r
621 __declspec(dllexport)\r
622 int rdma_set_option(struct rdma_cm_id *id, int level, int optname,\r
623                                         void *optval, size_t optlen);\r
624 \r
625 /**\r
626  * rdma_migrate_id - Move an rdma_cm_id to a new event channel.\r
627  * @id: Communication identifier to migrate.\r
628  * @channel: New event channel for rdma_cm_id events.\r
629  */\r
630 __declspec(dllexport)\r
631 int rdma_migrate_id(struct rdma_cm_id *id, struct rdma_event_channel *channel);\r
632 \r
633 #ifdef __cplusplus\r
634 }\r
635 #endif\r
636 \r
637 #endif /* RDMA_CMA_H */\r