/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2002-2004, Network Appliance, Inc. All rights reserved.
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#ifndef _DAT_REDIRECTION_H_
#define _DAT_REDIRECTION_H_

/*
 *
 * HEADER: dat_redirection.h
 *
 * PURPOSE: Defines the common redirection macros
 *
 * Description: Macros to invoke DAPL functions from the dat_registry
 *
 * Mapping rules:
 *      All global symbols are prepended with "DAT_" or "dat_"
 *      All DAT objects have an 'api' tag which, such as 'ep' or 'lmr'
 *      The method table is in the provider definition structure.
 *
 *
 *
 */

#ifdef __cplusplus
extern "C" {
#endif

typedef struct dat_provider DAT_PROVIDER;

#ifndef DAT_HANDLE_TO_PROVIDER

/*
 * A utility macro to fetch the Provider Library for any object
 *
 * An alternate version could be defined for single library systems.
 * it would look something like:
 *      extern const struct dat_ia my_single_ia_provider;
 *      #define DAT_HANDLE_TO_PROVIDER(ignore) &my_single_ia_provider
 *
 * This would allow a good compiler to avoid indirection overhead when
 * making function calls.
 */

#define DAT_HANDLE_TO_PROVIDER(handle) (*(DAT_PROVIDER **)(handle))
#endif

#define DAT_IA_QUERY(ia, evd, ia_msk, ia_ptr, p_msk, p_ptr) \
        (*DAT_HANDLE_TO_PROVIDER(ia)->ia_query_func)(\
                (ia),\
                (evd),\
                (ia_msk),\
                (ia_ptr),\
                (p_msk),\
                (p_ptr))

#define DAT_SET_CONSUMER_CONTEXT(handle, context) \
        (*DAT_HANDLE_TO_PROVIDER(handle)->set_consumer_context_func)(\
                (handle),\
                (context))

#define DAT_GET_CONSUMER_CONTEXT(handle, context) \
        (*DAT_HANDLE_TO_PROVIDER(handle)->get_consumer_context_func)(\
                (handle),\
                (context))

#define DAT_GET_HANDLE_TYPE(handle, handle_type) \
        (*DAT_HANDLE_TO_PROVIDER(handle)->get_handle_type_func)(\
                (handle),\
                (handle_type))

#define DAT_CR_QUERY(cr, mask, param) \
        (*DAT_HANDLE_TO_PROVIDER(cr)->cr_query_func)(\
                (cr),\
                (mask),\
                (param))

#define DAT_CR_ACCEPT(cr, ep, size, pdata) \
        (*DAT_HANDLE_TO_PROVIDER(cr)->cr_accept_func)(\
                (cr),\
                (ep),\
                (size),\
                (pdata))

#define DAT_CR_REJECT(cr) \
        (*DAT_HANDLE_TO_PROVIDER(cr)->cr_reject_func)(\
                (cr))

#define DAT_CR_HANDOFF(cr, qual) \
        (*DAT_HANDLE_TO_PROVIDER(cr)->cr_handoff_func)(\
                (cr),\
                (qual))

#define DAT_EVD_QUERY(evd, mask, param) \
        (*DAT_HANDLE_TO_PROVIDER(evd)->evd_query_func)(\
                (evd),\
                (mask),\
                (param))

#define DAT_EVD_RESIZE(evd, qsize) \
        (*DAT_HANDLE_TO_PROVIDER(evd)->evd_resize_func)(\
                (evd),\
                (qsize))

#define DAT_EVD_POST_SE(evd, event) \
        (*DAT_HANDLE_TO_PROVIDER(evd)->evd_post_se_func)(\
                (evd),\
                (event))

#define DAT_EVD_DEQUEUE(evd, event) \
        (*DAT_HANDLE_TO_PROVIDER(evd)->evd_dequeue_func)(\
                (evd),\
                (event))

#define DAT_EVD_FREE(evd)\
        (*DAT_HANDLE_TO_PROVIDER(evd)->evd_free_func)(\
                (evd))

#define DAT_EP_CREATE(ia, pz, in_evd, out_evd, connect_evd, attr, ep) \
        (*DAT_HANDLE_TO_PROVIDER(ia)->ep_create_func)(\
                (ia),\
                (pz),\
                (in_evd),\
                (out_evd),\
                (connect_evd),\
                (attr),\
                (ep))

#define DAT_EP_CREATE_WITH_SRQ(ia, pz, in_evd, out_evd, connect_evd, srq,\
        attr, ep) \
        (*DAT_HANDLE_TO_PROVIDER(ia)->ep_create_with_srq_func)(\
                (ia),\
                (pz),\
                (in_evd),\
                (out_evd),\
                (connect_evd),\
                (srq),\
                (attr),\
                (ep))

