usr/src/lib/udapl/libdat/include/dat/dat.h

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