Debian Codegraph @

dat/include/dat2/dat.h

raw
1 /*
2 * Copyright (c) 2002-2006, Network Appliance, Inc. All rights reserved.
3 *
4 * This Software is licensed under all of the following licenses:
5 *
6 * 1) under the terms of the "Common Public License 1.0" a copy of which is
7 * in the file LICENSE.txt in the root directory. The license is also
8 * available from the Open Source Initiative, see
9 * http://www.opensource.org/licenses/cpl.php.
10 *
11 * 2) under the terms of the "The BSD License" a copy of which is in the file
12 * LICENSE2.txt in the root directory. The license is also available from
13 * the Open Source Initiative, see
14 * http://www.opensource.org/licenses/bsd-license.php.
15 *
16 * 3) under the terms of the "GNU General Public License (GPL) Version 2" a
17 * copy of which is in the file LICENSE3.txt in the root directory. The
18 * license is also available from the Open Source Initiative, see
19 * http://www.opensource.org/licenses/gpl-license.php.
20 *
21 * Licensee has the right to choose one of the above licenses.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions are
25 * met:
26 *
27 * Redistributions of source code must retain both the above copyright
28 * notice and one of the license notices.
29 *
30 * Redistributions in binary form must reproduce both the above copyright
31 * notice, one of the license notices in the documentation
32 * and/or other materials provided with the distribution.
33 *
34 * Neither the name of Network Appliance, Inc. nor the names of other DAT
35 * Collaborative contributors may be used to endorse or promote
36 * products derived from this software without specific prior written
37 * permission.
38 */
39
40 /***************************************************************
41 *
42 * HEADER: dat.h
43 *
44 * PURPOSE: defines the common DAT API for uDAPL and kDAPL.
45 *
46 * Description: Header file for "DAPL: Direct Access Programming
47 * Library, Version: 2.0"
48 *
49 * Mapping rules:
50 * All global symbols are prepended with DAT_ or dat_
51 * All DAT objects have an 'api' tag which, such as 'EP' or 'LMR'
52 * The method table is in the provider definition structure.
53 *
54 *
55 ***************************************************************/
56 #ifndef _DAT_H_
57 #define _DAT_H_
58
59 #include <dat2/dat_error.h>
60
61 #ifdef __cplusplus
62 extern "C"
63 {
64 #endif
65
66 /* Generic DAT types */
67
68 typedef char * DAT_NAME_PTR; /* Format for ia_name and attributes */
69 #define DAT_NAME_MAX_LENGTH 256
70
71 /*
72 * Used for provider, vendor, transport, hardware-specific attributes
73 * definitions.
74 */
75
76 typedef struct dat_named_attr
77 {
78 const char * name; /* Name of attribute */
79 const char * value; /* Value of attribute */
80 } DAT_NAMED_ATTR;
81
82 typedef enum dat_boolean
83 {
84 DAT_FALSE = 0,
85 DAT_TRUE = 1
86 } DAT_BOOLEAN;
87
88 #ifdef DAT_EXTENSIONS
89 #define DAT_IB_EXTENSION 1
90 #define DAT_IW_EXTENSION 2
91 #endif /* DAT_EXTENSIONS */
92
93 typedef DAT_UINT32 DAT_HA_LB;
94 #define DAT_HA_LB_NONE (DAT_HA_LB)0
95 #define DAT_HA_LB_INTERCOMM (DAT_HA_LB)1
96 #define DAT_HA_LB_INTRACOMM (DAT_HA_LB)2
97
98 typedef union dat_context
99 {
100 DAT_PVOID as_ptr;
101 DAT_UINT64 as_64;
102 DAT_UVERYLONG as_index;
103 } DAT_CONTEXT;
104
105 typedef DAT_CONTEXT DAT_DTO_COOKIE;
106 typedef DAT_CONTEXT DAT_RMR_COOKIE;
107
108 typedef enum dat_completion_flags
109 {
110 /* Completes with notification */
111 DAT_COMPLETION_DEFAULT_FLAG = 0x00,
112 /* Completions suppressed if successful */
113 DAT_COMPLETION_SUPPRESS_FLAG = 0x01,
114 /* Sender controlled notification for recv completion */
115 DAT_COMPLETION_SOLICITED_WAIT_FLAG = 0x02,
116 /* Completions with unsignaled notifications */
117 DAT_COMPLETION_UNSIGNALLED_FLAG = 0x04,
118 /* Do not start processing until all previous RDMA reads complete. */
119 DAT_COMPLETION_BARRIER_FENCE_FLAG = 0x08,
120 /* Only valid for uDAPL as EP attribute for Recv Completion flags.
121 * Waiter unblocking is controlled by the Threshold value of
122 * dat_evd_wait. UNSIGNALLED for RECV is not allowed when EP has
123 * this attribute. */
124 DAT_COMPLETION_EVD_THRESHOLD_FLAG = 0x10,
125 /* Only valid for kDAPL
126 * Do not start processing LMR invalidate until all
127 * previously posted DTOs to the EP Request Queue
128 * have been completed.
129 * The value for LMR Invalidate Fence does not
130 * conflict with uDAPL so it can be extended
131 * to uDAPL usage later.
132 */
133 DAT_COMPLETION_LMR_INVALIDATE_FENCE_FLAG = 0x20
134 } DAT_COMPLETION_FLAGS;
135
136
137 typedef DAT_UINT32 DAT_TIMEOUT; /* microseconds */
138
139 /* timeout = infinity */
140 #define DAT_TIMEOUT_INFINITE ((DAT_TIMEOUT) ~0)
141
142 /* dat handles */
143 typedef DAT_PVOID DAT_HANDLE;
144 typedef DAT_HANDLE DAT_CR_HANDLE;
145 typedef DAT_HANDLE DAT_EP_HANDLE;
146 typedef DAT_HANDLE DAT_EVD_HANDLE;
147 typedef DAT_HANDLE DAT_IA_HANDLE;
148 typedef DAT_HANDLE DAT_LMR_HANDLE;
149 typedef DAT_HANDLE DAT_PSP_HANDLE;
150 typedef DAT_HANDLE DAT_PZ_HANDLE;
151 typedef DAT_HANDLE DAT_RMR_HANDLE;
152 typedef DAT_HANDLE DAT_RSP_HANDLE;
153 typedef DAT_HANDLE DAT_SRQ_HANDLE;
154 typedef DAT_HANDLE DAT_CSP_HANDLE;
155
156 typedef enum dat_dtos
157 {
158 DAT_DTO_SEND,
159 DAT_DTO_RDMA_WRITE,
160 DAT_DTO_RDMA_READ,
161 DAT_DTO_RECEIVE,
162 DAT_DTO_RECEIVE_WITH_INVALIDATE,
163 DAT_DTO_BIND_MW, /* DAT 2.0 review, binds are reported via DTO events */
164 DAT_DTO_LMR_FMR, /* kdat specific */
165 DAT_DTO_LMR_INVALIDATE /* kdat specific */
166 #ifdef DAT_EXTENSIONS
167 ,DAT_DTO_EXTENSION_BASE /* To be used by DAT extensions
168 as a starting point of extension DTOs */
169 #endif /* DAT_EXTENSIONS */
170 } DAT_DTOS;
171
172
173 /* dat NULL handles */
174 #define DAT_HANDLE_NULL ((DAT_HANDLE)NULL)
175
176 typedef DAT_SOCK_ADDR* DAT_IA_ADDRESS_PTR;
177
178 typedef DAT_UINT64 DAT_CONN_QUAL;
179 typedef DAT_UINT64 DAT_PORT_QUAL;
180
181 /* QOS definitions */
182 typedef enum dat_qos
183 {
184 DAT_QOS_BEST_EFFORT = 0x00,
185 DAT_QOS_HIGH_THROUGHPUT = 0x01,
186 DAT_QOS_LOW_LATENCY = 0x02,
187 /* not low latency, nor high throughput */
188 DAT_QOS_ECONOMY = 0x04,
189 /* both low latency and high throughput */
190 DAT_QOS_PREMIUM = 0x08
191 } DAT_QOS;
192
193 /*
194 * FLAGS
195 */
196
197 /* for backward compatibility */
198 #define DAT_CONNECT_MULTIPATH_REQUESTED_FLAG DAT_CONNECT_MULTIPATH_FLAG
199
200 typedef enum dat_connect_flags
201 {
202 DAT_CONNECT_DEFAULT_FLAG = 0x00,
203 DAT_CONNECT_MULTIPATH_REQUESTED_FLAG = 0x01,
204 DAT_CONNECT_MULTIPATH_REQUIRED_FLAG = 0x02
205 } DAT_CONNECT_FLAGS;
206
207 typedef enum dat_close_flags
208 {
209 DAT_CLOSE_ABRUPT_FLAG = 0x00,
210 DAT_CLOSE_GRACEFUL_FLAG = 0x01
211 } DAT_CLOSE_FLAGS;
212
213 #define DAT_CLOSE_DEFAULT DAT_CLOSE_ABRUPT_FLAG
214
215 typedef enum dat_evd_flags
216 {
217 DAT_EVD_SOFTWARE_FLAG = 0x001,
218 DAT_EVD_CR_FLAG = 0x010,
219 DAT_EVD_DTO_FLAG = 0x020,
220 DAT_EVD_CONNECTION_FLAG = 0x040,
221 DAT_EVD_RMR_BIND_FLAG = 0x080,
222 DAT_EVD_ASYNC_FLAG = 0x100,
223
224 /* DAT events only, no software events */
225 DAT_EVD_DEFAULT_FLAG = 0x1F0
226 #ifdef DAT_EXTENSIONS
227 /* To be used by DAT extensions as a starting point for extended evd flags */
228 ,DAT_EVD_EXTENSION_BASE = 0x200
229 #endif /* DAT_EXTENSIONS */
230 } DAT_EVD_FLAGS;
231
232 typedef enum dat_psp_flags
233 {
234 DAT_PSP_CONSUMER_FLAG = 0x00, /* Consumer creates an Endpoint */
235 DAT_PSP_PROVIDER_FLAG = 0x01 /* Provider creates an Endpoint */
236 } DAT_PSP_FLAGS;
237
238 /*
239 * Memory Buffers
240 *
241 * Both LMR and RMR triplets specify 64-bit addresses in the local host's byte
242 * order, even when that exceeds the size of a DAT_PVOID for the host
243 * architecture.
244 */
245
246 /*
247 * Both LMR and RMR Triplets specify 64-bit addresses in the local host
248 * order, even when that exceeds the size of a void pointer for the host
249 * architecture. The DAT_VADDR type that represents addresses is in the
250 * native byte-order of the local host. Helper macros that allow Consumers
251 * to convert DAT_VADDR into various orders that might be useful for
252 * inclusion of RMR Triplets into a payload of a message follow.
253 *
254 * DAT defines the following macros to convert the fields on an RMR Triplet
255 * to defined byte orders to allow their export by the Consumer over wire
256 * protocols. DAT does not define how the two peers decide which byte should be
257 * used.
258 *
259 * DAT_LMRC_TO_LSB(lmrc) returns the supplied LMR Context in ls-byte
260 * order.
261 * DAT_LMRC_TO_MSB(lmrc) returns the supplied LMR Context in ms-byte
262 * order.
263 * DAT_RMRC_TO_LSB(rmrc) returns the supplied RMR Context in ls-byte
264 * order.
265 * DAT_RMRC_TO_MSB(rmrc) returns the supplied RMR Context in ms-byte
266 * order.
267 * DAT_VADDR_TO_LSB(vaddr) returns the supplied Virtual Address in ls-byte
268 * order.
269 * DAT_VADDR_TO_MSB(vaddr) returns the supplied Virtual Address in
270 * ms-byte order.
271 * DAT_VLEN_TO_LSB(vlen) returns the supplied length in ls-byte order.
272 * DAT_VLEN_TO_MSB(vlen) returns the supplied length in ms-byte order.
273 *
274 * Consumers are free to use 64-bit or 32-bit arithmetic for local or remote
275 * memory address and length manipulation in their preferred byte-order. Only the
276 * LMR and RMR Triplets passed to a Provider as part of a Posted DTO are
277 * required to be in 64-bit address and local host order formats. Providers shall
278 * convert RMR_Triplets to a Transport-required wire format.
279 *
280 * For the best performance, Consumers should align each buffer segment to
281 * the boundary specified by the dat_optimal_alignment.
282 */
283 typedef DAT_UINT32 DAT_LMR_CONTEXT;
284 typedef DAT_UINT32 DAT_RMR_CONTEXT;
285
286 typedef DAT_UINT64 DAT_VLEN;
287 typedef DAT_UINT64 DAT_VADDR;
288 typedef DAT_UINT32 DAT_SEG_LENGTH; /* The maximum data segment length */
289
290 typedef struct dat_provider_attr DAT_PROVIDER_ATTR;
291 typedef struct dat_evd_param DAT_EVD_PARAM;
292 typedef struct dat_lmr_param DAT_LMR_PARAM;
293 typedef enum dat_lmr_param_mask DAT_LMR_PARAM_MASK;
294
295 /* It is legal for the Consumer to specify zero for segment_length
296 * of the dat_lmr_triplet. When 0 is specified for the
297 * segment_length then the other two elements of the
298 * dat_lmr_triplet are irrelevant and can be invalid.
299 */
300
301 typedef struct dat_lmr_triplet
302 {
303 DAT_VADDR virtual_address;/* 64-bit address */
304 DAT_SEG_LENGTH segment_length; /* 32-bit length */
305 DAT_LMR_CONTEXT lmr_context; /* 32-bit lmr_context */
306 } DAT_LMR_TRIPLET;
307
308 typedef struct dat_rmr_triplet
309 {
310 DAT_VADDR virtual_address;/* 64-bit address */
311 DAT_SEG_LENGTH segment_length; /* 32-bit length */
312 DAT_RMR_CONTEXT rmr_context; /* 32-bit rmr_context */
313 } DAT_RMR_TRIPLET;
314
315 /* Memory privileges */
316
317 typedef enum dat_mem_priv_flags
318 {
319 DAT_MEM_PRIV_NONE_FLAG = 0x00,
320 DAT_MEM_PRIV_LOCAL_READ_FLAG = 0x01,
321 DAT_MEM_PRIV_REMOTE_READ_FLAG = 0x02,
322 DAT_MEM_PRIV_LOCAL_WRITE_FLAG = 0x10,
323 DAT_MEM_PRIV_REMOTE_WRITE_FLAG = 0x20,
324 DAT_MEM_PRIV_ALL_FLAG = 0x33
325 #ifdef DAT_EXTENSIONS
326 /* To be used by DAT extensions as a starting
327 point of extension memory privileges */
328 ,DAT_MEM_PRIV_EXTENSION_BASE = 0x40
329 #endif /* DAT_EXTENSIONS */
330
331 } DAT_MEM_PRIV_FLAGS;
332
333 /* For backward compatibility with DAT-1.0, memory privileges values are
334 * supported
335 */
336 #define DAT_MEM_PRIV_READ_FLAG (DAT_MEM_PRIV_LOCAL_READ_FLAG | DAT_MEM_PRIV_REMOTE_READ_FLAG)
337 #define DAT_MEM_PRIV_WRITE_FLAG (DAT_MEM_PRIV_LOCAL_WRITE_FLAG | DAT_MEM_PRIV_REMOTE_WRITE_FLAG)
338
339 /* LMR VA types */
340 typedef enum dat_va_type
341 {
342 DAT_VA_TYPE_VA = 0x0,
343 DAT_VA_TYPE_ZB = 0x1
344 } DAT_VA_TYPE;
345
346 /* RMR Arguments & RMR Arguments Mask */
347
348 /* DAPL 2.0 addition */
349 /* Defines RMR protection scope */
350 typedef enum dat_rmr_scope
351 {
352 DAT_RMR_SCOPE_EP, /* bound to at most one EP at a time. */
353 DAT_RMR_SCOPE_PZ, /* bound to a Protection Zone */
354 DAT_RMR_SCOPE_ANY /* Supports all types */
355 } DAT_RMR_SCOPE;
356
357 typedef struct dat_rmr_param
358 {
359 DAT_IA_HANDLE ia_handle;
360 DAT_PZ_HANDLE pz_handle;
361 DAT_LMR_TRIPLET lmr_triplet;
362 DAT_MEM_PRIV_FLAGS mem_priv;
363 DAT_RMR_CONTEXT rmr_context;
364 DAT_RMR_SCOPE rmr_scope;
365 DAT_VA_TYPE va_type;
366 } DAT_RMR_PARAM;
367
368 typedef enum dat_rmr_param_mask
369 {
370 DAT_RMR_FIELD_IA_HANDLE = 0x01,
371 DAT_RMR_FIELD_PZ_HANDLE = 0x02,
372 DAT_RMR_FIELD_LMR_TRIPLET = 0x04,
373 DAT_RMR_FIELD_MEM_PRIV = 0x08,
374 DAT_RMR_FIELD_RMR_CONTEXT = 0x10,
375 DAT_RMR_FIELD_RMR_SCOPE = 0x20,
376 DAT_RMR_FIELD_VA_TYPE = 0x40,
377
378 DAT_RMR_FIELD_ALL = 0x7F
379 } DAT_RMR_PARAM_MASK;
380
381 /* Provider attributes */
382
383 typedef enum dat_iov_ownership
384 {
385 /* Not a modification by the Provider; the Consumer can use anytime. */
386 DAT_IOV_CONSUMER = 0x0,
387 /* Provider does not modify returned IOV DTO on completion. */
388 DAT_IOV_PROVIDER_NOMOD = 0x1,
389 /* Provider can modify IOV DTO on completion; can't trust it. */
390 DAT_IOV_PROVIDER_MOD = 0x2
391 } DAT_IOV_OWNERSHIP;
392
393 typedef enum dat_ep_creator_for_psp
394 {
395 DAT_PSP_CREATES_EP_NEVER, /* Provider never creates Endpoint. */
396 DAT_PSP_CREATES_EP_IFASKED, /* Provider creates Endpoint if asked. */
397 DAT_PSP_CREATES_EP_ALWAYS /* Provider always creates Endpoint. */
398 } DAT_EP_CREATOR_FOR_PSP;
399
400 /* General Interface Adapter attributes. These apply to both udat and kdat. */
401
402 /* To support backwards compatibility for DAPL-1.0 */
403 #define max_rdma_read_per_ep max_rdma_read_per_ep_in
404 #define DAT_IA_FIELD_IA_MAX_DTO_PER_OP DAT_IA_FIELD_IA_MAX_DTO_PER_EP_IN
405
406 /* To support backwards compatibility for DAPL-1.0 & DAPL-1.1 */
407 #define max_mtu_size max_message_size
408
409 /* Query for provider IA extension support */
410 typedef enum dat_extension
411 {
412 DAT_EXTENSION_NONE,/* no extension supported. */
413 DAT_EXTENSION_IB, /* IB extension. */
414 DAT_EXTENSION_IW /* iWARP extension. */
415 } DAT_EXTENSION;
416
417 typedef struct dat_ia_attr DAT_IA_ATTR;
418
419 /* To support backwards compatibility for DAPL-1.0 & DAPL-1.1 */
420 #define DAT_IA_FIELD_IA_MAX_MTU_SIZE DAT_IA_FIELD_IA_MAX_MESSAGE_SIZE
421
422 typedef DAT_UINT64 DAT_IA_ATTR_MASK;
423
424 #define DAT_IA_FIELD_IA_ADAPTER_NAME UINT64_C(0x000000001)
425 #define DAT_IA_FIELD_IA_VENDOR_NAME UINT64_C(0x000000002)
426 #define DAT_IA_FIELD_IA_HARDWARE_MAJOR_VERSION UINT64_C(0x000000004)
427 #define DAT_IA_FIELD_IA_HARDWARE_MINOR_VERSION UINT64_C(0x000000008)
428 #define DAT_IA_FIELD_IA_FIRMWARE_MAJOR_VERSION UINT64_C(0x000000010)
429 #define DAT_IA_FIELD_IA_FIRMWARE_MINOR_VERSION UINT64_C(0x000000020)
430 #define DAT_IA_FIELD_IA_ADDRESS_PTR UINT64_C(0x000000040)
431 #define DAT_IA_FIELD_IA_MAX_EPS UINT64_C(0x000000080)
432 #define DAT_IA_FIELD_IA_MAX_DTO_PER_EP UINT64_C(0x000000100)
433 #define DAT_IA_FIELD_IA_MAX_RDMA_READ_PER_EP_IN UINT64_C(0x000000200)
434 #define DAT_IA_FIELD_IA_MAX_RDMA_READ_PER_EP_OUT UINT64_C(0x000000400)
435 #define DAT_IA_FIELD_IA_MAX_EVDS UINT64_C(0x000000800)
436 #define DAT_IA_FIELD_IA_MAX_EVD_QLEN UINT64_C(0x000001000)
437 #define DAT_IA_FIELD_IA_MAX_IOV_SEGMENTS_PER_DTO UINT64_C(0x000002000)
438 #define DAT_IA_FIELD_IA_MAX_LMRS UINT64_C(0x000004000)
439 #define DAT_IA_FIELD_IA_MAX_LMR_BLOCK_SIZE UINT64_C(0x000008000)
440 #define DAT_IA_FIELD_IA_MAX_LMR_VIRTUAL_ADDRESS UINT64_C(0x000010000)
441 #define DAT_IA_FIELD_IA_MAX_PZS UINT64_C(0x000020000)
442 #define DAT_IA_FIELD_IA_MAX_MESSAGE_SIZE UINT64_C(0x000040000)
443 #define DAT_IA_FIELD_IA_MAX_RDMA_SIZE UINT64_C(0x000080000)
444 #define DAT_IA_FIELD_IA_MAX_RMRS UINT64_C(0x000100000)
445 #define DAT_IA_FIELD_IA_MAX_RMR_TARGET_ADDRESS UINT64_C(0x000200000)
446 #define DAT_IA_FIELD_IA_MAX_SRQS UINT64_C(0x000400000)
447 #define DAT_IA_FIELD_IA_MAX_EP_PER_SRQ UINT64_C(0x000800000)
448 #define DAT_IA_FIELD_IA_MAX_RECV_PER_SRQ UINT64_C(0x001000000)
449 #define DAT_IA_FIELD_IA_MAX_IOV_SEGMENTS_PER_RDMA_READ UINT64_C(0x002000000)
450 #define DAT_IA_FIELD_IA_MAX_IOV_SEGMENTS_PER_RDMA_WRITE UINT64_C(0x004000000)
451 #define DAT_IA_FIELD_IA_MAX_RDMA_READ_IN UINT64_C(0x008000000)
452 #define DAT_IA_FIELD_IA_MAX_RDMA_READ_OUT UINT64_C(0x010000000)
453 #define DAT_IA_FIELD_IA_MAX_RDMA_READ_PER_EP_IN_GUARANTEED UINT64_C(0x020000000)
454 #define DAT_IA_FIELD_IA_MAX_RDMA_READ_PER_EP_OUT_GUARANTEED UINT64_C(0x040000000)
455 #define DAT_IA_FIELD_IA_ZB_SUPPORTED UINT64_C(0x080000000)
456 #define DAT_IA_FIELD_IA_EXTENSIONS_SUPPORTED UINT64_C(0x100000000)
457
458 /* To support backwards compatibility for DAPL-1.0 & DAPL-1.1 */
459 #define DAT_IA_ALL DAT_IA_FIELD_ALL
460 #define DAT_IA_FIELD_NONE UINT64_C(0x0)
461
462 /* Endpoint attributes */
463
464 typedef enum dat_service_type
465 {
466 DAT_SERVICE_TYPE_RC /* reliable connections */
467 #ifdef DAT_EXTENSIONS
468 ,DAT_SERVICE_TYPE_EXTENSION_BASE /* To be used by DAT extensions
469 as a starting point of extension services */
470 #endif /* DAT_EXTENSIONS */
471 } DAT_SERVICE_TYPE;
472
473 typedef struct dat_ep_attr
474 {
475 DAT_SERVICE_TYPE service_type;
476 DAT_SEG_LENGTH max_message_size;
477 DAT_SEG_LENGTH max_rdma_size;
478 DAT_QOS qos;
479 DAT_COMPLETION_FLAGS recv_completion_flags;
480 DAT_COMPLETION_FLAGS request_completion_flags;
481 DAT_COUNT max_recv_dtos;
482 DAT_COUNT max_request_dtos;
483 DAT_COUNT max_recv_iov;
484 DAT_COUNT max_request_iov;
485 DAT_COUNT max_rdma_read_in;
486 DAT_COUNT max_rdma_read_out;
487 DAT_COUNT srq_soft_hw;
488 DAT_COUNT max_rdma_read_iov;
489 DAT_COUNT max_rdma_write_iov;
490 DAT_COUNT ep_transport_specific_count;
491 DAT_NAMED_ATTR * ep_transport_specific;
492 DAT_COUNT ep_provider_specific_count;
493 DAT_NAMED_ATTR * ep_provider_specific;
494 } DAT_EP_ATTR;
495
496 /* Endpoint Parameters */
497
498 /* For backwards compatibility */
499 #define DAT_EP_STATE_ERROR DAT_EP_STATE_DISCONNECTED
500
501 typedef enum dat_ep_state
502 {
503 DAT_EP_STATE_UNCONNECTED, /* quiescent state */
504 DAT_EP_STATE_UNCONFIGURED_UNCONNECTED,
505 DAT_EP_STATE_RESERVED,
506 DAT_EP_STATE_UNCONFIGURED_RESERVED,
507 DAT_EP_STATE_PASSIVE_CONNECTION_PENDING,
508 DAT_EP_STATE_UNCONFIGURED_PASSIVE,
509 DAT_EP_STATE_ACTIVE_CONNECTION_PENDING,
510 DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING,
511 DAT_EP_STATE_UNCONFIGURED_TENTATIVE,
512 DAT_EP_STATE_CONNECTED,
513 DAT_EP_STATE_DISCONNECT_PENDING,
514 DAT_EP_STATE_DISCONNECTED,
515 DAT_EP_STATE_COMPLETION_PENDING,
516 DAT_EP_STATE_CONNECTED_SINGLE_PATH,
517 DAT_EP_STATE_CONNECTED_MULTI_PATH
518 } DAT_EP_STATE;
519
520 typedef struct dat_ep_param
521 {
522 DAT_IA_HANDLE ia_handle;
523 DAT_EP_STATE ep_state;
524 DAT_COMM comm;
525 DAT_IA_ADDRESS_PTR local_ia_address_ptr;
526 DAT_PORT_QUAL local_port_qual;
527 DAT_IA_ADDRESS_PTR remote_ia_address_ptr;
528 DAT_PORT_QUAL remote_port_qual;
529 DAT_PZ_HANDLE pz_handle;
530 DAT_EVD_HANDLE recv_evd_handle;
531 DAT_EVD_HANDLE request_evd_handle;
532 DAT_EVD_HANDLE connect_evd_handle;
533 DAT_SRQ_HANDLE srq_handle;
534 DAT_EP_ATTR ep_attr;
535 } DAT_EP_PARAM;
536
537 typedef DAT_UINT64 DAT_EP_PARAM_MASK;
538 #define DAT_EP_FIELD_IA_HANDLE UINT64_C(0x00000001)
539 #define DAT_EP_FIELD_EP_STATE UINT64_C(0x00000002)
540 #define DAT_EP_FIELD_COMM UINT64_C(0x00000004)
541 #define DAT_EP_FIELD_LOCAL_IA_ADDRESS_PTR UINT64_C(0x00000008)
542 #define DAT_EP_FIELD_LOCAL_PORT_QUAL UINT64_C(0x00000010)
543 #define DAT_EP_FIELD_REMOTE_IA_ADDRESS_PTR UINT64_C(0x00000020)
544 #define DAT_EP_FIELD_REMOTE_PORT_QUAL UINT64_C(0x00000040)
545 #define DAT_EP_FIELD_PZ_HANDLE UINT64_C(0x00000080)
546 #define DAT_EP_FIELD_RECV_EVD_HANDLE UINT64_C(0x00000100)
547 #define DAT_EP_FIELD_REQUEST_EVD_HANDLE UINT64_C(0x00000200)
548 #define DAT_EP_FIELD_CONNECT_EVD_HANDLE UINT64_C(0x00000400)
549 #define DAT_EP_FIELD_SRQ_HANDLE UINT64_C(0x00000800)
550 /* Remainder of values from EP_ATTR, 0x00001000 and up */
551 #define DAT_EP_FIELD_EP_ATTR_SERVICE_TYPE UINT64_C(0x00001000)
552 #define DAT_EP_FIELD_EP_ATTR_MAX_MESSAGE_SIZE UINT64_C(0x00002000)
553 #define DAT_EP_FIELD_EP_ATTR_MAX_RDMA_SIZE UINT64_C(0x00004000)
554 #define DAT_EP_FIELD_EP_ATTR_QOS UINT64_C(0x00008000)
555 #define DAT_EP_FIELD_EP_ATTR_RECV_COMPLETION_FLAGS UINT64_C(0x00010000)
556 #define DAT_EP_FIELD_EP_ATTR_REQUEST_COMPLETION_FLAGS UINT64_C(0x00020000)
557 #define DAT_EP_FIELD_EP_ATTR_MAX_RECV_DTOS UINT64_C(0x00040000)
558 #define DAT_EP_FIELD_EP_ATTR_MAX_REQUEST_DTOS UINT64_C(0x00080000)
559 #define DAT_EP_FIELD_EP_ATTR_MAX_RECV_IOV UINT64_C(0x00100000)
560 #define DAT_EP_FIELD_EP_ATTR_MAX_REQUEST_IOV UINT64_C(0x00200000)
561 #define DAT_EP_FIELD_EP_ATTR_MAX_RDMA_READ_IN UINT64_C(0x00400000)
562 #define DAT_EP_FIELD_EP_ATTR_MAX_RDMA_READ_OUT UINT64_C(0x00800000)
563 #define DAT_EP_FIELD_EP_ATTR_SRQ_SOFT_HW UINT64_C(0x01000000)
564 #define DAT_EP_FIELD_EP_ATTR_MAX_RDMA_READ_IOV UINT64_C(0x02000000)
565 #define DAT_EP_FIELD_EP_ATTR_MAX_RDMA_WRITE_IOV UINT64_C(0x04000000)
566 #define DAT_EP_FIELD_EP_ATTR_NUM_TRANSPORT_ATTR UINT64_C(0x08000000)
567 #define DAT_EP_FIELD_EP_ATTR_TRANSPORT_SPECIFIC_ATTR UINT64_C(0x10000000)
568 #define DAT_EP_FIELD_EP_ATTR_NUM_PROVIDER_ATTR UINT64_C(0x20000000)
569 #define DAT_EP_FIELD_EP_ATTR_PROVIDER_SPECIFIC_ATTR UINT64_C(0x40000000)
570 #define DAT_EP_FIELD_EP_ATTR_ALL UINT64_C(0x7FFFF000)
571
572 #define DAT_EP_FIELD_ALL UINT64_C(0x7FFFFFFF)
573
574 #define DAT_WATERMARK_INFINITE ((DAT_COUNT)~0)
575 #define DAT_HW_DEFAULT DAT_WATERMARK_INFINITE
576 #define DAT_SRQ_LW_DEFAULT 0x0
577
578 typedef enum dat_srq_state
579 {
580 DAT_SRQ_STATE_ERROR,
581 DAT_SRQ_STATE_OPERATIONAL,
582 DAT_SRQ_STATE_SHUTDOWN
583 } DAT_SRQ_STATE;
584
585 #define DAT_VALUE_UNKNOWN (((DAT_COUNT) ~0)-1)
586
587 typedef struct dat_srq_attr
588 {
589 DAT_COUNT max_recv_dtos;
590 DAT_COUNT max_recv_iov;
591 DAT_COUNT low_watermark;
592 } DAT_SRQ_ATTR;
593
594 typedef struct dat_srq_param
595 {
596 DAT_IA_HANDLE ia_handle;
597 DAT_SRQ_STATE srq_state;
598 DAT_PZ_HANDLE pz_handle;
599 DAT_COUNT max_recv_dtos;
600 DAT_COUNT max_recv_iov;
601 DAT_COUNT low_watermark;
602 DAT_COUNT available_dto_count;
603 DAT_COUNT outstanding_dto_count;
604 } DAT_SRQ_PARAM;
605
606 typedef enum dat_srq_param_mask
607 {
608 DAT_SRQ_FIELD_IA_HANDLE = 0x001,
609 DAT_SRQ_FIELD_SRQ_STATE = 0x002,
610 DAT_SRQ_FIELD_PZ_HANDLE = 0x004,
611 DAT_SRQ_FIELD_MAX_RECV_DTO = 0x008,
612 DAT_SRQ_FIELD_MAX_RECV_IOV = 0x010,
613 DAT_SRQ_FIELD_LOW_WATERMARK = 0x020,
614 DAT_SRQ_FIELD_AVAILABLE_DTO_COUNT = 0x040,
615 DAT_SRQ_FIELD_OUTSTANDING_DTO_COUNT = 0x080,
616
617 DAT_SRQ_FIELD_ALL = 0x0FF
618 } DAT_SRQ_PARAM_MASK;
619
620 /* PZ Parameters */
621
622 typedef struct dat_pz_param
623 {
624 DAT_IA_HANDLE ia_handle;
625 } DAT_PZ_PARAM;
626
627 typedef enum dat_pz_param_mask
628 {
629 DAT_PZ_FIELD_IA_HANDLE = 0x01,
630
631 DAT_PZ_FIELD_ALL = 0x01
632 } DAT_PZ_PARAM_MASK;
633
634 /* PSP Parameters */
635
636 typedef struct dat_psp_param
637 {
638 DAT_IA_HANDLE ia_handle;
639 DAT_CONN_QUAL conn_qual;
640 DAT_EVD_HANDLE evd_handle;
641 DAT_PSP_FLAGS psp_flags;
642 } DAT_PSP_PARAM;
643
644 typedef enum dat_psp_param_mask
645 {
646 DAT_PSP_FIELD_IA_HANDLE = 0x01,
647 DAT_PSP_FIELD_CONN_QUAL = 0x02,
648 DAT_PSP_FIELD_EVD_HANDLE = 0x04,
649 DAT_PSP_FIELD_PSP_FLAGS = 0x08,
650
651 DAT_PSP_FIELD_ALL = 0x0F
652 } DAT_PSP_PARAM_MASK;
653
654 /* RSP Parameters */
655
656 typedef struct dat_rsp_param
657 {
658 DAT_IA_HANDLE ia_handle;
659 DAT_CONN_QUAL conn_qual;
660 DAT_EVD_HANDLE evd_handle;
661 DAT_EP_HANDLE ep_handle;
662 } DAT_RSP_PARAM;
663
664 typedef enum dat_rsp_param_mask
665 {
666 DAT_RSP_FIELD_IA_HANDLE = 0x01,
667 DAT_RSP_FIELD_CONN_QUAL = 0x02,
668 DAT_RSP_FIELD_EVD_HANDLE = 0x04,
669 DAT_RSP_FIELD_EP_HANDLE = 0x08,
670
671 DAT_RSP_FIELD_ALL = 0x0F
672 } DAT_RSP_PARAM_MASK;
673
674 /* CSP Parameters */
675 typedef struct dat_csp_param
676 {
677 DAT_IA_HANDLE ia_handle;
678 DAT_COMM *comm;
679 DAT_IA_ADDRESS_PTR address_ptr;
680 DAT_EVD_HANDLE evd_handle;
681 } DAT_CSP_PARAM;
682
683 typedef enum dat_csp_param_mask
684 {
685 DAT_CSP_FIELD_IA_HANDLE = 0x01,
686 DAT_CSP_FIELD_COMM = 0x02,
687 DAT_CSP_FIELD_IA_ADDRESS = 0x04,
688 DAT_CSP_FIELD_EVD_HANDLE = 0x08,
689
690 DAT_CSP_FIELD_ALL = 0x0F
691 } DAT_CSP_PARAM_MASK;
692
693 /* Connection Request Parameters.
694 *
695 * The Connection Request does not provide Remote Endpoint attributes.
696 * If a local Consumer needs this information, the remote Consumer should
697 * encode it into Private Data.
698 */
699
700 typedef struct dat_cr_param
701 {
702 /* Remote IA whose Endpoint requested the connection. */
703 DAT_IA_ADDRESS_PTR remote_ia_address_ptr;
704
705 /* Port qualifier of the remote Endpoint of the requested connection.*/
706 DAT_PORT_QUAL remote_port_qual;
707
708 /* Size of the Private Data. */
709 DAT_COUNT private_data_size;
710
711 /* Pointer to the Private Data passed by remote side in the Connection
712 * Request.
713 */
714 DAT_PVOID private_data;
715 /* The local Endpoint provided by the Service Point for the requested
716 * connection. It is the only Endpoint that can accept a Connection
717 * Request on this Service Point. The value DAT_HANDLE_NULL
718 * represents that there is no associated local Endpoint for the
719 * requested connection.
720 */
721 DAT_EP_HANDLE local_ep_handle;
722 } DAT_CR_PARAM;
723
724 typedef enum dat_cr_param_mask
725 {
726 DAT_CR_FIELD_REMOTE_IA_ADDRESS_PTR = 0x01,
727 DAT_CR_FIELD_REMOTE_PORT_QUAL = 0x02,
728 DAT_CR_FIELD_PRIVATE_DATA_SIZE = 0x04,
729 DAT_CR_FIELD_PRIVATE_DATA = 0x08,
730 DAT_CR_FIELD_LOCAL_EP_HANDLE = 0x10,
731
732 DAT_CR_FIELD_ALL = 0x1F
733 } DAT_CR_PARAM_MASK;
734
735 /************************** Events ******************************/
736
737 /* Completion status flags */
738
739 /* DTO completion status */
740
741 /* For backwards compatibility */
742 #define DAT_DTO_LENGTH_ERROR DAT_DTO_ERR_LOCAL_LENGTH
743 #define DAT_DTO_FAILURE DAT_DTO_ERR_FLUSHED
744
745 typedef enum dat_dto_completion_status
746 {
747 DAT_DTO_SUCCESS = 0,
748 DAT_DTO_ERR_FLUSHED = 1,
749 DAT_DTO_ERR_LOCAL_LENGTH = 2,
750 DAT_DTO_ERR_LOCAL_EP = 3,
751 DAT_DTO_ERR_LOCAL_PROTECTION = 4,
752 DAT_DTO_ERR_BAD_RESPONSE = 5,
753 DAT_DTO_ERR_REMOTE_ACCESS = 6,
754 DAT_DTO_ERR_REMOTE_RESPONDER = 7,
755 DAT_DTO_ERR_TRANSPORT = 8,
756 DAT_DTO_ERR_RECEIVER_NOT_READY = 9,
757 DAT_DTO_ERR_PARTIAL_PACKET = 10,
758 DAT_RMR_OPERATION_FAILED = 11,
759 DAT_DTO_ERR_LOCAL_MM_ERROR = 12 /* kdat specific */
760 } DAT_DTO_COMPLETION_STATUS;
761
762 /* RMR completion status */
763
764 /* For backwards compatibility */
765 #define DAT_RMR_BIND_SUCCESS DAT_DTO_SUCCESS
766 #define DAT_RMR_BIND_FAILURE DAT_DTO_ERR_FLUSHED
767
768 /* RMR completion status */
769 #define DAT_RMR_BIND_COMPLETION_STATUS DAT_DTO_COMPLETION_STATUS
770
771 /* Completion group structs (six total) */
772
773 /* DTO completion event data */
774 /* transfered_length is not defined if status is not DAT_SUCCESS */
775 /* invalidate_flag and rmr_context are not defined if status is not DAT_SUCCESS */
776
777 typedef struct dat_dto_completion_event_data
778 {
779 DAT_EP_HANDLE ep_handle;
780 DAT_DTO_COOKIE user_cookie;
781 DAT_DTO_COMPLETION_STATUS status;
782 DAT_SEG_LENGTH transfered_length;
783 DAT_DTOS operation;
784 DAT_RMR_CONTEXT rmr_context;
785 } DAT_DTO_COMPLETION_EVENT_DATA;
786
787 /* RMR bind completion event data */
788 typedef struct dat_rmr_bind_completion_event_data
789 {
790 DAT_RMR_HANDLE rmr_handle;
791 DAT_RMR_COOKIE user_cookie;
792 DAT_RMR_BIND_COMPLETION_STATUS status;
793 } DAT_RMR_BIND_COMPLETION_EVENT_DATA;
794
795 typedef union dat_sp_handle
796 {
797 DAT_RSP_HANDLE rsp_handle;
798 DAT_PSP_HANDLE psp_handle;
799 DAT_CSP_HANDLE csp_handle;
800 } DAT_SP_HANDLE;
801
802 /* Connection Request Arrival event data */
803 typedef struct dat_cr_arrival_event_data
804 {
805 /* Handle to the Service Point that received the Connection Request
806 * from the remote side. If the Service Point was Reserved, sp_handle is
807 * DAT_HANDLE_NULL because the reserved Service Point is
808 * automatically destroyed upon generating this event. Can be PSP,
809 * CSP, or RSP.
810 */
811 DAT_SP_HANDLE sp_handle;
812
813 /* Address of the IA on which the Connection Request arrived. */
814 DAT_IA_ADDRESS_PTR local_ia_address_ptr;
815
816 /* Connection Qualifier of the IA on which the Service Point received a
817 * Connection Request.
818 */
819 DAT_CONN_QUAL conn_qual;
820
821 /* The Connection Request instance created by a Provider for the
822 * arrived Connection Request. Consumers can find out private_data
823 * passed by a remote Consumer from cr_handle. It is up to a Consumer
824 * to dat_cr_accept or dat_cr_reject of the Connection Request.
825 */
826 DAT_CR_HANDLE cr_handle;
827
828 /* The binary indicator whether the arrived privata data was trancated
829 * or not.
830 * The default value of 0 means not truncation of received private data. */
831 DAT_BOOLEAN truncate_flag;
832
833 } DAT_CR_ARRIVAL_EVENT_DATA;
834
835
836 /* Connection event data */
837 typedef struct dat_connection_event_data
838 {
839 DAT_EP_HANDLE ep_handle;
840 DAT_COUNT private_data_size;
841 DAT_PVOID private_data;
842 } DAT_CONNECTION_EVENT_DATA;
843
844 /* Async Error event data */
845
846 /* For unaffiliated asynchronous event dat_handle is ia_handle. For
847 * Endpoint affiliated asynchronous event dat_handle is ep_handle. For
848 * EVD affiliated asynchronous event dat_handle is evd_handle. For SRQ
849 * affiliated asynchronous event dat_handle is srq_handle. For Memory
850 * affiliated asynchronous event dat_handle is either lmr_handle,
851 * rmr_handle or pz_handle.
852 */
853 typedef struct dat_asynch_error_event_data
854 {
855 DAT_HANDLE dat_handle; /* either IA, EP, EVD, SRQ, */
856 /* LMR, RMR, or PZ handle */
857 DAT_COUNT reason; /* object specific */
858 } DAT_ASYNCH_ERROR_EVENT_DATA;
859
860 /* The reason is object type specific and its values are defined below. */
861 typedef enum ia_async_error_reason
862 {
863 DAT_IA_CATASTROPHIC_ERROR,
864 DAT_IA_OTHER_ERROR
865 } DAT_IA_ASYNC_ERROR_REASON;
866
867 typedef enum ep_async_error_reason
868 {
869 DAT_EP_TRANSFER_TO_ERROR,
870 DAT_EP_OTHER_ERROR,
871 DAT_SRQ_SOFT_HIGH_WATERMARK_EVENT
872 } DAT_EP_ASYNC_ERROR_REASON;
873
874 typedef enum evd_async_error_reason
875 {
876 DAT_EVD_OVERFLOW_ERROR,
877 DAT_EVD_OTHER_ERROR
878 } DAT_EVD_ASYNC_ERROR_REASON;
879
880 typedef enum srq_async_error_reason
881 {
882 DAT_SRQ_TRANSFER_TO_ERROR,
883 DAT_SRQ_OTHER_ERROR,
884 DAT_SRQ_LOW_WATERMARK_EVENT
885 } DAT_SRQ_ASYNC_ERROR_REASON;
886
887 typedef enum lmr_async_error_reason
888 {
889 DAT_LMR_OTHER_ERROR
890 } DAT_LMR_ASYNC_ERROR_REASON;
891
892 typedef enum rmr_async_error_reason
893 {
894 DAT_RMR_OTHER_ERROR
895 } DAT_RMR_ASYNC_ERROR_REASON;
896
897 typedef enum pz_async_error_reason
898 {
899 DAT_PZ_OTHER_ERROR
900 } DAT_PZ_ASYNC_ERROR_REASON;
901
902 /* Software event data */
903 typedef struct dat_software_event_data
904 {
905 DAT_PVOID pointer;
906 } DAT_SOFTWARE_EVENT_DATA;
907
908 typedef enum dat_event_number
909 {
910 DAT_DTO_COMPLETION_EVENT = 0x00001,
911 DAT_RMR_BIND_COMPLETION_EVENT = 0x01001,
912 DAT_CONNECTION_REQUEST_EVENT = 0x02001,
913 DAT_CONNECTION_EVENT_ESTABLISHED = 0x04001,
914 DAT_CONNECTION_EVENT_PEER_REJECTED = 0x04002,
915 DAT_CONNECTION_EVENT_NON_PEER_REJECTED = 0x04003,
916 DAT_CONNECTION_EVENT_ACCEPT_COMPLETION_ERROR = 0x04004,
917 DAT_CONNECTION_EVENT_DISCONNECTED = 0x04005,
918 DAT_CONNECTION_EVENT_BROKEN = 0x04006,
919 DAT_CONNECTION_EVENT_TIMED_OUT = 0x04007,
920 DAT_CONNECTION_EVENT_UNREACHABLE = 0x04008,
921 DAT_ASYNC_ERROR_EVD_OVERFLOW = 0x08001,
922 DAT_ASYNC_ERROR_IA_CATASTROPHIC = 0x08002,
923 DAT_ASYNC_ERROR_EP_BROKEN = 0x08003,
924 DAT_ASYNC_ERROR_TIMED_OUT = 0x08004,
925 DAT_ASYNC_ERROR_PROVIDER_INTERNAL_ERROR = 0x08005,
926 DAT_HA_DOWN_TO_1 = 0x08101,
927 DAT_HA_UP_TO_MULTI_PATH = 0x08102,
928
929 DAT_SOFTWARE_EVENT = 0x10001
930 #ifdef DAT_EXTENSIONS
931 ,DAT_EXTENSION_EVENT = 0x20000,
932 DAT_IB_EXTENSION_RANGE_BASE = 0x40000,
933 DAT_IW_EXTENSION_RANGE_BASE = 0x80000
934 #endif /* DAT_EXTENSIONS */
935
936 } DAT_EVENT_NUMBER;
937
938 /* Union for event Data */
939
940 typedef union dat_event_data
941 {
942 DAT_DTO_COMPLETION_EVENT_DATA dto_completion_event_data;
943 DAT_RMR_BIND_COMPLETION_EVENT_DATA rmr_completion_event_data;
944 DAT_CR_ARRIVAL_EVENT_DATA cr_arrival_event_data;
945 DAT_CONNECTION_EVENT_DATA connect_event_data;
946 DAT_ASYNCH_ERROR_EVENT_DATA asynch_error_event_data;
947 DAT_SOFTWARE_EVENT_DATA software_event_data;
948 } DAT_EVENT_DATA;
949
950 /* Event struct that holds all event information */
951
952 typedef struct dat_event
953 {
954 DAT_EVENT_NUMBER event_number;
955 DAT_EVD_HANDLE evd_handle;
956 DAT_EVENT_DATA event_data;
957 DAT_UINT64 event_extension_data[8];
958 } DAT_EVENT;
959
960 /* Provider/registration info */
961
962 typedef struct dat_provider_info
963 {
964 char ia_name[DAT_NAME_MAX_LENGTH];
965 DAT_UINT32 dapl_version_major;
966 DAT_UINT32 dapl_version_minor;
967 DAT_BOOLEAN is_thread_safe;
968 } DAT_PROVIDER_INFO;
969
970 /***************************************************************
971 *
972 * FUNCTION PROTOTYPES
973 ***************************************************************/
974
975 /*
976 * IA functions
977 *
978 * Note that there are actual 'dat_ia_open' and 'dat_ia_close'
979 * functions, it is not just a re-directing #define. That is
980 * because the functions may have to ensure that the provider
981 * library is loaded before it can call it, and may choose to
982 * unload the library after the last close.
983 */
984
985 extern DAT_RETURN DAT_API dat_ia_openv (
986 IN const DAT_NAME_PTR, /* provider */
987 IN DAT_COUNT, /* asynch_evd_min_qlen */
988 INOUT DAT_EVD_HANDLE *, /* asynch_evd_handle */
989 OUT DAT_IA_HANDLE *, /* ia_handle */
990 IN DAT_UINT32, /* dat major version number */
991 IN DAT_UINT32, /* dat minor version number */
992 IN DAT_BOOLEAN); /* dat thread safety */
993
994 #define dat_ia_open(name, qlen, async_evd, ia) \
995 dat_ia_openv((name), (qlen), (async_evd), (ia), \
996 DAT_VERSION_MAJOR, DAT_VERSION_MINOR, \
997 DAT_THREADSAFE)
998
999 extern DAT_RETURN DAT_API dat_ia_query (
1000 IN DAT_IA_HANDLE, /* ia_handle */
1001 OUT DAT_EVD_HANDLE *, /* async_evd_handle */
1002 IN DAT_IA_ATTR_MASK, /* ia_attr_mask */
1003 OUT DAT_IA_ATTR *, /* ia_attr */
1004 IN DAT_PROVIDER_ATTR_MASK, /* provider_attr_mask */
1005 OUT DAT_PROVIDER_ATTR * ); /* provider_attr */
1006
1007 extern DAT_RETURN DAT_API dat_ia_close (
1008 IN DAT_IA_HANDLE, /* ia_handle */
1009 IN DAT_CLOSE_FLAGS ); /* close_flags */
1010
1011 /* helper functions */
1012
1013 extern DAT_RETURN DAT_API dat_set_consumer_context (
1014 IN DAT_HANDLE, /* dat_handle */
1015 IN DAT_CONTEXT); /* context */
1016
1017 extern DAT_RETURN DAT_API dat_get_consumer_context (
1018 IN DAT_HANDLE, /* dat_handle */
1019 OUT DAT_CONTEXT * ); /* context */
1020
1021 extern DAT_RETURN DAT_API dat_get_handle_type (
1022 IN DAT_HANDLE, /* dat_handle */
1023 OUT DAT_HANDLE_TYPE * ); /* handle_type */
1024
1025 /* CR functions */
1026
1027 extern DAT_RETURN DAT_API dat_cr_query (
1028 IN DAT_CR_HANDLE, /* cr_handle */
1029 IN DAT_CR_PARAM_MASK, /* cr_param_mask */
1030 OUT DAT_CR_PARAM * ); /* cr_param */
1031
1032 extern DAT_RETURN DAT_API dat_cr_accept (
1033 IN DAT_CR_HANDLE, /* cr_handle */
1034 IN DAT_EP_HANDLE, /* ep_handle */
1035 IN DAT_COUNT, /* private_data_size */
1036 IN const DAT_PVOID ); /* private_data */
1037
1038 extern DAT_RETURN DAT_API dat_cr_reject (
1039 IN DAT_CR_HANDLE, /* cr_handle */
1040 IN DAT_COUNT, /* private_data_size */
1041 IN const DAT_PVOID ); /* private_data */
1042
1043 /* For DAT-1.1 and above, this function is defined for both uDAPL and
1044 * kDAPL. For DAT-1.0, it is only defined for uDAPL.
1045 */
1046 extern DAT_RETURN DAT_API dat_cr_handoff (
1047 IN DAT_CR_HANDLE, /* cr_handle */
1048 IN DAT_CONN_QUAL); /* handoff */
1049
1050 /* EVD functions */
1051
1052 extern DAT_RETURN DAT_API dat_evd_resize (
1053 IN DAT_EVD_HANDLE, /* evd_handle */
1054 IN DAT_COUNT ); /* evd_min_qlen */
1055
1056 extern DAT_RETURN DAT_API dat_evd_post_se (
1057 IN DAT_EVD_HANDLE, /* evd_handle */
1058 IN const DAT_EVENT * ); /* event */
1059
1060 extern DAT_RETURN DAT_API dat_evd_dequeue (
1061 IN DAT_EVD_HANDLE, /* evd_handle */
1062 OUT DAT_EVENT * ); /* event */
1063
1064 extern DAT_RETURN DAT_API dat_evd_query (
1065 IN DAT_EVD_HANDLE, /* evd_handle */
1066 IN DAT_EVD_PARAM_MASK, /* evd_param_mask */
1067 OUT DAT_EVD_PARAM * ); /* evd_param */
1068
1069 extern DAT_RETURN DAT_API dat_evd_free (
1070 IN DAT_EVD_HANDLE ); /* evd_handle */
1071
1072 /* EP functions */
1073
1074 extern DAT_RETURN DAT_API dat_ep_create (
1075 IN DAT_IA_HANDLE, /* ia_handle */
1076 IN DAT_PZ_HANDLE, /* pz_handle */
1077 IN DAT_EVD_HANDLE, /* recv_completion_evd_handle */
1078 IN DAT_EVD_HANDLE, /* request_completion_evd_handle */
1079 IN DAT_EVD_HANDLE, /* connect_evd_handle */
1080 IN const DAT_EP_ATTR *, /* ep_attributes */
1081 OUT DAT_EP_HANDLE * ); /* ep_handle */
1082
1083 extern DAT_RETURN DAT_API dat_ep_query (
1084 IN DAT_EP_HANDLE, /* ep_handle */
1085 IN DAT_EP_PARAM_MASK, /* ep_param_mask */
1086 OUT DAT_EP_PARAM * ); /* ep_param */
1087
1088 extern DAT_RETURN DAT_API dat_ep_modify (
1089 IN DAT_EP_HANDLE, /* ep_handle */
1090 IN DAT_EP_PARAM_MASK, /* ep_param_mask */
1091 IN const DAT_EP_PARAM * ); /* ep_param */
1092
1093 extern DAT_RETURN DAT_API dat_ep_connect (
1094 IN DAT_EP_HANDLE, /* ep_handle */
1095 IN DAT_IA_ADDRESS_PTR, /* remote_ia_address */
1096 IN DAT_CONN_QUAL, /* remote_conn_qual */
1097 IN DAT_TIMEOUT, /* timeout */
1098 IN DAT_COUNT, /* private_data_size */
1099 IN const DAT_PVOID, /* private_data */
1100 IN DAT_QOS, /* quality_of_service */
1101 IN DAT_CONNECT_FLAGS ); /* connect_flags */
1102
1103 extern DAT_RETURN DAT_API dat_ep_dup_connect (
1104 IN DAT_EP_HANDLE, /* ep_handle */
1105 IN DAT_EP_HANDLE, /* ep_dup_handle */
1106 IN DAT_TIMEOUT, /* timeout */
1107 IN DAT_COUNT, /* private_data_size */
1108 IN const DAT_PVOID, /* private_data */
1109 IN DAT_QOS); /* quality_of_service */
1110
1111 extern DAT_RETURN DAT_API dat_ep_common_connect (
1112 IN DAT_EP_HANDLE, /* ep_handle */
1113 IN DAT_IA_ADDRESS_PTR, /* remote_ia_address */
1114 IN DAT_TIMEOUT, /* timeout */
1115 IN DAT_COUNT, /* private_data_size */
1116 IN const DAT_PVOID ); /* private_data */
1117
1118 extern DAT_RETURN DAT_API dat_ep_disconnect (
1119 IN DAT_EP_HANDLE, /* ep_handle */
1120 IN DAT_CLOSE_FLAGS ); /* close_flags */
1121
1122 extern DAT_RETURN DAT_API dat_ep_post_send (
1123 IN DAT_EP_HANDLE, /* ep_handle */
1124 IN DAT_COUNT, /* num_segments */
1125 IN DAT_LMR_TRIPLET *, /* local_iov */
1126 IN DAT_DTO_COOKIE, /* user_cookie */
1127 IN DAT_COMPLETION_FLAGS ); /* completion_flags */
1128
1129 extern DAT_RETURN DAT_API dat_ep_post_send_with_invalidate (
1130 IN DAT_EP_HANDLE, /* ep_handle */
1131 IN DAT_COUNT, /* num_segments */
1132 IN DAT_LMR_TRIPLET *, /* local_iov */
1133 IN DAT_DTO_COOKIE, /* user_cookie */
1134 IN DAT_COMPLETION_FLAGS, /* completion_flags */
1135 IN DAT_BOOLEAN, /* invalidate_flag */
1136 IN DAT_RMR_CONTEXT ); /* RMR to invalidate */
1137
1138 extern DAT_RETURN DAT_API dat_ep_post_recv (
1139 IN DAT_EP_HANDLE, /* ep_handle */
1140 IN DAT_COUNT, /* num_segments */
1141 IN DAT_LMR_TRIPLET *, /* local_iov */
1142 IN DAT_DTO_COOKIE, /* user_cookie */
1143 IN DAT_COMPLETION_FLAGS ); /* completion_flags */
1144
1145 extern DAT_RETURN DAT_API dat_ep_post_rdma_read (
1146 IN DAT_EP_HANDLE, /* ep_handle */
1147 IN DAT_COUNT, /* num_segments */
1148 IN DAT_LMR_TRIPLET *, /* local_iov */
1149 IN DAT_DTO_COOKIE, /* user_cookie */
1150 IN const DAT_RMR_TRIPLET *,/* remote_iov */
1151 IN DAT_COMPLETION_FLAGS ); /* completion_flags */
1152
1153 extern DAT_RETURN DAT_API dat_ep_post_rdma_read_to_rmr (
1154 IN DAT_EP_HANDLE, /* ep_handle */
1155 IN const DAT_RMR_TRIPLET *, /* local_iov */
1156 IN DAT_DTO_COOKIE, /* user_cookie */
1157 IN const DAT_RMR_TRIPLET *,/* remote_iov */
1158 IN DAT_COMPLETION_FLAGS ); /* completion_flags */
1159
1160 extern DAT_RETURN DAT_API dat_ep_post_rdma_write (
1161 IN DAT_EP_HANDLE, /* ep_handle */
1162 IN DAT_COUNT, /* num_segments */
1163 IN DAT_LMR_TRIPLET *, /* local_iov */
1164 IN DAT_DTO_COOKIE, /* user_cookie */
1165 IN const DAT_RMR_TRIPLET *,/* remote_iov */
1166 IN DAT_COMPLETION_FLAGS ); /* completion_flags */
1167
1168 extern DAT_RETURN DAT_API dat_ep_get_status (
1169 IN DAT_EP_HANDLE, /* ep_handle */
1170 OUT DAT_EP_STATE *, /* ep_state */
1171 OUT DAT_BOOLEAN *, /* recv_idle */
1172 OUT DAT_BOOLEAN * ); /* request_idle */
1173
1174 extern DAT_RETURN DAT_API dat_ep_free (
1175 IN DAT_EP_HANDLE); /* ep_handle */
1176
1177 extern DAT_RETURN DAT_API dat_ep_reset (
1178 IN DAT_EP_HANDLE); /* ep_handle */
1179
1180 extern DAT_RETURN DAT_API dat_ep_create_with_srq (
1181 IN DAT_IA_HANDLE, /* ia_handle */
1182 IN DAT_PZ_HANDLE, /* pz_handle */
1183 IN DAT_EVD_HANDLE, /* recv_evd_handle */
1184 IN DAT_EVD_HANDLE, /* request_evd_handle */
1185 IN DAT_EVD_HANDLE, /* connect_evd_handle */
1186 IN DAT_SRQ_HANDLE, /* srq_handle */
1187 IN const DAT_EP_ATTR *, /* ep_attributes */
1188 OUT DAT_EP_HANDLE *); /* ep_handle */
1189
1190 extern DAT_RETURN DAT_API dat_ep_recv_query (
1191 IN DAT_EP_HANDLE, /* ep_handle */
1192 OUT DAT_COUNT *, /* nbufs_allocated */
1193 OUT DAT_COUNT *); /* bufs_alloc_span */
1194
1195 extern DAT_RETURN DAT_API dat_ep_set_watermark (
1196 IN DAT_EP_HANDLE, /* ep_handle */
1197 IN DAT_COUNT, /* soft_high_watermark */
1198 IN DAT_COUNT); /* hard_high_watermark */
1199
1200 /* LMR functions */
1201
1202 extern DAT_RETURN DAT_API dat_lmr_free (
1203 IN DAT_LMR_HANDLE); /* lmr_handle */
1204
1205 /* Non-coherent memory functions */
1206
1207 extern DAT_RETURN DAT_API dat_lmr_sync_rdma_read (
1208 IN DAT_IA_HANDLE, /* ia_handle */
1209 IN const DAT_LMR_TRIPLET *, /* local_segments */
1210 IN DAT_VLEN); /* num_segments */
1211
1212 extern DAT_RETURN DAT_API dat_lmr_sync_rdma_write (
1213 IN DAT_IA_HANDLE, /* ia_handle */
1214 IN const DAT_LMR_TRIPLET *, /* local_segments */
1215 IN DAT_VLEN); /* num_segments */
1216
1217 /* RMR functions */
1218
1219 extern DAT_RETURN DAT_API dat_rmr_create (
1220 IN DAT_PZ_HANDLE, /* pz_handle */
1221 OUT DAT_RMR_HANDLE *); /* rmr_handle */
1222
1223 extern DAT_RETURN DAT_API dat_rmr_create_for_ep (
1224 IN DAT_PZ_HANDLE, /* pz_handle */
1225 OUT DAT_RMR_HANDLE *); /* rmr_handle */
1226
1227 extern DAT_RETURN DAT_API dat_rmr_query (
1228 IN DAT_RMR_HANDLE, /* rmr_handle */
1229 IN DAT_RMR_PARAM_MASK, /* rmr_param_mask */
1230 OUT DAT_RMR_PARAM *); /* rmr_param */
1231
1232 extern DAT_RETURN DAT_API dat_rmr_bind (
1233 IN DAT_RMR_HANDLE, /* rmr_handle */
1234 IN DAT_LMR_HANDLE, /* lmr_handle */
1235 IN const DAT_LMR_TRIPLET *,/* lmr_triplet */
1236 IN DAT_MEM_PRIV_FLAGS, /* mem_priv */
1237 IN DAT_VA_TYPE, /* va_type */
1238 IN DAT_EP_HANDLE, /* ep_handle */
1239 IN DAT_RMR_COOKIE, /* user_cookie */
1240 IN DAT_COMPLETION_FLAGS, /* completion_flags */
1241 OUT DAT_RMR_CONTEXT * ); /* context */
1242
1243 extern DAT_RETURN DAT_API dat_rmr_free (
1244 IN DAT_RMR_HANDLE); /* rmr_handle */
1245
1246 /* PSP functions */
1247
1248 extern DAT_RETURN DAT_API dat_psp_create (
1249 IN DAT_IA_HANDLE, /* ia_handle */
1250 IN DAT_CONN_QUAL, /* conn_qual */
1251 IN DAT_EVD_HANDLE, /* evd_handle */
1252 IN DAT_PSP_FLAGS, /* psp_flags */
1253 OUT DAT_PSP_HANDLE * ); /* psp_handle */
1254
1255 extern DAT_RETURN DAT_API dat_psp_create_any (
1256 IN DAT_IA_HANDLE, /* ia_handle */
1257 OUT DAT_CONN_QUAL *, /* conn_qual */
1258 IN DAT_EVD_HANDLE, /* evd_handle */
1259 IN DAT_PSP_FLAGS, /* psp_flags */
1260 OUT DAT_PSP_HANDLE * ); /* psp_handle */
1261
1262 extern DAT_RETURN DAT_API dat_psp_query (
1263 IN DAT_PSP_HANDLE, /* psp_handle */
1264 IN DAT_PSP_PARAM_MASK, /* psp_param_mask */
1265 OUT DAT_PSP_PARAM * ); /* psp_param */
1266
1267 extern DAT_RETURN DAT_API dat_psp_free (
1268 IN DAT_PSP_HANDLE ); /* psp_handle */
1269
1270 /* RSP functions */
1271
1272 extern DAT_RETURN DAT_API dat_rsp_create (
1273 IN DAT_IA_HANDLE, /* ia_handle */
1274 IN DAT_CONN_QUAL, /* conn_qual */
1275 IN DAT_EP_HANDLE, /* ep_handle */
1276 IN DAT_EVD_HANDLE, /* evd_handle */
1277 OUT DAT_RSP_HANDLE * ); /* rsp_handle */
1278
1279 extern DAT_RETURN DAT_API dat_rsp_query (
1280 IN DAT_RSP_HANDLE, /* rsp_handle */
1281 IN DAT_RSP_PARAM_MASK, /* rsp_param_mask */
1282 OUT DAT_RSP_PARAM * ); /* rsp_param */
1283
1284 extern DAT_RETURN DAT_API dat_rsp_free (
1285 IN DAT_RSP_HANDLE ); /* rsp_handle */
1286
1287 /* CSP functions */
1288
1289 extern DAT_RETURN DAT_API dat_csp_create (
1290 IN DAT_IA_HANDLE, /* ia_handle */
1291 IN DAT_COMM *, /* communicator */
1292 IN DAT_IA_ADDRESS_PTR, /* address */
1293 IN DAT_EVD_HANDLE, /* evd_handle */
1294 OUT DAT_CSP_HANDLE * ); /* csp_handle */
1295
1296 extern DAT_RETURN DAT_API dat_csp_query (
1297 IN DAT_CSP_HANDLE, /* csp_handle */
1298 IN DAT_CSP_PARAM_MASK, /* csp_param_mask */
1299 OUT DAT_CSP_PARAM * ); /* csp_param */
1300
1301 extern DAT_RETURN DAT_API dat_csp_free (
1302 IN DAT_CSP_HANDLE ); /* csp_handle */
1303
1304 /* PZ functions */
1305
1306 extern DAT_RETURN DAT_API dat_pz_create (
1307 IN DAT_IA_HANDLE, /* ia_handle */
1308 OUT DAT_PZ_HANDLE * ); /* pz_handle */
1309
1310 extern DAT_RETURN DAT_API dat_pz_query (
1311 IN DAT_PZ_HANDLE, /* pz_handle */
1312 IN DAT_PZ_PARAM_MASK, /* pz_param_mask */
1313 OUT DAT_PZ_PARAM *); /* pz_param */
1314
1315 extern DAT_RETURN DAT_API dat_pz_free (
1316 IN DAT_PZ_HANDLE ); /* pz_handle */
1317
1318 /* SRQ functions */
1319
1320 extern DAT_RETURN DAT_API dat_srq_create (
1321 IN DAT_IA_HANDLE, /* ia_handle */
1322 IN DAT_PZ_HANDLE, /* pz_handle */
1323 IN DAT_SRQ_ATTR *, /* srq_attr */
1324 OUT DAT_SRQ_HANDLE *); /* srq_handle */
1325
1326 extern DAT_RETURN DAT_API dat_srq_free (
1327 IN DAT_SRQ_HANDLE); /* srq_handle */
1328
1329 extern DAT_RETURN DAT_API dat_srq_post_recv (
1330 IN DAT_SRQ_HANDLE, /* srq_handle */
1331 IN DAT_COUNT, /* num_segments */
1332 IN DAT_LMR_TRIPLET *, /* local_iov */
1333 IN DAT_DTO_COOKIE); /* user_cookie */
1334
1335 extern DAT_RETURN DAT_API dat_srq_query (
1336 IN DAT_SRQ_HANDLE, /* srq_handle */
1337 IN DAT_SRQ_PARAM_MASK, /* srq_param_mask */
1338 OUT DAT_SRQ_PARAM *); /* srq_param */
1339
1340 extern DAT_RETURN DAT_API dat_srq_resize (
1341 IN DAT_SRQ_HANDLE, /* srq_handle */
1342 IN DAT_COUNT); /* srq_max_recv_dto */
1343
1344 extern DAT_RETURN DAT_API dat_srq_set_lw (
1345 IN DAT_SRQ_HANDLE, /* srq_handle */
1346 IN DAT_COUNT); /* low_watermark */
1347
1348 #ifdef DAT_EXTENSIONS
1349 #define DAT_OPEN_EXTENSION_BASE 0x1000
1350 #define DAT_CLOSE_EXTENSION_BASE 0x2000
1351 typedef int DAT_EXTENDED_OP;
1352 extern DAT_RETURN DAT_API dat_extension_op(
1353 IN DAT_HANDLE, /* handle */
1354 IN DAT_EXTENDED_OP, /* operation */
1355 IN ... ); /* args */
1356 #endif
1357
1358 /*
1359 * DAT registry functions.
1360 *
1361 * Note the dat_ia_open and dat_ia_close functions are linked to
1362 * registration code which "redirects" to the appropriate provider.
1363 */
1364 extern DAT_RETURN DAT_API dat_registry_list_providers (
1365 IN DAT_COUNT, /* max_to_return */
1366 OUT DAT_COUNT *, /* entries_returned */
1367 OUT DAT_PROVIDER_INFO *(dat_provider_list[]) ); /* dat_provider_list */
1368
1369 /*
1370 * DAT error functions.
1371 */
1372 extern DAT_RETURN DAT_API dat_strerror (
1373 IN DAT_RETURN, /* dat function return */
1374 OUT const char ** , /* major message string */
1375 OUT const char ** ); /* minor message string */
1376
1377 #ifdef __cplusplus
1378 }
1379 #endif
1380
1381 #endif /* _DAT_H_ */
1382