#define DAT_EP_QUERY(ep, mask, param) \
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_query_func)(\
                (ep),\
                (mask),\
                (param))

#define DAT_EP_MODIFY(ep, mask, param) \
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_modify_func)(\
                (ep),\
                (mask),\
                (param))

#define DAT_EP_CONNECT(ep, ia_addr, conn_qual, timeout, psize, pdata,   \
                qos, flags)                                             \
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_connect_func)(\
                (ep),\
                (ia_addr),\
                (conn_qual),\
                (timeout),\
                (psize),\
                (pdata),\
                (qos),\
                (flags))

#define DAT_EP_DUP_CONNECT(ep, dup, timeout, psize, pdata, qos) \
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_dup_connect_func)(\
                (ep),\
                (dup),\
                (timeout),\
                (psize),\
                (pdata),\
                (qos))

#define DAT_EP_DISCONNECT(ep, flags) \
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_disconnect_func)(\
                (ep),\
                (flags))

#define DAT_EP_POST_SEND(ep, size, lbuf, cookie, flags) \
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_post_send_func)(\
                (ep),\
                (size),\
                (lbuf),\
                (cookie),\
                (flags))

#define DAT_EP_POST_RECV(ep, size, lbuf, cookie, flags) \
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_post_recv_func)(\
                (ep),\
                (size),\
                (lbuf),\
                (cookie),\
                (flags))

#define DAT_EP_POST_RDMA_READ(ep, size, lbuf, cookie, rbuf, flags) \
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_post_rdma_read_func)(\
                (ep),\
                (size),\
                (lbuf),\
                (cookie),\
                (rbuf),\
                (flags))

#define DAT_EP_POST_RDMA_WRITE(ep, size, lbuf, cookie, rbuf, flags) \
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_post_rdma_write_func)(\
                (ep),\
                (size),\
                (lbuf),\
                (cookie),\
                (rbuf),\
                (flags))

#define DAT_EP_GET_STATUS(ep, ep_state, recv_idle, request_idle) \
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_get_status_func)(\
                (ep), \
                (ep_state),\
                (recv_idle),\
                (request_idle))

#define DAT_EP_FREE(ep)\
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_free_func)(\
                (ep))

#define DAT_EP_RESET(ep)\
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_reset_func)(\
                (ep))

#define DAT_EP_RECV_QUERY(ep, nbuf_alloc, buf_span) \
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_recv_query_func)(\
                (ep),\
                (nbuf_alloc),\
                (buf_span))

#define DAT_EP_SET_WATERMARK(ep, soft_wm, hard_wm) \
        (*DAT_HANDLE_TO_PROVIDER(ep)->ep_set_watermark_func)(\
                (ep),\
                (soft_wm),\
                (hard_wm))

#define DAT_LMR_QUERY(lmr, mask, param)\
        (*DAT_HANDLE_TO_PROVIDER(lmr)->lmr_query_func)(\
                (lmr),\
                (mask),\
                (param))

#define DAT_LMR_FREE(lmr)\
        (*DAT_HANDLE_TO_PROVIDER(lmr)->lmr_free_func)(\
                (lmr))

#define DAT_LMR_SYNC_RDMA_READ(ia, lbuf, size) \
        (*DAT_HANDLE_TO_PROVIDER(ia)->lmr_sync_rdma_read_func)(\
                (ia), \
                (lbuf), \
                (size))

#define DAT_LMR_SYNC_RDMA_WRITE(ia, lbuf, size) \
        (*DAT_HANDLE_TO_PROVIDER(ia)->lmr_sync_rdma_write_func)(\
                (ia), \
                (lbuf), \
                (size))

#define DAT_RMR_CREATE(pz, rmr) \
        (*DAT_HANDLE_TO_PROVIDER(pz)->rmr_create_func)(\
                (pz),\
                (rmr))

#define DAT_RMR_QUERY(rmr, mask, param) \
        (*DAT_HANDLE_TO_PROVIDER(rmr)->rmr_query_func)(\
                (rmr),\
                (mask),\
                (param))

