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, Version 1.0 only
6 * (the "License").  You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22/*
23 * Copyright (c) 2002-2003, Network Appliance, Inc. All rights reserved.
24 */
25
26/*
27 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
28 * Use is subject to license terms.
29 */
30
31#pragma ident	"%Z%%M%	%I%	%E% SMI"
32
33/*
34 *
35 * MODULE: dat_api.c
36 *
37 * PURPOSE: DAT Provider and Consumer registry functions.
38 *
39 */
40
41#include "dat_osd.h"
42#include <dat/dat_registry.h>
43
44
45DAT_RETURN dat_set_consumer_context(
46	IN	DAT_HANDLE		dat_handle,
47	IN	DAT_CONTEXT		context)
48{
49	if (DAT_BAD_HANDLE(dat_handle)) {
50		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
51	}
52	return DAT_SET_CONSUMER_CONTEXT(dat_handle,
53				context);
54}
55
56
57DAT_RETURN dat_get_consumer_context(
58	IN	DAT_HANDLE		dat_handle,
59	OUT	DAT_CONTEXT		*context)
60{
61	if (DAT_BAD_HANDLE(dat_handle)) {
62		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
63	}
64	return DAT_GET_CONSUMER_CONTEXT(dat_handle,
65				context);
66
67}
68
69
70DAT_RETURN dat_get_handle_type(
71	IN	DAT_HANDLE		dat_handle,
72	OUT	DAT_HANDLE_TYPE		*type)
73{
74	if (DAT_BAD_HANDLE(dat_handle)) {
75		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
76	}
77	return DAT_GET_HANDLE_TYPE(dat_handle,
78				type);
79}
80
81
82DAT_RETURN dat_cr_query(
83	IN	DAT_CR_HANDLE		cr_handle,
84	IN	DAT_CR_PARAM_MASK	cr_param_mask,
85	OUT	DAT_CR_PARAM		*cr_param)
86{
87	if (DAT_BAD_HANDLE(cr_handle)) {
88		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR));
89	}
90	return DAT_CR_QUERY(cr_handle,
91			    cr_param_mask,
92			    cr_param);
93}
94
95
96DAT_RETURN dat_cr_accept(
97	IN	DAT_CR_HANDLE		cr_handle,
98	IN	DAT_EP_HANDLE		ep_handle,
99	IN	DAT_COUNT		private_data_size,
100	IN	const DAT_PVOID		private_data)
101{
102	if (DAT_BAD_HANDLE(cr_handle)) {
103		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR));
104	}
105	return DAT_CR_ACCEPT(cr_handle,
106			    ep_handle,
107			    private_data_size,
108			    private_data);
109}
110
111
112DAT_RETURN dat_cr_reject(
113	IN	DAT_CR_HANDLE 		cr_handle)
114{
115	if (DAT_BAD_HANDLE(cr_handle)) {
116		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR));
117	}
118	return (DAT_CR_REJECT(cr_handle));
119}
120
121
122DAT_RETURN dat_evd_resize(
123	IN	DAT_EVD_HANDLE		evd_handle,
124	IN	DAT_COUNT		evd_min_qlen)
125{
126	if (DAT_BAD_HANDLE(evd_handle)) {
127		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
128	}
129	return DAT_EVD_RESIZE(evd_handle,
130			evd_min_qlen);
131}
132
133
134DAT_RETURN dat_evd_post_se(
135	IN	DAT_EVD_HANDLE		evd_handle,
136	IN	const DAT_EVENT		*event)
137{
138	if (DAT_BAD_HANDLE(evd_handle)) {
139		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
140	}
141	return DAT_EVD_POST_SE(evd_handle,
142			    event);
143}
144
145
146DAT_RETURN dat_evd_dequeue(
147	IN	DAT_EVD_HANDLE		evd_handle,
148	OUT	DAT_EVENT		*event)
149{
150	if (DAT_BAD_HANDLE(evd_handle)) {
151		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
152	}
153	return DAT_EVD_DEQUEUE(evd_handle,
154				event);
155}
156
157
158DAT_RETURN dat_evd_free(
159	IN	DAT_EVD_HANDLE 		evd_handle)
160{
161	if (DAT_BAD_HANDLE(evd_handle)) {
162		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1));
163	}
164	return (DAT_EVD_FREE(evd_handle));
165}
166
167
168DAT_RETURN dat_ep_create(
169	IN	DAT_IA_HANDLE		ia_handle,
170	IN	DAT_PZ_HANDLE		pz_handle,
171	IN	DAT_EVD_HANDLE		recv_completion_evd_handle,
172	IN	DAT_EVD_HANDLE		request_completion_evd_handle,
173	IN	DAT_EVD_HANDLE		connect_evd_handle,
174	IN	const DAT_EP_ATTR 	*ep_attributes,
175	OUT	DAT_EP_HANDLE		*ep_handle)
176{
177	if (DAT_BAD_HANDLE(ia_handle)) {
178		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
179	}
180	return DAT_EP_CREATE(ia_handle,
181			    pz_handle,
182			    recv_completion_evd_handle,
183			    request_completion_evd_handle,
184			    connect_evd_handle,
185			    ep_attributes,
186			    ep_handle);
187}
188
189
190DAT_RETURN dat_ep_query(
191	IN	DAT_EP_HANDLE		ep_handle,
192	IN	DAT_EP_PARAM_MASK	ep_param_mask,
193	OUT	DAT_EP_PARAM		*ep_param)
194{
195	if (DAT_BAD_HANDLE(ep_handle)) {
196		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
197	}
198	return DAT_EP_QUERY(ep_handle,
199			    ep_param_mask,
200			    ep_param);
201}
202
203
204DAT_RETURN dat_ep_modify(
205	IN	DAT_EP_HANDLE		ep_handle,
206	IN	DAT_EP_PARAM_MASK	ep_param_mask,
207	IN	const DAT_EP_PARAM 	*ep_param)
208{
209	if (DAT_BAD_HANDLE(ep_handle)) {
210		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
211	}
212	return DAT_EP_MODIFY(ep_handle,
213			    ep_param_mask,
214			    ep_param);
215}
216
217
218DAT_RETURN dat_ep_connect(
219	IN	DAT_EP_HANDLE		ep_handle,
220	IN	DAT_IA_ADDRESS_PTR	remote_ia_address,
221	IN	DAT_CONN_QUAL		remote_conn_qual,
222	IN	DAT_TIMEOUT		timeout,
223	IN	DAT_COUNT		private_data_size,
224	IN	const DAT_PVOID		private_data,
225	IN	DAT_QOS			quality_of_service,
226	IN	DAT_CONNECT_FLAGS	connect_flags)
227{
228	if (DAT_BAD_HANDLE(ep_handle)) {
229		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
230	}
231	return DAT_EP_CONNECT(ep_handle,
232			    remote_ia_address,
233			    remote_conn_qual,
234			    timeout,
235			    private_data_size,
236			    private_data,
237			    quality_of_service,
238			    connect_flags);
239}
240
241
242DAT_RETURN dat_ep_dup_connect(
243	IN	DAT_EP_HANDLE		ep_handle,
244	IN	DAT_EP_HANDLE		ep_dup_handle,
245	IN	DAT_TIMEOUT		timeout,
246	IN	DAT_COUNT		private_data_size,
247	IN	const DAT_PVOID		private_data,
248	IN	DAT_QOS			quality_of_service)
249{
250	if (DAT_BAD_HANDLE(ep_handle)) {
251		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
252	}
253	return DAT_EP_DUP_CONNECT(ep_handle,
254			    ep_dup_handle,
255			    timeout,
256			    private_data_size,
257			    private_data,
258			    quality_of_service);
259}
260
261
262DAT_RETURN dat_ep_disconnect(
263	IN	DAT_EP_HANDLE		ep_handle,
264	IN	DAT_CLOSE_FLAGS		close_flags)
265{
266	if (DAT_BAD_HANDLE(ep_handle)) {
267		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
268	}
269	return DAT_EP_DISCONNECT(ep_handle,
270				close_flags);
271}
272
273
274DAT_RETURN dat_ep_post_send(
275	IN	DAT_EP_HANDLE		ep_handle,
276	IN	DAT_COUNT		num_segments,
277	IN	DAT_LMR_TRIPLET		*local_iov,
278	IN	DAT_DTO_COOKIE		user_cookie,
279	IN	DAT_COMPLETION_FLAGS	completion_flags)
280{
281	if (DAT_BAD_HANDLE(ep_handle)) {
282		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
283	}
284	return DAT_EP_POST_SEND(ep_handle,
285			    num_segments,
286			    local_iov,
287			    user_cookie,
288			    completion_flags);
289}
290
291
292DAT_RETURN dat_ep_post_recv(
293	IN	DAT_EP_HANDLE		ep_handle,
294	IN	DAT_COUNT		num_segments,
295	IN	DAT_LMR_TRIPLET		*local_iov,
296	IN	DAT_DTO_COOKIE		user_cookie,
297	IN	DAT_COMPLETION_FLAGS	completion_flags)
298{
299	if (DAT_BAD_HANDLE(ep_handle)) {
300		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
301	}
302	return DAT_EP_POST_RECV(ep_handle,
303			    num_segments,
304			    local_iov,
305			    user_cookie,
306			    completion_flags);
307}
308
309
310DAT_RETURN dat_ep_post_rdma_read(
311	IN	DAT_EP_HANDLE		ep_handle,
312	IN	DAT_COUNT		num_segments,
313	IN	DAT_LMR_TRIPLET		*local_iov,
314	IN	DAT_DTO_COOKIE		user_cookie,
315	IN	const DAT_RMR_TRIPLET	*remote_iov,
316	IN	DAT_COMPLETION_FLAGS	completion_flags)
317{
318	if (DAT_BAD_HANDLE(ep_handle)) {
319		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
320	}
321	return DAT_EP_POST_RDMA_READ(ep_handle,
322				    num_segments,
323				    local_iov,
324				    user_cookie,
325				    remote_iov,
326				    completion_flags);
327}
328
329
330DAT_RETURN dat_ep_post_rdma_write(
331	IN	DAT_EP_HANDLE		ep_handle,
332	IN	DAT_COUNT		num_segments,
333	IN	DAT_LMR_TRIPLET		*local_iov,
334	IN	DAT_DTO_COOKIE		user_cookie,
335	IN	const DAT_RMR_TRIPLET	*remote_iov,
336	IN	DAT_COMPLETION_FLAGS	completion_flags)
337{
338	if (DAT_BAD_HANDLE(ep_handle)) {
339		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
340	}
341	return DAT_EP_POST_RDMA_WRITE(ep_handle,
342				    num_segments,
343				    local_iov,
344				    user_cookie,
345				    remote_iov,
346				    completion_flags);
347}
348
349
350DAT_RETURN dat_ep_get_status(
351	IN	DAT_EP_HANDLE		ep_handle,
352	OUT	DAT_EP_STATE		*ep_state,
353	OUT	DAT_BOOLEAN 		*recv_idle,
354	OUT	DAT_BOOLEAN 		*request_idle)
355{
356	if (DAT_BAD_HANDLE(ep_handle)) {
357		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
358	}
359	return DAT_EP_GET_STATUS(ep_handle,
360				ep_state,
361				recv_idle,
362				request_idle);
363}
364
365
366DAT_RETURN dat_ep_free(
367	IN	DAT_EP_HANDLE		ep_handle)
368{
369	if (DAT_BAD_HANDLE(ep_handle)) {
370		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
371	}
372	return (DAT_EP_FREE(ep_handle));
373}
374
375
376DAT_RETURN dat_ep_reset(
377	IN	DAT_EP_HANDLE		ep_handle)
378{
379	if (DAT_BAD_HANDLE(ep_handle)) {
380		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
381	}
382	return (DAT_EP_RESET(ep_handle));
383}
384
385
386DAT_RETURN dat_lmr_free(
387	IN	DAT_LMR_HANDLE		lmr_handle)
388{
389	if (DAT_BAD_HANDLE(lmr_handle)) {
390		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_LMR));
391	}
392	return (DAT_LMR_FREE(lmr_handle));
393}
394
395
396DAT_RETURN dat_rmr_create(
397	IN	DAT_PZ_HANDLE		pz_handle,
398	OUT	DAT_RMR_HANDLE		*rmr_handle)
399{
400	if (DAT_BAD_HANDLE(pz_handle)) {
401		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ));
402	}
403	return DAT_RMR_CREATE(pz_handle,
404			rmr_handle);
405}
406
407
408DAT_RETURN dat_rmr_query(
409	IN	DAT_RMR_HANDLE		rmr_handle,
410	IN	DAT_RMR_PARAM_MASK	rmr_param_mask,
411	OUT	DAT_RMR_PARAM		*rmr_param)
412{
413	if (DAT_BAD_HANDLE(rmr_handle)) {
414		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RMR));
415	}
416	return DAT_RMR_QUERY(rmr_handle,
417			    rmr_param_mask,
418			    rmr_param);
419}
420
421
422DAT_RETURN dat_rmr_bind(
423	IN	DAT_RMR_HANDLE		rmr_handle,
424	IN	const DAT_LMR_TRIPLET	*lmr_triplet,
425	IN	DAT_MEM_PRIV_FLAGS	mem_priv,
426	IN	DAT_EP_HANDLE		ep_handle,
427	IN	DAT_RMR_COOKIE		user_cookie,
428	IN	DAT_COMPLETION_FLAGS	completion_flags,
429	OUT	DAT_RMR_CONTEXT		*context)
430{
431	if (DAT_BAD_HANDLE(rmr_handle)) {
432		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RMR));
433	}
434	return DAT_RMR_BIND(rmr_handle,
435			    lmr_triplet,
436			    mem_priv,
437			    ep_handle,
438			    user_cookie,
439			    completion_flags,
440			    context);
441}
442
443
444DAT_RETURN dat_rmr_free(
445	IN	DAT_RMR_HANDLE		rmr_handle)
446{
447	if (DAT_BAD_HANDLE(rmr_handle)) {
448		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RMR));
449	}
450	return (DAT_RMR_FREE(rmr_handle));
451}
452
453
454DAT_RETURN dat_psp_create(
455	IN	DAT_IA_HANDLE		ia_handle,
456	IN	DAT_CONN_QUAL		conn_qual,
457	IN	DAT_EVD_HANDLE		evd_handle,
458	IN	DAT_PSP_FLAGS		psp_flags,
459	OUT	DAT_PSP_HANDLE		*psp_handle)
460{
461	if (DAT_BAD_HANDLE(ia_handle)) {
462		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
463	}
464	return DAT_PSP_CREATE(ia_handle,
465			    conn_qual,
466			    evd_handle,
467			    psp_flags,
468			    psp_handle);
469}
470
471
472DAT_RETURN dat_psp_query(
473	IN	DAT_PSP_HANDLE		psp_handle,
474	IN	DAT_PSP_PARAM_MASK	psp_param_mask,
475	OUT	DAT_PSP_PARAM 		*psp_param)
476{
477	if (DAT_BAD_HANDLE(psp_handle)) {
478		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PSP));
479	}
480	return DAT_PSP_QUERY(psp_handle,
481			    psp_param_mask,
482			    psp_param);
483}
484
485
486DAT_RETURN dat_psp_free(
487	IN	DAT_PSP_HANDLE	psp_handle)
488{
489	if (DAT_BAD_HANDLE(psp_handle)) {
490		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PSP));
491	}
492	return (DAT_PSP_FREE(psp_handle));
493}
494
495
496DAT_RETURN dat_rsp_create(
497	IN	DAT_IA_HANDLE		ia_handle,
498	IN	DAT_CONN_QUAL		conn_qual,
499	IN	DAT_EP_HANDLE		ep_handle,
500	IN	DAT_EVD_HANDLE		evd_handle,
501	OUT	DAT_RSP_HANDLE		*rsp_handle)
502{
503	if (DAT_BAD_HANDLE(ia_handle)) {
504		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
505	}
506	return DAT_RSP_CREATE(ia_handle,
507			    conn_qual,
508			    ep_handle,
509			    evd_handle,
510			    rsp_handle);
511}
512
513
514DAT_RETURN dat_rsp_query(
515	IN	DAT_RSP_HANDLE		rsp_handle,
516	IN	DAT_RSP_PARAM_MASK	rsp_param_mask,
517	OUT	DAT_RSP_PARAM		*rsp_param)
518{
519	if (DAT_BAD_HANDLE(rsp_handle)) {
520		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RSP));
521	}
522	return DAT_RSP_QUERY(rsp_handle,
523			    rsp_param_mask,
524			    rsp_param);
525}
526
527
528DAT_RETURN dat_rsp_free(
529	IN	DAT_RSP_HANDLE		rsp_handle)
530{
531	if (DAT_BAD_HANDLE(rsp_handle)) {
532		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RSP));
533	}
534	return (DAT_RSP_FREE(rsp_handle));
535}
536
537
538DAT_RETURN dat_pz_create(
539	IN	DAT_IA_HANDLE		ia_handle,
540	OUT	DAT_PZ_HANDLE		*pz_handle)
541{
542	if (DAT_BAD_HANDLE(ia_handle)) {
543		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
544	}
545	return DAT_PZ_CREATE(ia_handle,
546			pz_handle);
547}
548
549
550DAT_RETURN dat_pz_query(
551	IN	DAT_PZ_HANDLE		pz_handle,
552	IN	DAT_PZ_PARAM_MASK	pz_param_mask,
553	OUT	DAT_PZ_PARAM		*pz_param)
554{
555	if (DAT_BAD_HANDLE(pz_handle)) {
556		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ));
557	}
558	return DAT_PZ_QUERY(pz_handle,
559			pz_param_mask,
560			pz_param);
561}
562
563
564DAT_RETURN dat_pz_free(
565	IN	DAT_PZ_HANDLE		pz_handle)
566{
567	if (DAT_BAD_HANDLE(pz_handle)) {
568		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ));
569	}
570	return (DAT_PZ_FREE(pz_handle));
571}
572
573/* ARGSUSED */
574DAT_RETURN dat_lmr_sync_rdma_read(
575	IN	DAT_IA_HANDLE	ia_handle,
576	IN	const DAT_LMR_TRIPLET *local_segments,
577	IN	DAT_VLEN num_segments)
578{
579	if (DAT_BAD_HANDLE(ia_handle)) {
580		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
581	}
582
583#if defined(__x86)
584	return (DAT_SUCCESS);
585#elif defined(__sparc)
586	return (DAT_LMR_SYNC_RDMA_READ(ia_handle, local_segments,
587		num_segments));
588#else
589#error "ISA not supported"
590#endif
591}
592
593/* ARGSUSED */
594DAT_RETURN dat_lmr_sync_rdma_write(
595	IN	DAT_IA_HANDLE	ia_handle,
596	IN	const DAT_LMR_TRIPLET *local_segments,
597	IN	DAT_VLEN num_segments)
598{
599	if (DAT_BAD_HANDLE(ia_handle)) {
600		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
601	}
602
603#if defined(__x86)
604	return (DAT_SUCCESS);
605#elif defined(__sparc)
606	return (DAT_LMR_SYNC_RDMA_WRITE(ia_handle, local_segments,
607		num_segments));
608#else
609#error "ISA not supported"
610#endif
611}
612
613DAT_RETURN dat_ep_create_with_srq(
614	IN	DAT_IA_HANDLE	ia_handle,
615	IN	DAT_PZ_HANDLE	pz_handle,
616	IN	DAT_EVD_HANDLE	recv_evd_handle,
617	IN	DAT_EVD_HANDLE	request_evd_handle,
618	IN	DAT_EVD_HANDLE	connect_evd_handle,
619	IN	DAT_SRQ_HANDLE	srq_handle,
620	IN	const DAT_EP_ATTR *ep_attributes,
621	OUT	DAT_EP_HANDLE	*ep_handle)
622{
623	if (DAT_BAD_HANDLE(ia_handle)) {
624		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
625	}
626	return DAT_EP_CREATE_WITH_SRQ(ia_handle,
627				pz_handle,
628				recv_evd_handle,
629				request_evd_handle,
630				connect_evd_handle,
631				srq_handle,
632				ep_attributes,
633				ep_handle);
634}
635
636DAT_RETURN dat_ep_recv_query(
637	IN	DAT_EP_HANDLE	ep_handle,
638	OUT	DAT_COUNT	*nbufs_allocated,
639	OUT	DAT_COUNT	*bufs_alloc_span)
640{
641	if (DAT_BAD_HANDLE(ep_handle)) {
642		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
643	}
644	return DAT_EP_RECV_QUERY(ep_handle,
645				nbufs_allocated,
646				bufs_alloc_span);
647}
648
649DAT_RETURN dat_ep_set_watermark(
650	IN	DAT_EP_HANDLE	ep_handle,
651	IN	DAT_COUNT	soft_high_watermark,
652	IN	DAT_COUNT	hard_high_watermark)
653{
654	if (DAT_BAD_HANDLE(ep_handle)) {
655		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP));
656	}
657	return DAT_EP_SET_WATERMARK(ep_handle,
658				soft_high_watermark,
659				hard_high_watermark);
660}
661
662DAT_RETURN dat_srq_create(
663	IN	DAT_IA_HANDLE	ia_handle,
664	IN	DAT_PZ_HANDLE	pz_handle,
665	IN	DAT_SRQ_ATTR	*srq_attr,
666	OUT	DAT_SRQ_HANDLE	*srq_handle)
667{
668	if (DAT_BAD_HANDLE(ia_handle)) {
669		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA));
670	}
671	return DAT_SRQ_CREATE(ia_handle,
672				pz_handle,
673				srq_attr,
674				srq_handle);
675}
676
677DAT_RETURN dat_srq_free(
678	IN	DAT_SRQ_HANDLE	srq_handle)
679{
680	if (DAT_BAD_HANDLE(srq_handle)) {
681		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ));
682	}
683	return (DAT_SRQ_FREE(srq_handle));
684}
685
686DAT_RETURN dat_srq_post_recv(
687	IN	DAT_SRQ_HANDLE	srq_handle,
688	IN	DAT_COUNT	num_segments,
689	IN	DAT_LMR_TRIPLET	*local_iov,
690	IN	DAT_DTO_COOKIE	user_cookie)
691{
692	if (DAT_BAD_HANDLE(srq_handle)) {
693		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ));
694	}
695	return DAT_SRQ_POST_RECV(srq_handle,
696				num_segments,
697				local_iov,
698				user_cookie);
699}
700
701DAT_RETURN dat_srq_query(
702	IN	DAT_SRQ_HANDLE		srq_handle,
703	IN	DAT_SRQ_PARAM_MASK	srq_param_mask,
704	OUT	DAT_SRQ_PARAM		*srq_param)
705{
706	if (DAT_BAD_HANDLE(srq_handle)) {
707		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ));
708	}
709	return DAT_SRQ_QUERY(srq_handle,
710			srq_param_mask,
711			srq_param);
712}
713
714DAT_RETURN dat_srq_resize(
715	IN	DAT_SRQ_HANDLE	srq_handle,
716	IN	DAT_COUNT	srq_max_recv_dto)
717{
718	if (DAT_BAD_HANDLE(srq_handle)) {
719		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ));
720	}
721	return DAT_SRQ_RESIZE(srq_handle,
722			srq_max_recv_dto);
723}
724
725DAT_RETURN dat_srq_set_lw(
726	IN	DAT_SRQ_HANDLE	srq_handle,
727	IN	DAT_COUNT	low_watermark)
728{
729	if (DAT_BAD_HANDLE(srq_handle)) {
730		return (DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ));
731	}
732	return DAT_SRQ_SET_LW(srq_handle,
733			low_watermark);
734}
735