[LIBIBVERBS] add ECONNRESET mapped to MSFT WSAECONNRESET for OFED porting.
[mirror/winof/.git] / ulp / libibverbs / include / infiniband / verbs.h
1 /*\r
2  * Copyright (c) 2004, 2005 Topspin Communications.  All rights reserved.\r
3  * Copyright (c) 2004, 2008 Intel Corporation.  All rights reserved.\r
4  * Copyright (c) 2005, 2006, 2007 Cisco Systems, Inc.  All rights reserved.\r
5  * Copyright (c) 2005 PathScale, Inc.  All rights reserved.\r
6  *\r
7  * This software is available to you under the OpenFabrics.org BSD license\r
8  * below:\r
9  *\r
10  *     Redistribution and use in source and binary forms, with or\r
11  *     without modification, are permitted provided that the following\r
12  *     conditions are met:\r
13  *\r
14  *      - Redistributions of source code must retain the above\r
15  *        copyright notice, this list of conditions and the following\r
16  *        disclaimer.\r
17  *\r
18  *      - Redistributions in binary form must reproduce the above\r
19  *        copyright notice, this list of conditions and the following\r
20  *        disclaimer in the documentation and/or other materials\r
21  *        provided with the distribution.\r
22  *\r
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
30  * SOFTWARE.\r
31  */\r
32 \r
33 #pragma once\r
34 \r
35 #ifndef INFINIBAND_VERBS_H\r
36 #define INFINIBAND_VERBS_H\r
37 \r
38 #include <windows.h>\r
39 #include <rdma\winverbs.h>\r
40 #include <errno.h>\r
41 #include <comp_channel.h>\r
42 \r
43 #ifdef __cplusplus\r
44 extern "C" {\r
45 #endif\r
46 \r
47 /*\r
48  * Interfaces based on libibverbs 1.1.2.\r
49  */\r
50 \r
51 typedef unsigned __int8         uint8_t;\r
52 typedef unsigned __int16        uint16_t;\r
53 typedef unsigned __int32        uint32_t;\r
54 typedef unsigned __int64        uint64_t;\r
55 \r
56 #define EOVERFLOW               WV_BUFFER_OVERFLOW\r
57 #define EISCONN                 WV_CONNECTION_ACTIVE\r
58 #define ECONNREFUSED    WV_CONNECTION_REFUSED\r
59 #define ETIMEDOUT               WV_TIMEOUT\r
60 #define ENETUNREACH             WV_HOST_UNREACHABLE\r
61 #define EADDRINUSE              WV_ADDRESS_ALREADY_EXISTS\r
62 #define EALREADY                WV_IO_PENDING\r
63 #define EAFNOSUPPORT    WV_INVALID_ADDRESS\r
64 #define EWOULDBLOCK             WV_DEVICE_BUSY\r
65 \r
66 #define ECONNRESET              WSAECONNRESET\r
67 \r
68 union ibv_gid\r
69 {\r
70         uint8_t                 raw[16];\r
71         struct\r
72         {\r
73                 uint64_t        subnet_prefix;\r
74                 uint64_t        interface_id;\r
75 \r
76         }       global;\r
77 };\r
78 \r
79 enum ibv_node_type\r
80 {\r
81         IBV_NODE_UNKNOWN        = -1,\r
82         IBV_NODE_CA             = 1,\r
83         IBV_NODE_SWITCH,\r
84         IBV_NODE_ROUTER,\r
85         IBV_NODE_RNIC\r
86 };\r
87 \r
88 enum ibv_transport_type\r
89 {\r
90         IBV_TRANSPORT_UNKNOWN   = WvDeviceUnknown,\r
91         IBV_TRANSPORT_IB                = WvDeviceInfiniband,\r
92         IBV_TRANSPORT_IWARP             = WvDeviceIwarp\r
93 };\r
94 \r
95 enum ibv_device_cap_flags\r
96 {\r
97         IBV_DEVICE_RESIZE_MAX_WR                = WV_DEVICE_RESIZE_MAX_WR,\r
98         IBV_DEVICE_BAD_PKEY_CNTR                = WV_DEVICE_BAD_PKEY_COUNTER,\r
99         IBV_DEVICE_BAD_QKEY_CNTR                = WV_DEVICE_BAD_QKEY_COUNTER,\r
100         IBV_DEVICE_RAW_MULTI                    = 0,\r
101         IBV_DEVICE_AUTO_PATH_MIG                = WV_DEVICE_PATH_MIGRATION,\r
102         IBV_DEVICE_CHANGE_PHY_PORT              = WV_DEVICE_CHANGE_PHYSICAL_PORT,\r
103         IBV_DEVICE_UD_AV_PORT_ENFORCE   = WV_DEVICE_AH_PORT_CHECKING,\r
104         IBV_DEVICE_CURR_QP_STATE_MOD    = WV_DEVICE_QP_STATE_MODIFIER,\r
105         IBV_DEVICE_SHUTDOWN_PORT                = WV_DEVICE_SHUTDOWN_PORT,\r
106         IBV_DEVICE_INIT_TYPE                    = WV_DEVICE_INIT_TYPE,\r
107         IBV_DEVICE_PORT_ACTIVE_EVENT    = WV_DEVICE_PORT_ACTIVE_EVENT,\r
108         IBV_DEVICE_SYS_IMAGE_GUID               = WV_DEVICE_SYSTEM_IMAGE_GUID,\r
109         IBV_DEVICE_RC_RNR_NAK_GEN               = WV_DEVICE_RC_RNR_NAK_GENERATION,\r
110         IBV_DEVICE_SRQ_RESIZE                   = WV_DEVICE_SRQ_RESIZE,\r
111         IBV_DEVICE_N_NOTIFY_CQ                  = WV_DEVICE_BATCH_NOTIFY_CQ\r
112 };\r
113 \r
114 enum ibv_atomic_cap\r
115 {\r
116         IBV_ATOMIC_NONE = WvAtomicNone,\r
117         IBV_ATOMIC_HCA  = WvAtomicDevice,\r
118         IBV_ATOMIC_GLOB = WvAtomicNode\r
119 };\r
120 \r
121 struct ibv_device_attr\r
122 {\r
123         char                    fw_ver[64];\r
124         uint64_t                node_guid;\r
125         uint64_t                sys_image_guid;\r
126         uint64_t                max_mr_size;\r
127         uint64_t                page_size_cap;\r
128         uint32_t                vendor_id;\r
129         uint32_t                vendor_part_id;\r
130         uint32_t                hw_ver;\r
131         int                             max_qp;\r
132         int                             max_qp_wr;\r
133         int                             device_cap_flags;\r
134         int                             max_sge;\r
135         int                             max_sge_rd;\r
136         int                             max_cq;\r
137         int                             max_cqe;\r
138         int                             max_mr;\r
139         int                             max_pd;\r
140         int                             max_qp_rd_atom;\r
141         int                             max_ee_rd_atom;\r
142         int                             max_res_rd_atom;\r
143         int                             max_qp_init_rd_atom;\r
144         int                             max_ee_init_rd_atom;\r
145         enum ibv_atomic_cap     atomic_cap;\r
146         int                             max_ee;\r
147         int                             max_rdd;\r
148         int                             max_mw;\r
149         int                             max_raw_ipv6_qp;\r
150         int                             max_raw_ethy_qp;\r
151         int                             max_mcast_grp;\r
152         int                             max_mcast_qp_attach;\r
153         int                             max_total_mcast_qp_attach;\r
154         int                             max_ah;\r
155         int                             max_fmr;\r
156         int                             max_map_per_fmr;\r
157         int                             max_srq;\r
158         int                             max_srq_wr;\r
159         int                             max_srq_sge;\r
160         uint16_t                max_pkeys;\r
161         uint8_t                 local_ca_ack_delay;\r
162         uint8_t                 phys_port_cnt;\r
163 };\r
164 \r
165 enum ibv_mtu\r
166 {\r
167         IBV_MTU_256  = 1,\r
168         IBV_MTU_512  = 2,\r
169         IBV_MTU_1024 = 3,\r
170         IBV_MTU_2048 = 4,\r
171         IBV_MTU_4096 = 5\r
172 };\r
173 \r
174 enum ibv_port_state\r
175 {\r
176         IBV_PORT_NOP                    = WvPortNop,\r
177         IBV_PORT_DOWN                   = WvPortDown,\r
178         IBV_PORT_INIT                   = WvPortInit,\r
179         IBV_PORT_ARMED                  = WvPortArmed,\r
180         IBV_PORT_ACTIVE                 = WvPortActive,\r
181         IBV_PORT_ACTIVE_DEFER   = WvPortActiveDefer\r
182 };\r
183 \r
184 struct ibv_port_attr\r
185 {\r
186         enum ibv_port_state     state;\r
187         enum ibv_mtu            max_mtu;\r
188         enum ibv_mtu            active_mtu;\r
189         int                                     gid_tbl_len;\r
190         uint32_t                        port_cap_flags;\r
191         uint32_t                        max_msg_sz;\r
192         uint32_t                        bad_pkey_cntr;\r
193         uint32_t                        qkey_viol_cntr;\r
194         uint16_t                        pkey_tbl_len;\r
195         uint16_t                        lid;\r
196         uint16_t                        sm_lid;\r
197         uint8_t                         lmc;\r
198         uint8_t                         max_vl_num;\r
199         uint8_t                         sm_sl;\r
200         uint8_t                         subnet_timeout;\r
201         uint8_t                         init_type_reply;\r
202         uint8_t                         active_width;\r
203         uint8_t                         active_speed;\r
204         uint8_t                         phys_state;\r
205 };\r
206 \r
207 // Only device/port level events are currently supported.\r
208 enum ibv_event_type\r
209 {\r
210         IBV_EVENT_CQ_ERR,\r
211         IBV_EVENT_QP_FATAL,\r
212         IBV_EVENT_QP_REQ_ERR,\r
213         IBV_EVENT_QP_ACCESS_ERR,\r
214         IBV_EVENT_COMM_EST,\r
215         IBV_EVENT_SQ_DRAINED,\r
216         IBV_EVENT_PATH_MIG,\r
217         IBV_EVENT_PATH_MIG_ERR,\r
218         IBV_EVENT_DEVICE_FATAL,\r
219         IBV_EVENT_PORT_ACTIVE,\r
220         IBV_EVENT_PORT_ERR,\r
221         IBV_EVENT_LID_CHANGE,\r
222         IBV_EVENT_PKEY_CHANGE,\r
223         IBV_EVENT_SM_CHANGE,\r
224         IBV_EVENT_SRQ_ERR,\r
225         IBV_EVENT_SRQ_LIMIT_REACHED,\r
226         IBV_EVENT_QP_LAST_WQE_REACHED,\r
227         IBV_EVENT_CLIENT_REREGISTER\r
228 };\r
229 \r
230 struct ibv_async_event\r
231 {\r
232         union\r
233         {\r
234                 struct ibv_cq  *cq;\r
235                 struct ibv_qp  *qp;\r
236                 struct ibv_srq *srq;\r
237                 int                             port_num;\r
238 \r
239         }       element;\r
240         enum ibv_event_type     event_type;\r
241 };\r
242 \r
243 enum ibv_wc_status\r
244 {\r
245         IBV_WC_SUCCESS,\r
246         IBV_WC_LOC_LEN_ERR,\r
247         IBV_WC_LOC_QP_OP_ERR,\r
248         IBV_WC_LOC_PROT_ERR,\r
249         IBV_WC_WR_FLUSH_ERR,\r
250         IBV_WC_MW_BIND_ERR,\r
251         IBV_WC_REM_ACCESS_ERR,\r
252         IBV_WC_REM_OP_ERR,\r
253         IBV_WC_RNR_RETRY_EXC_ERR,\r
254         IBV_WC_RESP_TIMEOUT_ERR,\r
255         IBV_WC_REM_INV_REQ_ERR,\r
256         IBV_WC_BAD_RESP_ERR,\r
257         IBV_WC_LOC_ACCESS_ERR,\r
258         IBV_WC_GENERAL_ERR,\r
259         IBV_WC_FATAL_ERR,\r
260         IBV_WC_RETRY_EXC_ERR,\r
261         IBV_WC_REM_ABORT_ERR,\r
262         IBV_WC_LOC_EEC_OP_ERR,\r
263         IBV_WC_LOC_RDD_VIOL_ERR,\r
264         IBV_WC_REM_INV_RD_REQ_ERR,\r
265         IBV_WC_INV_EECN_ERR,\r
266         IBV_WC_INV_EEC_STATE_ERR\r
267 };\r
268 \r
269 __declspec(dllexport)\r
270 const char *ibv_wc_status_str(enum ibv_wc_status status);\r
271 \r
272 enum ibv_wc_opcode\r
273 {\r
274         IBV_WC_SEND                                     = WvSend,\r
275         IBV_WC_RDMA_WRITE                       = WvRdmaWrite,\r
276         IBV_WC_RDMA_READ                        = WvRdmaRead,\r
277         IBV_WC_COMP_SWAP                        = WvCompareExchange,\r
278         IBV_WC_FETCH_ADD                        = WvFetchAdd,\r
279         IBV_WC_BIND_MW                          = WvBindWindow,\r
280 /*\r
281  * Set value of IBV_WC_RECV so consumers can test if a completion is a\r
282  * receive by testing (opcode & IBV_WC_RECV).\r
283  */\r
284         IBV_WC_RECV                                     = WvReceive,\r
285         IBV_WC_RECV_RDMA_WITH_IMM       = WvReceiveRdmaWrite\r
286 };\r
287 \r
288 enum ibv_wc_flags\r
289 {\r
290         IBV_WC_GRH                      = WV_WC_GRH_VALID,\r
291         IBV_WC_WITH_IMM         = WV_WC_IMMEDIATE\r
292 };\r
293 \r
294 struct ibv_wc\r
295 {\r
296         union\r
297         {\r
298                 uint32_t                        qp_num;\r
299                 void*                           reserved;\r
300         };\r
301         uint64_t                        wr_id;\r
302         enum ibv_wc_opcode      opcode;\r
303         uint32_t                        byte_len;\r
304         uint32_t                        vendor_err2;\r
305         uint32_t                        vendor_err;\r
306         enum ibv_wc_status      status;\r
307 \r
308         enum ibv_wc_flags       wc_flags;\r
309         uint32_t                        imm_data;       /* in network byte order */\r
310         uint32_t                        src_qp;\r
311         uint16_t                        pkey_index;\r
312         uint16_t                        slid;\r
313         uint8_t                         sl;\r
314         uint8_t                         dlid_path_bits;\r
315 };\r
316 \r
317 enum ibv_access_flags\r
318 {\r
319         IBV_ACCESS_LOCAL_WRITE          = WV_ACCESS_LOCAL_WRITE,\r
320         IBV_ACCESS_REMOTE_WRITE         = WV_ACCESS_REMOTE_WRITE,\r
321         IBV_ACCESS_REMOTE_READ          = WV_ACCESS_REMOTE_READ,\r
322         IBV_ACCESS_REMOTE_ATOMIC        = WV_ACCESS_REMOTE_ATOMIC,\r
323         IBV_ACCESS_MW_BIND                      = WV_ACCESS_MW_BIND\r
324 };\r
325 \r
326 struct ibv_pd\r
327 {\r
328         struct ibv_context      *context;\r
329         IWVProtectionDomain     *handle;\r
330 };\r
331 \r
332 /* Reregister MR not supported by WinVerbs */\r
333 enum ibv_rereg_mr_flags\r
334 {\r
335         IBV_REREG_MR_CHANGE_TRANSLATION = (1 << 0),\r
336         IBV_REREG_MR_CHANGE_PD                  = (1 << 1),\r
337         IBV_REREG_MR_CHANGE_ACCESS              = (1 << 2),\r
338         IBV_REREG_MR_KEEP_VALID                 = (1 << 3)\r
339 };\r
340 \r
341 struct ibv_mr\r
342 {\r
343         struct ibv_context      *context;\r
344         struct ibv_pd           *pd;\r
345         void                            *addr;\r
346         size_t                          length;\r
347         uint32_t                        lkey;\r
348         uint32_t                        rkey;\r
349 };\r
350 \r
351 /* Memory windows not implemented by WinVerbs */\r
352 enum ibv_mw_type\r
353 {\r
354         IBV_MW_TYPE_1           = 1,\r
355         IBV_MW_TYPE_2           = 2\r
356 };\r
357 \r
358 /* Memory windows not implemented by WinVerbs */\r
359 struct ibv_mw\r
360 {\r
361         struct ibv_context      *context;\r
362         struct ibv_pd           *pd;\r
363         uint32_t                        rkey;\r
364 };\r
365 \r
366 struct ibv_global_route\r
367 {\r
368         union ibv_gid           dgid;\r
369         uint32_t                        flow_label;\r
370         uint8_t                         sgid_index;\r
371         uint8_t                         hop_limit;\r
372         uint8_t                         traffic_class;\r
373 };\r
374 \r
375 struct ibv_grh\r
376 {\r
377         uint32_t                        version_tclass_flow;\r
378         uint16_t                        paylen;\r
379         uint8_t                         next_hdr;\r
380         uint8_t                         hop_limit;\r
381         union ibv_gid           sgid;\r
382         union ibv_gid           dgid;\r
383 };\r
384 \r
385 enum ibv_rate\r
386 {\r
387         IBV_RATE_MAX      = 0,\r
388         IBV_RATE_2_5_GBPS = 2,\r
389         IBV_RATE_5_GBPS   = 5,\r
390         IBV_RATE_10_GBPS  = 3,\r
391         IBV_RATE_20_GBPS  = 6,\r
392         IBV_RATE_30_GBPS  = 4,\r
393         IBV_RATE_40_GBPS  = 7,\r
394         IBV_RATE_60_GBPS  = 8,\r
395         IBV_RATE_80_GBPS  = 9,\r
396         IBV_RATE_120_GBPS = 10\r
397 };\r
398 \r
399 /**\r
400  * ibv_rate_to_mult - Convert the IB rate enum to a multiple of the\r
401  * base rate of 2.5 Gbit/sec.  For example, IBV_RATE_5_GBPS will be\r
402  * converted to 2, since 5 Gbit/sec is 2 * 2.5 Gbit/sec.\r
403  * @rate: rate to convert.\r
404  */\r
405 __declspec(dllexport)\r
406 int ibv_rate_to_mult(enum ibv_rate rate);\r
407 \r
408 /**\r
409  * mult_to_ibv_rate - Convert a multiple of 2.5 Gbit/sec to an IB rate enum.\r
410  * @mult: multiple to convert.\r
411  */\r
412 __declspec(dllexport)\r
413 enum ibv_rate mult_to_ibv_rate(int mult);\r
414 \r
415 struct ibv_ah_attr\r
416 {\r
417         struct ibv_global_route grh;\r
418         uint16_t                                dlid;\r
419         uint8_t                                 sl;\r
420         uint8_t                                 src_path_bits;\r
421         uint8_t                                 static_rate;\r
422         uint8_t                                 is_global;\r
423         uint8_t                                 port_num;\r
424 };\r
425 \r
426 enum ibv_srq_attr_mask\r
427 {\r
428         IBV_SRQ_MAX_WR  = 1 << 0,\r
429         IBV_SRQ_LIMIT   = 1 << 1\r
430 };\r
431 \r
432 struct ibv_srq_attr\r
433 {\r
434         uint32_t                max_wr;\r
435         uint32_t                max_sge;\r
436         uint32_t                srq_limit;\r
437 };\r
438 \r
439 struct ibv_srq_init_attr\r
440 {\r
441         void                            *srq_context;\r
442         struct ibv_srq_attr     attr;\r
443 };\r
444 \r
445 enum ibv_qp_type\r
446 {\r
447         IBV_QPT_RC = WvQpTypeRc,\r
448         IBV_QPT_UC = WvQpTypeUc,\r
449         IBV_QPT_UD = WvQpTypeUd\r
450 };\r
451 \r
452 struct ibv_qp_cap\r
453 {\r
454         uint32_t                max_send_wr;\r
455         uint32_t                max_recv_wr;\r
456         uint32_t                max_send_sge;\r
457         uint32_t                max_recv_sge;\r
458         uint32_t                max_inline_data;\r
459 };\r
460 \r
461 struct ibv_qp_init_attr\r
462 {\r
463         void                            *qp_context;\r
464         struct ibv_cq           *send_cq;\r
465         struct ibv_cq           *recv_cq;\r
466         struct ibv_srq          *srq;\r
467         struct ibv_qp_cap       cap;\r
468         enum ibv_qp_type        qp_type;\r
469         int                                     sq_sig_all;\r
470 };\r
471 \r
472 enum ibv_qp_attr_mask\r
473 {\r
474         IBV_QP_STATE                            = WV_QP_ATTR_STATE,\r
475         IBV_QP_CUR_STATE                        = WV_QP_ATTR_CURRENT_STATE,\r
476         IBV_QP_EN_SQD_ASYNC_NOTIFY      = WV_QP_ATTR_FLAGS,\r
477         IBV_QP_ACCESS_FLAGS                     = WV_QP_ATTR_ACCESS_FLAGS,\r
478         IBV_QP_PKEY_INDEX                       = WV_QP_ATTR_PKEY_INDEX,\r
479         IBV_QP_PORT                                     = WV_QP_ATTR_PORT_NUMBER,\r
480         IBV_QP_QKEY                                     = WV_QP_ATTR_QKEY,\r
481         IBV_QP_AV                                       = WV_QP_ATTR_AV,\r
482         IBV_QP_PATH_MTU                         = WV_QP_ATTR_AV,\r
483         IBV_QP_TIMEOUT                          = WV_QP_ATTR_ACK_TIMEOUT,\r
484         IBV_QP_RETRY_CNT                        = WV_QP_ATTR_ERROR_RETRY_COUNT,\r
485         IBV_QP_RNR_RETRY                        = WV_QP_ATTR_RNR_RETRY_COUNT,\r
486         IBV_QP_RQ_PSN                           = WV_QP_ATTR_RECEIVE_PSN,\r
487         IBV_QP_MAX_QP_RD_ATOMIC         = WV_QP_ATTR_INITIATOR_DEPTH,\r
488         IBV_QP_ALT_PATH                         = WV_QP_ATTR_ALTERNATE_AV,\r
489         IBV_QP_MIN_RNR_TIMER            = WV_QP_ATTR_RNR_NAK_TIMEOUT,\r
490         IBV_QP_SQ_PSN                           = WV_QP_ATTR_SEND_PSN,\r
491         IBV_QP_MAX_DEST_RD_ATOMIC       = WV_QP_ATTR_RESPONDER_RESOURCES,\r
492         IBV_QP_PATH_MIG_STATE           = WV_QP_ATTR_PATH_MIG_STATE,\r
493         IBV_QP_CAP                                      = WV_QP_ATTR_CAPABILITIES,\r
494         IBV_QP_DEST_QPN                         = WV_QP_ATTR_DESTINATION_QPN\r
495 };\r
496 \r
497 enum ibv_qp_state\r
498 {\r
499         IBV_QPS_RESET   = WvQpStateReset,\r
500         IBV_QPS_INIT    = WvQpStateInit,\r
501         IBV_QPS_RTR             = WvQpStateRtr,\r
502         IBV_QPS_RTS             = WvQpStateRts,\r
503         IBV_QPS_SQD             = WvQpStateSqd,\r
504         IBV_QPS_SQE             = WvQpStateSqError,\r
505         IBV_QPS_ERR             = WvQpStateError\r
506 };\r
507 \r
508 enum ibv_mig_state\r
509 {\r
510         IBV_MIG_MIGRATED        = WvApmMigrated,\r
511         IBV_MIG_REARM           = WvApmRearm,\r
512         IBV_MIG_ARMED           = WvApmArmed\r
513 };\r
514 \r
515 struct ibv_qp_attr\r
516 {\r
517         enum ibv_qp_state       qp_state;\r
518         enum ibv_qp_state       cur_qp_state;\r
519         enum ibv_mtu            path_mtu;\r
520         enum ibv_mig_state      path_mig_state;\r
521         uint32_t                        qkey;\r
522         uint32_t                        rq_psn;\r
523         uint32_t                        sq_psn;\r
524         uint32_t                        dest_qp_num;\r
525         int                                     qp_access_flags;\r
526         struct ibv_qp_cap       cap;\r
527         struct ibv_ah_attr      ah_attr;\r
528         struct ibv_ah_attr      alt_ah_attr;\r
529         uint16_t                        pkey_index;\r
530         uint16_t                        alt_pkey_index;\r
531         uint8_t                         en_sqd_async_notify;\r
532         uint8_t                         sq_draining;\r
533         uint8_t                         max_rd_atomic;\r
534         uint8_t                         max_dest_rd_atomic;\r
535         uint8_t                         min_rnr_timer;\r
536         uint8_t                         port_num;\r
537         uint8_t                         timeout;\r
538         uint8_t                         retry_cnt;\r
539         uint8_t                         rnr_retry;\r
540         uint8_t                         alt_port_num;\r
541         uint8_t                         alt_timeout;\r
542 };\r
543 \r
544 enum ibv_wr_opcode\r
545 {\r
546         IBV_WR_SEND = WvSend,\r
547         IBV_WR_RDMA_WRITE = WvRdmaWrite,\r
548         IBV_WR_RDMA_READ = WvRdmaRead,\r
549         IBV_WR_ATOMIC_CMP_AND_SWP = WvCompareExchange,\r
550         IBV_WR_ATOMIC_FETCH_AND_ADD = WvFetchAdd,\r
551         IBV_WR_SEND_WITH_IMM = WvSend | 0x80000000,\r
552         IBV_WR_RDMA_WRITE_WITH_IMM = WvRdmaWrite | 0x80000000,\r
553 };\r
554 \r
555 enum ibv_send_flags\r
556 {\r
557         IBV_SEND_FENCE          = WV_SEND_FENCE,\r
558         IBV_SEND_SIGNALED       = WV_SEND_SIGNALED,\r
559         IBV_SEND_SOLICITED      = WV_SEND_SOLICITED,\r
560         IBV_SEND_INLINE         = WV_SEND_INLINE\r
561 };\r
562 \r
563 struct ibv_sge\r
564 {\r
565         uint64_t                addr;\r
566         uint32_t                length;\r
567         uint32_t                lkey;\r
568 };\r
569 \r
570 struct ibv_send_wr\r
571 {\r
572         uint64_t                                wr_id;\r
573         struct ibv_send_wr              *next;\r
574         struct ibv_sge                  *sg_list;\r
575         int                                             num_sge;\r
576         enum ibv_wr_opcode              opcode;\r
577         enum ibv_send_flags             send_flags;\r
578         uint32_t                                imm_data;       /* in network byte order */\r
579         union\r
580         {\r
581                 struct\r
582                 {\r
583                         uint64_t                remote_addr;\r
584                         uint32_t                rkey;\r
585 \r
586                 }       rdma;\r
587                 struct\r
588                 {\r
589                         uint64_t                remote_addr;\r
590                         uint32_t                rkey;\r
591                         uint64_t                compare_add;\r
592                         uint64_t                swap;\r
593 \r
594                 }       atomic;\r
595                 struct\r
596                 {\r
597                         struct ibv_ah  *ah;\r
598                         uint32_t                remote_qpn;\r
599                         uint32_t                remote_qkey;\r
600 \r
601                 }       ud;\r
602         }       wr;\r
603 };\r
604 \r
605 struct ibv_recv_wr\r
606 {\r
607         uint64_t                                wr_id;\r
608         struct ibv_recv_wr     *next;\r
609         struct ibv_sge         *sg_list;\r
610         int                                             num_sge;\r
611 };\r
612 \r
613 /* Memory windows not implemented by WinVerbs */\r
614 struct ibv_mw_bind\r
615 {\r
616         uint64_t                                wr_id;\r
617         struct ibv_mr                   *mr;\r
618         void                                    *addr;\r
619         size_t                                  length;\r
620         enum ibv_send_flags             send_flags;\r
621         enum ibv_access_flags   mw_access_flags;\r
622 };\r
623 \r
624 struct ibv_srq\r
625 {\r
626         struct ibv_context              *context;\r
627         void                                    *srq_context;\r
628         struct ibv_pd                   *pd;\r
629         IWVSharedReceiveQueue   *handle;\r
630 };\r
631 \r
632 struct ibv_qp\r
633 {\r
634         struct ibv_context              *context;\r
635         void                                    *qp_context;\r
636         struct ibv_pd                   *pd;\r
637         struct ibv_cq                   *send_cq;\r
638         struct ibv_cq                   *recv_cq;\r
639         struct ibv_srq                  *srq;\r
640         IWVQueuePair                    *handle;\r
641         union\r
642         {\r
643                 IWVDatagramQueuePair    *ud_handle;\r
644                 IWVConnectQueuePair             *conn_handle;\r
645         };\r
646         uint32_t                                qp_num;\r
647         enum ibv_qp_state       state;\r
648         enum ibv_qp_type                qp_type;\r
649 };\r
650 \r
651 struct ibv_comp_channel\r
652 {\r
653         struct ibv_context              *context;\r
654         COMP_CHANNEL                    comp_channel;\r
655 };\r
656 \r
657 struct ibv_cq\r
658 {\r
659         struct ibv_context              *context;\r
660         struct ibv_comp_channel *channel;\r
661         void                                    *cq_context;\r
662         IWVCompletionQueue              *handle;\r
663         int                                             cqe;\r
664         COMP_ENTRY                              comp_entry;\r
665         LONG volatile                   notify_cnt;\r
666         LONG volatile                   ack_cnt;\r
667 };\r
668 \r
669 struct ibv_ah\r
670 {\r
671         struct ibv_context              *context;\r
672         struct ibv_pd                   *pd;\r
673         IWVAddressHandle                *handle;\r
674         ULONG_PTR                               key;\r
675 };\r
676 \r
677 struct ibv_device;\r
678 struct ibv_context;\r
679 \r
680 enum\r
681 {\r
682         IBV_SYSFS_NAME_MAX      = 64\r
683 };\r
684 \r
685 struct ibv_device\r
686 {\r
687         enum ibv_node_type              node_type;\r
688         enum ibv_transport_type transport_type;\r
689         char                                    name[IBV_SYSFS_NAME_MAX];\r
690 };\r
691 \r
692 struct ibv_context\r
693 {\r
694         struct ibv_device               *device;\r
695         IWVDevice                               *cmd_if;\r
696         COMP_CHANNEL                    channel;\r
697 };\r
698 \r
699 /**\r
700  * ibv_get_device_list - Get list of IB devices currently available\r
701  * @num_devices: optional.  if non-NULL, set to the number of devices\r
702  * returned in the array.\r
703  *\r
704  * Return a NULL-terminated array of IB devices.  The array can be\r
705  * released with ibv_free_device_list().\r
706  */\r
707 __declspec(dllexport)\r
708 struct ibv_device **ibv_get_device_list(int *num_devices);\r
709 \r
710 /**\r
711  * ibv_free_device_list - Free list from ibv_get_device_list()\r
712  *\r
713  * Free an array of devices returned from ibv_get_device_list().  Once\r
714  * the array is freed, pointers to devices that were not opened with\r
715  * ibv_open_device() are no longer valid.  Client code must open all\r
716  * devices it intends to use before calling ibv_free_device_list().\r
717  */\r
718 __declspec(dllexport)\r
719 void ibv_free_device_list(struct ibv_device **list);\r
720 \r
721 /**\r
722  * ibv_get_device_name - Return kernel device name\r
723  */\r
724 __declspec(dllexport)\r
725 const char *ibv_get_device_name(struct ibv_device *device);\r
726 \r
727 /**\r
728  * ibv_get_device_guid - Return device's node GUID\r
729  */\r
730 __declspec(dllexport)\r
731 uint64_t ibv_get_device_guid(struct ibv_device *device);\r
732 \r
733 /**\r
734  * ibv_open_device - Initialize device for use\r
735  */\r
736 __declspec(dllexport)\r
737 struct ibv_context *ibv_open_device(struct ibv_device *device);\r
738 \r
739 /**\r
740  * ibv_close_device - Release device\r
741  */\r
742 __declspec(dllexport)\r
743 int ibv_close_device(struct ibv_context *context);\r
744 \r
745 /**\r
746  * ibv_get_async_event - Get next async event\r
747  * @event: Pointer to use to return async event\r
748  *\r
749  * All async events returned by ibv_get_async_event() must eventually\r
750  * be acknowledged with ibv_ack_async_event().\r
751  */\r
752 __declspec(dllexport)\r
753 int ibv_get_async_event(struct ibv_context *context,\r
754                                                 struct ibv_async_event *event);\r
755 \r
756 /**\r
757  * ibv_ack_async_event - Acknowledge an async event\r
758  * @event: Event to be acknowledged.\r
759  *\r
760  * All async events which are returned by ibv_get_async_event() must\r
761  * be acknowledged.  To avoid races, destroying an object (CQ, SRQ or\r
762  * QP) will wait for all affiliated events to be acknowledged, so\r
763  * there should be a one-to-one correspondence between acks and\r
764  * successful gets.\r
765  */\r
766 __declspec(dllexport)\r
767 void ibv_ack_async_event(struct ibv_async_event *event);\r
768 \r
769 /**\r
770  * ibv_query_device - Get device properties\r
771  */\r
772 __declspec(dllexport)\r
773 int ibv_query_device(struct ibv_context *context,\r
774                                          struct ibv_device_attr *device_attr);\r
775 \r
776 /**\r
777  * ibv_query_port - Get port properties\r
778  */\r
779 __declspec(dllexport)\r
780 int ibv_query_port(struct ibv_context *context, uint8_t port_num,\r
781                                    struct ibv_port_attr *port_attr);\r
782 \r
783 /**\r
784  * ibv_query_gid - Get a GID table entry\r
785  */\r
786 __declspec(dllexport)\r
787 int ibv_query_gid(struct ibv_context *context, uint8_t port_num,\r
788                                   int index, union ibv_gid *gid);\r
789 \r
790 /**\r
791  * ibv_query_pkey - Get a P_Key table entry\r
792  */\r
793 __declspec(dllexport)\r
794 int ibv_query_pkey(struct ibv_context *context, uint8_t port_num,\r
795                                    int index, uint16_t *pkey);\r
796 \r
797 /**\r
798  * ibv_alloc_pd - Allocate a protection domain\r
799  */\r
800 __declspec(dllexport)\r
801 struct ibv_pd *ibv_alloc_pd(struct ibv_context *context);\r
802 \r
803 /**\r
804  * ibv_dealloc_pd - Free a protection domain\r
805  */\r
806 __declspec(dllexport)\r
807 int ibv_dealloc_pd(struct ibv_pd *pd);\r
808 \r
809 /**\r
810  * ibv_reg_mr - Register a memory region\r
811  */\r
812 __declspec(dllexport)\r
813 struct ibv_mr *ibv_reg_mr(struct ibv_pd *pd, void *addr,\r
814                                                   size_t length, enum ibv_access_flags access);\r
815 \r
816 /**\r
817  * ibv_dereg_mr - Deregister a memory region\r
818  */\r
819 __declspec(dllexport)\r
820 int ibv_dereg_mr(struct ibv_mr *mr);\r
821 \r
822 /**\r
823  * ibv_create_comp_channel - Create a completion event channel\r
824  */\r
825 __declspec(dllexport)\r
826 struct ibv_comp_channel *ibv_create_comp_channel(struct ibv_context *context);\r
827 \r
828 /**\r
829  * ibv_destroy_comp_channel - Destroy a completion event channel\r
830  */\r
831 __declspec(dllexport)\r
832 int ibv_destroy_comp_channel(struct ibv_comp_channel *channel);\r
833 \r
834 /**\r
835  * ibv_create_cq - Create a completion queue\r
836  * @context - Context CQ will be attached to\r
837  * @cqe - Minimum number of entries required for CQ\r
838  * @cq_context - Consumer-supplied context returned for completion events\r
839  * @channel - Completion channel where completion events will be queued.\r
840  *     May be NULL if completion events will not be used.\r
841  * @comp_vector - Completion vector used to signal completion events.\r
842  *     Must be >= 0 and < context->num_comp_vectors.\r
843  */\r
844 __declspec(dllexport)\r
845 struct ibv_cq *ibv_create_cq(struct ibv_context *context, int cqe,\r
846                                                          void *cq_context,\r
847                                                          struct ibv_comp_channel *channel,\r
848                                                          int comp_vector);\r
849 \r
850 /**\r
851  * ibv_resize_cq - Modifies the capacity of the CQ.\r
852  * @cq: The CQ to resize.\r
853  * @cqe: The minimum size of the CQ.\r
854  *\r
855  * Users can examine the cq structure to determine the actual CQ size.\r
856  */\r
857 __declspec(dllexport)\r
858 int ibv_resize_cq(struct ibv_cq *cq, int cqe);\r
859 \r
860 /**\r
861  * ibv_destroy_cq - Destroy a completion queue\r
862  */\r
863 __declspec(dllexport)\r
864 int ibv_destroy_cq(struct ibv_cq *cq);\r
865 \r
866 /**\r
867  * ibv_get_cq_event - Read next CQ event\r
868  * @channel: Channel to get next event from.\r
869  * @cq: Used to return pointer to CQ.\r
870  * @cq_context: Used to return consumer-supplied CQ context.\r
871  *\r
872  * All completion events returned by ibv_get_cq_event() must\r
873  * eventually be acknowledged with ibv_ack_cq_events().\r
874  */\r
875 __declspec(dllexport)\r
876 int ibv_get_cq_event(struct ibv_comp_channel *channel,\r
877                                          struct ibv_cq **cq, void **cq_context);\r
878 \r
879 /**\r
880  * ibv_ack_cq_events - Acknowledge CQ completion events\r
881  * @cq: CQ to acknowledge events for\r
882  * @nevents: Number of events to acknowledge.\r
883  *\r
884  * All completion events which are returned by ibv_get_cq_event() must\r
885  * be acknowledged.  To avoid races, ibv_destroy_cq() will wait for\r
886  * all completion events to be acknowledged, so there should be a\r
887  * one-to-one correspondence between acks and successful gets.  An\r
888  * application may accumulate multiple completion events and\r
889  * acknowledge them in a single call to ibv_ack_cq_events() by passing\r
890  * the number of events to ack in @nevents.\r
891  */\r
892 __declspec(dllexport)\r
893 void ibv_ack_cq_events(struct ibv_cq *cq, unsigned int nevents);\r
894 \r
895 /**\r
896  * ibv_poll_cq - Poll a CQ for work completions\r
897  * @cq:the CQ being polled\r
898  * @num_entries:maximum number of completions to return\r
899  * @wc:array of at least @num_entries of &struct ibv_wc where completions\r
900  *   will be returned\r
901  *\r
902  * Poll a CQ for (possibly multiple) completions.  If the return value\r
903  * is < 0, an error occurred.  If the return value is >= 0, it is the\r
904  * number of completions returned.  If the return value is\r
905  * non-negative and strictly less than num_entries, then the CQ was\r
906  * emptied.\r
907  */\r
908 __declspec(dllexport)\r
909 int ibv_poll_cq(struct ibv_cq *cq, int num_entries, struct ibv_wc *wc);\r
910 \r
911 /**\r
912  * ibv_req_notify_cq - Request completion notification on a CQ.  An\r
913  *   event will be added to the completion channel associated with the\r
914  *   CQ when an entry is added to the CQ.\r
915  * @cq: The completion queue to request notification for.\r
916  * @solicited_only: If non-zero, an event will be generated only for\r
917  *   the next solicited CQ entry.  If zero, any CQ entry, solicited or\r
918  *   not, will generate an event.\r
919  */\r
920 __declspec(dllexport)\r
921 int ibv_req_notify_cq(struct ibv_cq *cq, int solicited_only);\r
922 \r
923 /**\r
924  * ibv_create_srq - Creates a SRQ associated with the specified protection\r
925  *   domain.\r
926  * @pd: The protection domain associated with the SRQ.\r
927  * @srq_init_attr: A list of initial attributes required to create the SRQ.\r
928  *\r
929  * srq_attr->max_wr and srq_attr->max_sge are read the determine the\r
930  * requested size of the SRQ, and set to the actual values allocated\r
931  * on return.  If ibv_create_srq() succeeds, then max_wr and max_sge\r
932  * will always be at least as large as the requested values.\r
933  */\r
934 __declspec(dllexport)\r
935 struct ibv_srq *ibv_create_srq(struct ibv_pd *pd,\r
936                                                            struct ibv_srq_init_attr *srq_init_attr);\r
937 \r
938 /**\r
939  * ibv_modify_srq - Modifies the attributes for the specified SRQ.\r
940  * @srq: The SRQ to modify.\r
941  * @srq_attr: On input, specifies the SRQ attributes to modify.  On output,\r
942  *   the current values of selected SRQ attributes are returned.\r
943  * @srq_attr_mask: A bit-mask used to specify which attributes of the SRQ\r
944  *   are being modified.\r
945  *\r
946  * The mask may contain IBV_SRQ_MAX_WR to resize the SRQ and/or\r
947  * IBV_SRQ_LIMIT to set the SRQ's limit and request notification when\r
948  * the number of receives queued drops below the limit.\r
949  */\r
950 __declspec(dllexport)\r
951 int ibv_modify_srq(struct ibv_srq *srq,\r
952                                    struct ibv_srq_attr *srq_attr,\r
953                                    enum ibv_srq_attr_mask srq_attr_mask);\r
954 \r
955 /**\r
956  * ibv_query_srq - Returns the attribute list and current values for the\r
957  *   specified SRQ.\r
958  * @srq: The SRQ to query.\r
959  * @srq_attr: The attributes of the specified SRQ.\r
960  */\r
961 __declspec(dllexport)\r
962 int ibv_query_srq(struct ibv_srq *srq, struct ibv_srq_attr *srq_attr);\r
963 \r
964 /**\r
965  * ibv_destroy_srq - Destroys the specified SRQ.\r
966  * @srq: The SRQ to destroy.\r
967  */\r
968 __declspec(dllexport)\r
969 int ibv_destroy_srq(struct ibv_srq *srq);\r
970 \r
971 /**\r
972  * ibv_post_srq_recv - Posts a list of work requests to the specified SRQ.\r
973  * @srq: The SRQ to post the work request on.\r
974  * @recv_wr: A list of work requests to post on the receive queue.\r
975  * @bad_recv_wr: On an immediate failure, this parameter will reference\r
976  *   the work request that failed to be posted on the QP.\r
977  */\r
978 __declspec(dllexport)\r
979 int ibv_post_srq_recv(struct ibv_srq *srq,\r
980                                           struct ibv_recv_wr *recv_wr,\r
981                                           struct ibv_recv_wr **bad_recv_wr);\r
982 \r
983 /**\r
984  * ibv_create_qp - Create a queue pair.\r
985  */\r
986 __declspec(dllexport)\r
987 struct ibv_qp *ibv_create_qp(struct ibv_pd *pd,\r
988                                                          struct ibv_qp_init_attr *qp_init_attr);\r
989 \r
990 /**\r
991  * ibv_modify_qp - Modify a queue pair.\r
992  */\r
993 __declspec(dllexport)\r
994 int ibv_modify_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr,\r
995                                   enum ibv_qp_attr_mask attr_mask);\r
996 \r
997 /**\r
998  * ibv_query_qp - Returns the attribute list and current values for the\r
999  *   specified QP.\r
1000  * @qp: The QP to query.\r
1001  * @attr: The attributes of the specified QP.\r
1002  * @attr_mask: A bit-mask used to select specific attributes to query.\r
1003  * @init_attr: Additional attributes of the selected QP.\r
1004  *\r
1005  * The qp_attr_mask may be used to limit the query to gathering only the\r
1006  * selected attributes.\r
1007  */\r
1008 __declspec(dllexport)\r
1009 int ibv_query_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr,\r
1010                                  enum ibv_qp_attr_mask attr_mask,\r
1011                                  struct ibv_qp_init_attr *init_attr);\r
1012 \r
1013 /**\r
1014  * ibv_destroy_qp - Destroy a queue pair.\r
1015  */\r
1016 __declspec(dllexport)\r
1017 int ibv_destroy_qp(struct ibv_qp *qp);\r
1018 \r
1019 /**\r
1020  * ibv_post_send - Post a list of work requests to a send queue.\r
1021  *\r
1022  * If IBV_SEND_INLINE flag is set, the data buffers can be reused\r
1023  * immediately after the call returns.\r
1024  */\r
1025 __declspec(dllexport)\r
1026 int ibv_post_send(struct ibv_qp *qp, struct ibv_send_wr *wr,\r
1027                                   struct ibv_send_wr **bad_wr);\r
1028 \r
1029 /**\r
1030  * ibv_post_recv - Post a list of work requests to a receive queue.\r
1031  */\r
1032 __declspec(dllexport)\r
1033 int ibv_post_recv(struct ibv_qp *qp, struct ibv_recv_wr *wr,\r
1034                                   struct ibv_recv_wr **bad_wr);\r
1035 \r
1036 /**\r
1037  * ibv_create_ah - Create an address handle.\r
1038  */\r
1039 __declspec(dllexport)\r
1040 struct ibv_ah *ibv_create_ah(struct ibv_pd *pd, struct ibv_ah_attr *attr);\r
1041 \r
1042 /**\r
1043  * ibv_init_ah_from_wc - Initializes address handle attributes from a\r
1044  *   work completion.\r
1045  * @context: Device context on which the received message arrived.\r
1046  * @port_num: Port on which the received message arrived.\r
1047  * @wc: Work completion associated with the received message.\r
1048  * @grh: References the received global route header.  This parameter is\r
1049  *   ignored unless the work completion indicates that the GRH is valid.\r
1050  * @ah_attr: Returned attributes that can be used when creating an address\r
1051  *   handle for replying to the message.\r
1052  */\r
1053 __declspec(dllexport)\r
1054 int ibv_init_ah_from_wc(struct ibv_context *context, uint8_t port_num,\r
1055                                                 struct ibv_wc *wc, struct ibv_grh *grh,\r
1056                                                 struct ibv_ah_attr *ah_attr);\r
1057 \r
1058 /**\r
1059  * ibv_create_ah_from_wc - Creates an address handle associated with the\r
1060  *   sender of the specified work completion.\r
1061  * @pd: The protection domain associated with the address handle.\r
1062  * @wc: Work completion information associated with a received message.\r
1063  * @grh: References the received global route header.  This parameter is\r
1064  *   ignored unless the work completion indicates that the GRH is valid.\r
1065  * @port_num: The outbound port number to associate with the address.\r
1066  *\r
1067  * The address handle is used to reference a local or global destination\r
1068  * in all UD QP post sends.\r
1069  */\r
1070 __declspec(dllexport)\r
1071 struct ibv_ah *ibv_create_ah_from_wc(struct ibv_pd *pd, struct ibv_wc *wc,\r
1072                                                                          struct ibv_grh *grh, uint8_t port_num);\r
1073 \r
1074 /**\r
1075  * ibv_destroy_ah - Destroy an address handle.\r
1076  */\r
1077 __declspec(dllexport)\r
1078 int ibv_destroy_ah(struct ibv_ah *ah);\r
1079 \r
1080 /**\r
1081  * ibv_attach_mcast - Attaches the specified QP to a multicast group.\r
1082  * @qp: QP to attach to the multicast group.  The QP must be a UD QP.\r
1083  * @gid: Multicast group GID.\r
1084  * @lid: Multicast group LID in host byte order.\r
1085  *\r
1086  * In order to route multicast packets correctly, subnet\r
1087  * administration must have created the multicast group and configured\r
1088  * the fabric appropriately.  The port associated with the specified\r
1089  * QP must also be a member of the multicast group.\r
1090  */\r
1091 __declspec(dllexport)\r
1092 int ibv_attach_mcast(struct ibv_qp *qp, union ibv_gid *gid, uint16_t lid);\r
1093 \r
1094 /**\r
1095  * ibv_detach_mcast - Detaches the specified QP from a multicast group.\r
1096  * @qp: QP to detach from the multicast group.\r
1097  * @gid: Multicast group GID.\r
1098  * @lid: Multicast group LID in host byte order.\r
1099  */\r
1100 __declspec(dllexport)\r
1101 int ibv_detach_mcast(struct ibv_qp *qp, union ibv_gid *gid, uint16_t lid);\r
1102 \r
1103 /**\r
1104  * ibv_node_type_str - Return string describing node_type enum value\r
1105  */\r
1106 __declspec(dllexport)\r
1107 const char *ibv_node_type_str(enum ibv_node_type node_type);\r
1108 \r
1109 /**\r
1110  * ibv_port_state_str - Return string describing port_state enum value\r
1111  */\r
1112 __declspec(dllexport)\r
1113 const char *ibv_port_state_str(enum ibv_port_state port_state);\r
1114 \r
1115 /**\r
1116  * ibv_event_type_str - Return string describing event_type enum value\r
1117  */\r
1118 __declspec(dllexport)\r
1119 const char *ibv_event_type_str(enum ibv_event_type event);\r
1120 \r
1121 /*\r
1122  * Windows specific structures and interfaces\r
1123  */\r
1124 struct ibvw_windata\r
1125 {\r
1126         IWVProvider             *prov;\r
1127         COMP_MANAGER    *comp_mgr;\r
1128 };\r
1129 \r
1130 #define IBVW_WINDATA_VERSION 1\r
1131 \r
1132 __declspec(dllexport)\r
1133 int ibvw_get_windata(struct ibvw_windata *windata, int version);\r
1134 \r
1135 __declspec(dllexport)\r
1136 void ibvw_release_windata(struct ibvw_windata *windata, int version);\r
1137 \r
1138 #ifdef __cplusplus\r
1139 }\r
1140 #endif\r
1141 \r
1142 #endif /* INFINIBAND_VERBS_H */\r