#define DAT_RMR_BIND(rmr, lmr, mem_priv, ep, cookie, flags, context) \
        (*DAT_HANDLE_TO_PROVIDER(rmr)->rmr_bind_func)(\
                (rmr),\
                (lmr),\
                (mem_priv),\
                (ep),\
                (cookie),\
                (flags),\
                (context))

#define DAT_RMR_FREE(rmr)\
        (*DAT_HANDLE_TO_PROVIDER(rmr)->rmr_free_func)(\
                (rmr))

#define DAT_PSP_CREATE(ia, conn_qual, evd, flags, handle) \
        (*DAT_HANDLE_TO_PROVIDER(ia)->psp_create_func)(\
                (ia),\
                (conn_qual),\
                (evd),\
                (flags),\
                (handle))

#define DAT_PSP_CREATE_ANY(ia, conn_qual, evd, flags, handle) \
        (*DAT_HANDLE_TO_PROVIDER(ia)->psp_create_any_func)(\
                (ia), \
                (conn_qual), \
                (evd), \
                (flags), \
                (handle))

#define DAT_PSP_QUERY(psp, mask, param) \
        (*DAT_HANDLE_TO_PROVIDER(psp)->psp_query_func)(\
                (psp),\
                (mask),\
                (param))

#define DAT_PSP_FREE(psp)\
        (*DAT_HANDLE_TO_PROVIDER(psp)->psp_free_func)(\
                (psp))

#define DAT_RSP_CREATE(ia, conn_qual, ep, evd, handle) \
        (*DAT_HANDLE_TO_PROVIDER(ia)->rsp_create_func)(\
                (ia),\
                (conn_qual),\
                (ep),\
                (evd),\
                (handle))

#define DAT_RSP_QUERY(rsp, mask, param) \
        (*DAT_HANDLE_TO_PROVIDER(rsp)->rsp_query_func)(\
                (rsp),\
                (mask),\
                (param))

#define DAT_RSP_FREE(rsp)\
        (*DAT_HANDLE_TO_PROVIDER(rsp)->rsp_free_func)(\
                (rsp))

#define DAT_PZ_CREATE(ia, pz) \
        (*DAT_HANDLE_TO_PROVIDER(ia)->pz_create_func)(\
                (ia),\
                (pz))

#define DAT_PZ_QUERY(pz, mask, param) \
        (*DAT_HANDLE_TO_PROVIDER(pz)->pz_query_func)(\
                (pz),\
                (mask),\
                (param))

#define DAT_PZ_FREE(pz) \
        (*DAT_HANDLE_TO_PROVIDER(pz)->pz_free_func)(\
                (pz))

#define DAT_SRQ_CREATE(ia, pz, attr, srq) \
        (*DAT_HANDLE_TO_PROVIDER(ia)->srq_create_func)(\
                (ia),\
                (pz),\
                (attr),\
                (srq))

#define DAT_SRQ_SET_LW(srq, lw) \
        (*DAT_HANDLE_TO_PROVIDER(srq)->srq_set_lw_func)(\
                (srq),\
                (lw))

#define DAT_SRQ_FREE(srq) \
        (*DAT_HANDLE_TO_PROVIDER(srq)->srq_free_func)(\
                (srq))

#define DAT_SRQ_QUERY(srq, mask, param) \
        (*DAT_HANDLE_TO_PROVIDER(srq)->srq_query_func)(\
                (srq),\
                (mask),\
                (param))

#define DAT_SRQ_RESIZE(srq, qsize) \
        (*DAT_HANDLE_TO_PROVIDER(srq)->srq_resize_func)(\
                (srq),\
                (qsize))

#define DAT_SRQ_POST_RECV(srq, size, lbuf, cookie) \
        (*DAT_HANDLE_TO_PROVIDER(srq)->srq_post_recv_func)(\
                (srq),\
                (size),\
                (lbuf),\
                (cookie))

/*
 * FUNCTION PROTOTYPES
 */

typedef DAT_RETURN (*DAT_IA_OPEN_FUNC)(
        IN      const DAT_NAME_PTR,     /* provider             */
        IN      DAT_COUNT,              /* asynch_evd_min_qlen  */
        INOUT   DAT_EVD_HANDLE *,       /* asynch_evd_handle    */
        OUT     DAT_IA_HANDLE *,        /* ia_handle            */
        IN      boolean_t);             /* relaxed ordering aware */

