/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (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-2003, Network Appliance, Inc. All rights reserved.
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
*
* MODULE: dat_api.c
*
* PURPOSE: DAT Provider and Consumer registry functions.
*
*/
#include "dat_osd.h"
#include <dat/dat_registry.h>
DAT_RETURN dat_set_consumer_context(
IN DAT_HANDLE dat_handle,
IN DAT_CONTEXT context)
{
if (DAT_BAD_HANDLE(dat_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
}
return DAT_SET_CONSUMER_CONTEXT(dat_handle,
context);
}
DAT_RETURN dat_get_consumer_context(
IN DAT_HANDLE dat_handle,
OUT DAT_CONTEXT *context)
{
if (DAT_BAD_HANDLE(dat_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
}
return DAT_GET_CONSUMER_CONTEXT(dat_handle,
context);
}
DAT_RETURN dat_get_handle_type(
IN DAT_HANDLE dat_handle,
OUT DAT_HANDLE_TYPE *type)
{
if (DAT_BAD_HANDLE(dat_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
}
return DAT_GET_HANDLE_TYPE(dat_handle,
type);
}
DAT_RETURN dat_cr_query(
IN DAT_CR_HANDLE cr_handle,
IN DAT_CR_PARAM_MASK cr_param_mask,
OUT DAT_CR_PARAM *cr_param)
{
if (DAT_BAD_HANDLE(cr_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR));
}
return DAT_CR_QUERY(cr_handle,
cr_param_mask,
cr_param);
}
DAT_RETURN dat_cr_accept(
IN DAT_CR_HANDLE cr_handle,
IN DAT_EP_HANDLE ep_handle,
IN DAT_COUNT private_data_size,
IN const DAT_PVOID private_data)
{
if (DAT_BAD_HANDLE(cr_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR));
}
return DAT_CR_ACCEPT(cr_handle,
ep_handle,
private_data_size,
private_data);
}
DAT_RETURN dat_cr_reject(
IN DAT_CR_HANDLE cr_handle)
{
if (DAT_BAD_HANDLE(cr_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR));
}
return (DAT_CR_REJECT(cr_handle));
}
DAT_RETURN dat_evd_resize(
IN DAT_EVD_HANDLE evd_handle,
IN DAT_COUNT evd_min_qlen)
{
if (DAT_BAD_HANDLE(evd_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
}
return DAT_EVD_RESIZE(evd_handle,
evd_min_qlen);
}
DAT_RETURN dat_evd_post_se(
IN DAT_EVD_HANDLE evd_handle,
IN const DAT_EVENT *event)
{
if (DAT_BAD_HANDLE(evd_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
}
return DAT_EVD_POST_SE(evd_handle,
event);
}
DAT_RETURN dat_evd_dequeue(
IN DAT_EVD_HANDLE evd_handle,
OUT DAT_EVENT *event)
{
if (DAT_BAD_HANDLE(evd_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
}
return DAT_EVD_DEQUEUE(evd_handle,
event);
}
DAT_RETURN dat_evd_free(
IN DAT_EVD_HANDLE evd_handle)
{
if (DAT_BAD_HANDLE(evd_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
}
return (DAT_EVD_FREE(evd_handle));
}
DAT_RETURN dat_ep_create(
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)
{
if (DAT_BAD_HANDLE(ia_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
}
return DAT_EP_CREATE(ia_handle,
pz_handle,
recv_completion_evd_handle,
request_completion_evd_handle,
connect_evd_handle,
ep_attributes,
ep_handle);
}
DAT_RETURN dat_ep_query(
IN DAT_EP_HANDLE ep_handle,
IN DAT_EP_PARAM_MASK ep_param_mask,
OUT DAT_EP_PARAM *ep_param)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return DAT_EP_QUERY(ep_handle,
ep_param_mask,
ep_param);
}
DAT_RETURN dat_ep_modify(
IN DAT_EP_HANDLE ep_handle,
IN DAT_EP_PARAM_MASK ep_param_mask,
IN const DAT_EP_PARAM *ep_param)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return DAT_EP_MODIFY(ep_handle,
ep_param_mask,
ep_param);
}
DAT_RETURN dat_ep_connect(
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)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return DAT_EP_CONNECT(ep_handle,
remote_ia_address,
remote_conn_qual,
timeout,
private_data_size,
private_data,
quality_of_service,
connect_flags);
}
DAT_RETURN dat_ep_dup_connect(
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)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return DAT_EP_DUP_CONNECT(ep_handle,
ep_dup_handle,
timeout,
private_data_size,
private_data,
quality_of_service);
}
DAT_RETURN dat_ep_disconnect(
IN DAT_EP_HANDLE ep_handle,
IN DAT_CLOSE_FLAGS close_flags)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return DAT_EP_DISCONNECT(ep_handle,
close_flags);
}
DAT_RETURN dat_ep_post_send(
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)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return DAT_EP_POST_SEND(ep_handle,
num_segments,
local_iov,
user_cookie,
completion_flags);
}
DAT_RETURN dat_ep_post_recv(
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)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return DAT_EP_POST_RECV(ep_handle,
num_segments,
local_iov,
user_cookie,
completion_flags);
}
DAT_RETURN dat_ep_post_rdma_read(
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)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return DAT_EP_POST_RDMA_READ(ep_handle,
num_segments,
local_iov,
user_cookie,
remote_iov,
completion_flags);
}
DAT_RETURN dat_ep_post_rdma_write(
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)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return DAT_EP_POST_RDMA_WRITE(ep_handle,
num_segments,
local_iov,
user_cookie,
remote_iov,
completion_flags);
}
DAT_RETURN dat_ep_get_status(
IN DAT_EP_HANDLE ep_handle,
OUT DAT_EP_STATE *ep_state,
OUT DAT_BOOLEAN *recv_idle,
OUT DAT_BOOLEAN *request_idle)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return DAT_EP_GET_STATUS(ep_handle,
ep_state,
recv_idle,
request_idle);
}
DAT_RETURN dat_ep_free(
IN DAT_EP_HANDLE ep_handle)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return (DAT_EP_FREE(ep_handle));
}
DAT_RETURN dat_ep_reset(
IN DAT_EP_HANDLE ep_handle)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return (DAT_EP_RESET(ep_handle));
}
DAT_RETURN dat_lmr_free(
IN DAT_LMR_HANDLE lmr_handle)
{
if (DAT_BAD_HANDLE(lmr_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_LMR));
}
return (DAT_LMR_FREE(lmr_handle));
}
DAT_RETURN dat_rmr_create(
IN DAT_PZ_HANDLE pz_handle,
OUT DAT_RMR_HANDLE *rmr_handle)
{
if (DAT_BAD_HANDLE(pz_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ));
}
return DAT_RMR_CREATE(pz_handle,
rmr_handle);
}
DAT_RETURN dat_rmr_query(
IN DAT_RMR_HANDLE rmr_handle,
IN DAT_RMR_PARAM_MASK rmr_param_mask,
OUT DAT_RMR_PARAM *rmr_param)
{
if (DAT_BAD_HANDLE(rmr_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RMR));
}
return DAT_RMR_QUERY(rmr_handle,
rmr_param_mask,
rmr_param);
}
DAT_RETURN dat_rmr_bind(
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)
{
if (DAT_BAD_HANDLE(rmr_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RMR));
}
return DAT_RMR_BIND(rmr_handle,
lmr_triplet,
mem_priv,
ep_handle,
user_cookie,
completion_flags,
context);
}
DAT_RETURN dat_rmr_free(
IN DAT_RMR_HANDLE rmr_handle)
{
if (DAT_BAD_HANDLE(rmr_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RMR));
}
return (DAT_RMR_FREE(rmr_handle));
}
DAT_RETURN dat_psp_create(
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)
{
if (DAT_BAD_HANDLE(ia_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
}
return DAT_PSP_CREATE(ia_handle,
conn_qual,
evd_handle,
psp_flags,
psp_handle);
}
DAT_RETURN dat_psp_query(
IN DAT_PSP_HANDLE psp_handle,
IN DAT_PSP_PARAM_MASK psp_param_mask,
OUT DAT_PSP_PARAM *psp_param)
{
if (DAT_BAD_HANDLE(psp_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PSP));
}
return DAT_PSP_QUERY(psp_handle,
psp_param_mask,
psp_param);
}
DAT_RETURN dat_psp_free(
IN DAT_PSP_HANDLE psp_handle)
{
if (DAT_BAD_HANDLE(psp_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PSP));
}
return (DAT_PSP_FREE(psp_handle));
}
DAT_RETURN dat_rsp_create(
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)
{
if (DAT_BAD_HANDLE(ia_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
}
return DAT_RSP_CREATE(ia_handle,
conn_qual,
ep_handle,
evd_handle,
rsp_handle);
}
DAT_RETURN dat_rsp_query(
IN DAT_RSP_HANDLE rsp_handle,
IN DAT_RSP_PARAM_MASK rsp_param_mask,
OUT DAT_RSP_PARAM *rsp_param)
{
if (DAT_BAD_HANDLE(rsp_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RSP));
}
return DAT_RSP_QUERY(rsp_handle,
rsp_param_mask,
rsp_param);
}
DAT_RETURN dat_rsp_free(
IN DAT_RSP_HANDLE rsp_handle)
{
if (DAT_BAD_HANDLE(rsp_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RSP));
}
return (DAT_RSP_FREE(rsp_handle));
}
DAT_RETURN dat_pz_create(
IN DAT_IA_HANDLE ia_handle,
OUT DAT_PZ_HANDLE *pz_handle)
{
if (DAT_BAD_HANDLE(ia_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
}
return DAT_PZ_CREATE(ia_handle,
pz_handle);
}
DAT_RETURN dat_pz_query(
IN DAT_PZ_HANDLE pz_handle,
IN DAT_PZ_PARAM_MASK pz_param_mask,
OUT DAT_PZ_PARAM *pz_param)
{
if (DAT_BAD_HANDLE(pz_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ));
}
return DAT_PZ_QUERY(pz_handle,
pz_param_mask,
pz_param);
}
DAT_RETURN dat_pz_free(
IN DAT_PZ_HANDLE pz_handle)
{
if (DAT_BAD_HANDLE(pz_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ));
}
return (DAT_PZ_FREE(pz_handle));
}
/* ARGSUSED */
DAT_RETURN dat_lmr_sync_rdma_read(
IN DAT_IA_HANDLE ia_handle,
IN const DAT_LMR_TRIPLET *local_segments,
IN DAT_VLEN num_segments)
{
if (DAT_BAD_HANDLE(ia_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
}
#if defined(__x86)
return (DAT_SUCCESS);
#elif defined(__sparc)
return (DAT_LMR_SYNC_RDMA_READ(ia_handle, local_segments,
num_segments));
#else
#error "ISA not supported"
#endif
}
/* ARGSUSED */
DAT_RETURN dat_lmr_sync_rdma_write(
IN DAT_IA_HANDLE ia_handle,
IN const DAT_LMR_TRIPLET *local_segments,
IN DAT_VLEN num_segments)
{
if (DAT_BAD_HANDLE(ia_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
}
#if defined(__x86)
return (DAT_SUCCESS);
#elif defined(__sparc)
return (DAT_LMR_SYNC_RDMA_WRITE(ia_handle, local_segments,
num_segments));
#else
#error "ISA not supported"
#endif
}
DAT_RETURN dat_ep_create_with_srq(
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)
{
if (DAT_BAD_HANDLE(ia_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
}
return DAT_EP_CREATE_WITH_SRQ(ia_handle,
pz_handle,
recv_evd_handle,
request_evd_handle,
connect_evd_handle,
srq_handle,
ep_attributes,
ep_handle);
}
DAT_RETURN dat_ep_recv_query(
IN DAT_EP_HANDLE ep_handle,
OUT DAT_COUNT *nbufs_allocated,
OUT DAT_COUNT *bufs_alloc_span)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return DAT_EP_RECV_QUERY(ep_handle,
nbufs_allocated,
bufs_alloc_span);
}
DAT_RETURN dat_ep_set_watermark(
IN DAT_EP_HANDLE ep_handle,
IN DAT_COUNT soft_high_watermark,
IN DAT_COUNT hard_high_watermark)
{
if (DAT_BAD_HANDLE(ep_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
}
return DAT_EP_SET_WATERMARK(ep_handle,
soft_high_watermark,
hard_high_watermark);
}
DAT_RETURN dat_srq_create(
IN DAT_IA_HANDLE ia_handle,
IN DAT_PZ_HANDLE pz_handle,
IN DAT_SRQ_ATTR *srq_attr,
OUT DAT_SRQ_HANDLE *srq_handle)
{
if (DAT_BAD_HANDLE(ia_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
}
return DAT_SRQ_CREATE(ia_handle,
pz_handle,
srq_attr,
srq_handle);
}
DAT_RETURN dat_srq_free(
IN DAT_SRQ_HANDLE srq_handle)
{
if (DAT_BAD_HANDLE(srq_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ));
}
return (DAT_SRQ_FREE(srq_handle));
}
DAT_RETURN dat_srq_post_recv(
IN DAT_SRQ_HANDLE srq_handle,
IN DAT_COUNT num_segments,
IN DAT_LMR_TRIPLET *local_iov,
IN DAT_DTO_COOKIE user_cookie)
{
if (DAT_BAD_HANDLE(srq_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ));
}
return DAT_SRQ_POST_RECV(srq_handle,
num_segments,
local_iov,
user_cookie);
}
DAT_RETURN dat_srq_query(
IN DAT_SRQ_HANDLE srq_handle,
IN DAT_SRQ_PARAM_MASK srq_param_mask,
OUT DAT_SRQ_PARAM *srq_param)
{
if (DAT_BAD_HANDLE(srq_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ));
}
return DAT_SRQ_QUERY(srq_handle,
srq_param_mask,
srq_param);
}
DAT_RETURN dat_srq_resize(
IN DAT_SRQ_HANDLE srq_handle,
IN DAT_COUNT srq_max_recv_dto)
{
if (DAT_BAD_HANDLE(srq_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ));
}
return DAT_SRQ_RESIZE(srq_handle,
srq_max_recv_dto);
}
DAT_RETURN dat_srq_set_lw(
IN DAT_SRQ_HANDLE srq_handle,
IN DAT_COUNT low_watermark)
{
if (DAT_BAD_HANDLE(srq_handle)) {
return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ));
}
return DAT_SRQ_SET_LW(srq_handle,
low_watermark);
}