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