typedef DAT_RETURN (*DAT_IA_OPENV_FUNC)(
        IN      const DAT_NAME_PTR,     /* provider             */
        IN      DAT_COUNT,              /* asynch_evd_min_qlen  */
        INOUT   DAT_EVD_HANDLE *,       /* asynch_evd_handle    */
        OUT     DAT_IA_HANDLE *,        /* ia_handle            */
        IN      DAT_UINT32,             /* dat major version number */
        IN      DAT_UINT32,             /* dat minor version number */
        IN      DAT_BOOLEAN);           /* dat thread safety */

typedef DAT_RETURN (*DAT_IA_CLOSE_FUNC)(
        IN      DAT_IA_HANDLE,          /* ia_handle            */
        IN      DAT_CLOSE_FLAGS);       /* close_flags          */

typedef DAT_RETURN (*DAT_IA_QUERY_FUNC)(
        IN      DAT_IA_HANDLE,          /* ia handle            */
        OUT     DAT_EVD_HANDLE *,       /* async_evd_handle     */
        IN      DAT_IA_ATTR_MASK,       /* ia_attr_mask         */
        OUT     DAT_IA_ATTR *,          /* ia_attr              */
        IN      DAT_PROVIDER_ATTR_MASK, /* provider_attr_mask   */
        OUT     DAT_PROVIDER_ATTR *);   /* provider_attr        */

/* helper functions */

typedef DAT_RETURN (*DAT_SET_CONSUMER_CONTEXT_FUNC)(
        IN      DAT_HANDLE,             /* dat handle           */
        IN      DAT_CONTEXT);           /* context              */

typedef DAT_RETURN (*DAT_GET_CONSUMER_CONTEXT_FUNC)(
        IN      DAT_HANDLE,             /* dat handle           */
        OUT     DAT_CONTEXT *);         /* context              */

typedef DAT_RETURN (*DAT_GET_HANDLE_TYPE_FUNC)(
        IN      DAT_HANDLE,
        OUT     DAT_HANDLE_TYPE *);

/* CR Functions */

typedef DAT_RETURN (*DAT_CR_QUERY_FUNC)(
        IN      DAT_CR_HANDLE,          /* cr_handle            */
        IN      DAT_CR_PARAM_MASK,      /* cr_param_mask        */
        OUT     DAT_CR_PARAM *);        /* cr_param             */

typedef DAT_RETURN (*DAT_CR_ACCEPT_FUNC)(
        IN      DAT_CR_HANDLE,          /* cr_handle            */
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        IN      DAT_COUNT,              /* private_data_size    */
        IN      const DAT_PVOID);       /* private_data         */

typedef DAT_RETURN (*DAT_CR_REJECT_FUNC)(
        IN      DAT_CR_HANDLE);

/*
 * For DAT-1.1 this function is defined for both uDAPL and kDAPL.
 * For DAT-1.0 it was only defined for uDAPL.
 */
typedef DAT_RETURN (*DAT_CR_HANDOFF_FUNC)(
        IN      DAT_CR_HANDLE,          /* cr_handle            */
        IN      DAT_CONN_QUAL);         /* handoff              */

/* EVD Functions */

typedef DAT_RETURN (*DAT_EVD_RESIZE_FUNC)(
        IN      DAT_EVD_HANDLE,         /* evd_handle           */
        IN      DAT_COUNT);             /* evd_min_qlen         */

typedef DAT_RETURN (*DAT_EVD_POST_SE_FUNC)(
        IN      DAT_EVD_HANDLE,         /* evd_handle           */
        IN      const DAT_EVENT *);     /* event                */

typedef DAT_RETURN (*DAT_EVD_DEQUEUE_FUNC)(
        IN      DAT_EVD_HANDLE,         /* evd_handle           */
        OUT     DAT_EVENT *);           /* event                */

typedef DAT_RETURN (*DAT_EVD_FREE_FUNC)(
        IN      DAT_EVD_HANDLE);        /* evd_handle           */

typedef DAT_RETURN (*DAT_EVD_QUERY_FUNC)(
        IN      DAT_EVD_HANDLE,         /* evd_handle           */
        IN      DAT_EVD_PARAM_MASK,     /* evd_param_mask       */
        OUT     DAT_EVD_PARAM *);       /* evd_param            */

