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