/* EP functions */

typedef DAT_RETURN (*DAT_EP_CREATE_FUNC)(
        IN      DAT_IA_HANDLE,          /* ia_handle            */
        IN      DAT_PZ_HANDLE,          /* pz_handle            */
        IN      DAT_EVD_HANDLE,         /* recv_completion_evd_handle */
        IN      DAT_EVD_HANDLE,         /* request_completion_evd_handle */
        IN      DAT_EVD_HANDLE,         /* connect_evd_handle   */
        IN      const DAT_EP_ATTR *,    /* ep_attributes        */
        OUT     DAT_EP_HANDLE *);       /* ep_handle            */

typedef DAT_RETURN (*DAT_EP_CREATE_WITH_SRQ_FUNC)(
        IN      DAT_IA_HANDLE,          /* ia_handle            */
        IN      DAT_PZ_HANDLE,          /* pz_handle            */
        IN      DAT_EVD_HANDLE,         /* recv_evd_handle      */
        IN      DAT_EVD_HANDLE,         /* request_evd_handle   */
        IN      DAT_EVD_HANDLE,         /* connect_evd_handle   */
        IN      DAT_SRQ_HANDLE,         /* srq_handle           */
        IN      const DAT_EP_ATTR *,    /* ep_attributes        */
        OUT     DAT_EP_HANDLE *);       /* ep_handle            */

typedef DAT_RETURN (*DAT_EP_QUERY_FUNC)(
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        IN      DAT_EP_PARAM_MASK,      /* ep_param_mask        */
        OUT     DAT_EP_PARAM *);        /* ep_param             */

typedef DAT_RETURN (*DAT_EP_MODIFY_FUNC)(
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        IN      DAT_EP_PARAM_MASK,      /* ep_param_mask        */
        IN      const DAT_EP_PARAM *);  /* ep_param             */

typedef DAT_RETURN (*DAT_EP_CONNECT_FUNC)(
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        IN      DAT_IA_ADDRESS_PTR,     /* remote_ia_address    */
        IN      DAT_CONN_QUAL,          /* remote_conn_qual     */
        IN      DAT_TIMEOUT,            /* timeout              */
        IN      DAT_COUNT,              /* private_data_size    */
        IN      const DAT_PVOID,        /* private_data         */
        IN      DAT_QOS,                /* quality_of_service   */
        IN      DAT_CONNECT_FLAGS);     /* connect_flags        */

typedef DAT_RETURN (*DAT_EP_DUP_CONNECT_FUNC)(
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        IN      DAT_EP_HANDLE,          /* ep_dup_handle        */
        IN      DAT_TIMEOUT,            /* timeout              */
        IN      DAT_COUNT,              /* private_data_size    */
        IN      const DAT_PVOID,        /* private_data         */
        IN      DAT_QOS);               /* quality_of_service   */

typedef DAT_RETURN (*DAT_EP_DISCONNECT_FUNC)(
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        IN      DAT_CLOSE_FLAGS);       /* close_flags          */

typedef DAT_RETURN (*DAT_EP_POST_SEND_FUNC)(
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        IN      DAT_COUNT,              /* num_segments         */
        IN      DAT_LMR_TRIPLET *,      /* local_iov            */
        IN      DAT_DTO_COOKIE,         /* user_cookie          */
        IN      DAT_COMPLETION_FLAGS);  /* completion_flags     */

typedef DAT_RETURN (*DAT_EP_POST_RECV_FUNC)(
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        IN      DAT_COUNT,              /* num_segments         */
        IN      DAT_LMR_TRIPLET *,      /* local_iov            */
        IN      DAT_DTO_COOKIE,         /* user_cookie          */
        IN      DAT_COMPLETION_FLAGS);  /* completion_flags     */

typedef DAT_RETURN (*DAT_EP_POST_RDMA_READ_FUNC)(
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        IN      DAT_COUNT,              /* num_segments         */
        IN      DAT_LMR_TRIPLET *,      /* local_iov            */
        IN      DAT_DTO_COOKIE,         /* user_cookie          */
        IN      const DAT_RMR_TRIPLET *,        /* remote_iov           */
        IN      DAT_COMPLETION_FLAGS);  /* completion_flags     */

typedef DAT_RETURN (*DAT_EP_POST_RDMA_WRITE_FUNC)(
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        IN      DAT_COUNT,              /* num_segments         */
        IN      DAT_LMR_TRIPLET *,      /* local_iov            */
        IN      DAT_DTO_COOKIE,         /* user_cookie          */
        IN      const DAT_RMR_TRIPLET *,        /* remote_iov           */
        IN      DAT_COMPLETION_FLAGS);  /* completion_flags     */

typedef DAT_RETURN (*DAT_EP_GET_STATUS_FUNC)(
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        OUT     DAT_EP_STATE *,         /* ep_state             */
        OUT     DAT_BOOLEAN *,          /* recv_idle            */
        OUT     DAT_BOOLEAN *);         /* request_idle         */

typedef DAT_RETURN (*DAT_EP_FREE_FUNC)(
        IN      DAT_EP_HANDLE);         /* ep_handle            */

typedef DAT_RETURN (*DAT_EP_RESET_FUNC)(
        IN      DAT_EP_HANDLE);         /* ep_handle            */

typedef DAT_RETURN (*DAT_EP_RECV_QUERY_FUNC)(
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        OUT     DAT_COUNT *,            /* nbufs_allocated      */
        OUT     DAT_COUNT *);           /* bufs_alloc_span      */

typedef DAT_RETURN (*DAT_EP_SET_WATERMARK_FUNC)(
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        IN      DAT_COUNT,              /* soft_high_watermark  */
        IN      DAT_COUNT);             /* hard_high_watermark  */

/* LMR functions */

typedef DAT_RETURN (*DAT_LMR_FREE_FUNC)(
        IN      DAT_LMR_HANDLE);

typedef DAT_RETURN (*DAT_LMR_QUERY_FUNC)(
        IN      DAT_LMR_HANDLE,         /* lmr_handle           */
        IN      DAT_LMR_PARAM_MASK,     /* lmr_param_mask       */
        OUT     DAT_LMR_PARAM *);       /* lmr_param            */

typedef DAT_RETURN (*DAT_LMR_SYNC_RDMA_READ_FUNC)(
        IN      DAT_IA_HANDLE,          /* ia_handle            */
        IN      const DAT_LMR_TRIPLET *, /* local_segments      */
        IN      DAT_VLEN);              /* num_segments         */

typedef DAT_RETURN (*DAT_LMR_SYNC_RDMA_WRITE_FUNC)(
        IN      DAT_IA_HANDLE,          /* ia_handle            */
        IN      const DAT_LMR_TRIPLET *, /* local_segments      */
        IN      DAT_VLEN);              /* num_segments         */

/* RMR Functions */

typedef DAT_RETURN (*DAT_RMR_CREATE_FUNC)(
        IN      DAT_PZ_HANDLE,          /* pz_handle            */
        OUT     DAT_RMR_HANDLE *);      /* rmr_handle           */

typedef DAT_RETURN (*DAT_RMR_QUERY_FUNC)(
        IN      DAT_RMR_HANDLE,         /* rmr_handle           */
        IN      DAT_RMR_PARAM_MASK,     /* rmr_param_mask       */
        OUT     DAT_RMR_PARAM *);       /* rmr_param            */

typedef DAT_RETURN (*DAT_RMR_BIND_FUNC)(
        IN      DAT_RMR_HANDLE,         /* rmr_handle           */
        IN      const DAT_LMR_TRIPLET *,        /* lmr_triplet          */
        IN      DAT_MEM_PRIV_FLAGS,     /* mem_priv             */
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        IN      DAT_RMR_COOKIE,         /* user_cookie          */
        IN      DAT_COMPLETION_FLAGS,   /* completion_flags     */
        OUT     DAT_RMR_CONTEXT *);     /* context              */

typedef DAT_RETURN (*DAT_RMR_FREE_FUNC)(
        IN      DAT_RMR_HANDLE);

/* PSP Functions */

typedef DAT_RETURN (*DAT_PSP_CREATE_FUNC)(
        IN      DAT_IA_HANDLE,          /* ia_handle            */
        IN      DAT_CONN_QUAL,          /* conn_qual            */
        IN      DAT_EVD_HANDLE,         /* evd_handle           */
        IN      DAT_PSP_FLAGS,          /* psp_flags            */
        OUT     DAT_PSP_HANDLE *);      /* psp_handle           */

typedef DAT_RETURN (*DAT_PSP_CREATE_ANY_FUNC)(
        IN      DAT_IA_HANDLE,          /* ia_handle            */
        OUT     DAT_CONN_QUAL *,        /* conn_qual            */
        IN      DAT_EVD_HANDLE,         /* evd_handle           */
        IN      DAT_PSP_FLAGS,          /* psp_flags            */
        OUT     DAT_PSP_HANDLE *);      /* psp_handle           */

typedef DAT_RETURN (*DAT_PSP_QUERY_FUNC)(
        IN      DAT_PSP_HANDLE,         /* psp_handle           */
        IN      DAT_PSP_PARAM_MASK,     /* psp_param_mask       */
        OUT     DAT_PSP_PARAM *);       /* *psp_param           */

typedef DAT_RETURN (*DAT_PSP_FREE_FUNC)(
        IN      DAT_PSP_HANDLE);        /* psp_handle           */

/* RSP Functions */

typedef DAT_RETURN (*DAT_RSP_CREATE_FUNC)(
        IN      DAT_IA_HANDLE,          /* ia_handle            */
        IN      DAT_CONN_QUAL,          /* conn_qual            */
        IN      DAT_EP_HANDLE,          /* ep_handle            */
        IN      DAT_EVD_HANDLE,         /* evd_handle           */
        OUT     DAT_RSP_HANDLE *);      /* rsp_handle           */

typedef DAT_RETURN (*DAT_RSP_QUERY_FUNC) (
        IN      DAT_RSP_HANDLE,         /* rsp_handle           */
        IN      DAT_RSP_PARAM_MASK,     /* rsp_param_mask       */
        OUT     DAT_RSP_PARAM *);       /* *rsp_param           */

typedef DAT_RETURN (*DAT_RSP_FREE_FUNC)(
        IN      DAT_RSP_HANDLE);        /* rsp_handle           */

/* PZ Functions */

typedef DAT_RETURN (*DAT_PZ_CREATE_FUNC)(
        IN      DAT_IA_HANDLE,          /* ia_handle            */
        OUT     DAT_PZ_HANDLE *);       /* pz_handle            */

typedef DAT_RETURN (*DAT_PZ_QUERY_FUNC)(
        IN      DAT_PZ_HANDLE,          /* pz_handle            */
        IN      DAT_PZ_PARAM_MASK,      /* pz_param_mask        */
        OUT     DAT_PZ_PARAM *);        /* pz_param             */

typedef DAT_RETURN (*DAT_PZ_FREE_FUNC)(
        IN      DAT_PZ_HANDLE);         /* pz_handle            */

/* SRQ Functions */

typedef DAT_RETURN (*DAT_SRQ_CREATE_FUNC)(
        IN      DAT_IA_HANDLE,          /* ia_handle            */
        IN      DAT_PZ_HANDLE,          /* pz_handle            */
        IN      DAT_SRQ_ATTR *,         /* srq_attr             */
        OUT     DAT_SRQ_HANDLE *);      /* srq_handle           */

typedef DAT_RETURN (*DAT_SRQ_SET_LW_FUNC)(
        IN      DAT_SRQ_HANDLE,         /* srq_handle           */
        IN      DAT_COUNT);             /* low_watermark        */

typedef DAT_RETURN (*DAT_SRQ_FREE_FUNC)(
        IN      DAT_SRQ_HANDLE);        /* srq_handle           */

typedef DAT_RETURN (*DAT_SRQ_QUERY_FUNC)(
        IN      DAT_SRQ_HANDLE,         /* srq_handle           */
        IN      DAT_SRQ_PARAM_MASK,     /* srq_param_mask       */
        OUT     DAT_SRQ_PARAM *);               /* srq_param            */

typedef DAT_RETURN (*DAT_SRQ_RESIZE_FUNC)(
        IN      DAT_SRQ_HANDLE,         /* srq_handle           */
        IN      DAT_COUNT);             /* srq_max_recv_dto     */

typedef DAT_RETURN (*DAT_SRQ_POST_RECV_FUNC)(
        IN      DAT_SRQ_HANDLE,         /* srq_handle           */
        IN      DAT_COUNT,              /* num_segments         */
        IN      DAT_LMR_TRIPLET *,      /* local_iov            */
        IN      DAT_DTO_COOKIE);        /* user_cookie          */

#ifdef __cplusplus
}
#endif

#endif /* _DAT_REDIRECTION_H_ */