Debian Codegraph @

dat/common/dat_api.c

raw
1 /*
2 * Copyright (c) 2002-2006, Network Appliance, Inc. All rights reserved.
3 *
4 * This Software is licensed under all of the following licenses:
5 *
6 * 1) under the terms of the "Common Public License 1.0" a copy of which is
7 * in the file LICENSE.txt in the root directory. The license is also
8 * available from the Open Source Initiative, see
9 * http://www.opensource.org/licenses/cpl.php.
10 *
11 * 2) under the terms of the "The BSD License" a copy of which is in the file
12 * LICENSE2.txt in the root directory. The license is also available from
13 * the Open Source Initiative, see
14 * http://www.opensource.org/licenses/bsd-license.php.
15 *
16 * 3) under the terms of the "GNU General Public License (GPL) Version 2" a
17 * copy of which is in the file LICENSE3.txt in the root directory. The
18 * license is also available from the Open Source Initiative, see
19 * http://www.opensource.org/licenses/gpl-license.php.
20 *
21 * Licensee has the right to choose one of the above licenses.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions are
25 * met:
26 *
27 * Redistributions of source code must retain the above copyright
28 * notice and one of the license notices.
29 *
30 * Redistributions in binary form must reproduce both the above copyright
31 * notice, one of the license notices in the documentation
32 * and/or other materials provided with the distribution.
33 *
34 * Neither the name of Network Appliance, Inc. nor the names of other DAT
35 * Collaborative contributors may be used to endorse or promote
36 * products derived from this software without specific prior written
37 * permission.
38 */
39
40 /**********************************************************************
41 *
42 * MODULE: dat_api.c
43 *
44 * PURPOSE: DAT Provider and Consumer registry functions.
45 * Also provide small integers for IA_HANDLES
46 *
47 * $Id: dat_api.c 1326 2005-05-20 22:25:31Z jlentini $
48 **********************************************************************/
49
50 #include <dat2/udat.h>
51 #include <dat2/dat_registry.h>
52 #include "dat_osd.h"
53 #include "dat_init.h"
54
55 /*
56 * structure to deal with IA handles
57 */
58 typedef struct {
59 DAT_OS_LOCK handle_lock;
60 unsigned long handle_max;
61 void **handle_array;
62 } DAT_HANDLE_VEC;
63
64 /*
65 * Number of IA Handle entries allocated at a time.
66 */
67 #define DAT_HANDLE_ENTRY_STEP 64
68
69 static DAT_HANDLE_VEC g_hv;
70
71 /***********************************************************************
72 * Function: dats_handle_init
73 *
74 * Initialize a handle_vector. Happens when the module initializes
75 ***********************************************************************/
76 DAT_RETURN dats_handle_vector_init(void)
77 {
78 DAT_RETURN dat_status;
79 unsigned long i;
80
81 dat_status = DAT_SUCCESS;
82
83 g_hv.handle_max = DAT_HANDLE_ENTRY_STEP;
84
85 dat_status = dat_os_lock_init(&g_hv.handle_lock);
86 if (DAT_SUCCESS != dat_status) {
87 return dat_status;
88 }
89
90 g_hv.handle_array =
91 dat_os_alloc(sizeof(void *) * DAT_HANDLE_ENTRY_STEP);
92 if (g_hv.handle_array == NULL) {
93 dat_status =
94 DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);
95 goto bail;
96 }
97
98 for (i = 0; i < g_hv.handle_max; i++) {
99 g_hv.handle_array[i] = NULL;
100 }
101
102 bail:
103 return dat_status;
104 }
105
106 /***********************************************************************
107 * Function: dats_set_ia_handle
108 *
109 * Install an ia_handle into a handle vector and return a small
110 * integer.
111 ***********************************************************************/
112 DAT_IA_HANDLE dats_set_ia_handle(IN DAT_IA_HANDLE ia_handle)
113 {
114 unsigned long i;
115 void **h;
116
117 dat_os_lock(&g_hv.handle_lock);
118
119 /*
120 * Don't give out handle zero since that is DAT_HANDLE_NULL!
121 */
122 for (i = 1; i < g_hv.handle_max; i++) {
123 if (g_hv.handle_array[i] == NULL) {
124 g_hv.handle_array[i] = ia_handle;
125
126 dat_os_unlock(&g_hv.handle_lock);
127
128 dat_os_dbg_print(DAT_OS_DBG_TYPE_PROVIDER_API,
129 "dat_set_handle %p to %d\n", ia_handle,
130 i);
131 return DAT_UL_TO_IA_HANDLE(i);
132 }
133 }
134
135 /* Didn't find an entry, grow the list & try again */
136 dat_os_dbg_print(DAT_OS_DBG_TYPE_PROVIDER_API,
137 "Growing the handle array from %d to %d\n",
138 g_hv.handle_max,
139 g_hv.handle_max + DAT_HANDLE_ENTRY_STEP);
140
141 /* reallocate the handle array */
142 h = dat_os_alloc(sizeof(void *) *
143 (g_hv.handle_max + DAT_HANDLE_ENTRY_STEP));
144 if (h == NULL) {
145 dat_os_unlock(&g_hv.handle_lock);
146 return DAT_UL_TO_IA_HANDLE(-1);
147 }
148 /* copy old data to new area & free old memory */
149 memcpy((void *)h, (void *)g_hv.handle_array,
150 sizeof(void *) * g_hv.handle_max);
151 dat_os_free(g_hv.handle_array, sizeof(void *) * g_hv.handle_max);
152 g_hv.handle_array = h;
153
154 /* Initialize the new entries */
155 for (i = g_hv.handle_max; i < g_hv.handle_max + DAT_HANDLE_ENTRY_STEP;
156 i++) {
157 g_hv.handle_array[i] = NULL;
158 }
159 i = g_hv.handle_max;
160 g_hv.handle_array[i] = ia_handle;
161 g_hv.handle_max += DAT_HANDLE_ENTRY_STEP;
162 dat_os_unlock(&g_hv.handle_lock);
163
164 dat_os_dbg_print(DAT_OS_DBG_TYPE_PROVIDER_API,
165 "dat_set_handle x %p to %d\n", ia_handle, i);
166
167 return DAT_UL_TO_IA_HANDLE(i);
168 }
169
170 /***********************************************************************
171 * Function: dats_get_ia_handle(
172 *
173 * Get handle from vector OR vector from handle, return in OUT parameter
174 *
175 ***********************************************************************/
176 DAT_RETURN
177 dats_get_ia_handle(IN DAT_IA_HANDLE handle, OUT DAT_IA_HANDLE * ia_handle_p)
178 {
179 DAT_RETURN dat_status = DAT_SUCCESS;
180
181 if (handle == NULL)
182 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
183
184 /* handle to vector */
185 if (DAT_IA_HANDLE_TO_UL(handle) >= g_hv.handle_max) {
186 unsigned long i;
187
188 dat_os_lock(&g_hv.handle_lock);
189 for (i = 1; i < g_hv.handle_max; i++) {
190 if (g_hv.handle_array[i] == handle) {
191 dat_os_unlock(&g_hv.handle_lock);
192 *ia_handle_p = DAT_UL_TO_IA_HANDLE(i);
193 goto bail;
194 }
195 }
196 dat_os_unlock(&g_hv.handle_lock);
197 dat_status = DAT_ERROR(DAT_INVALID_HANDLE,
198 DAT_INVALID_HANDLE_IA);
199 /* vector to handle */
200 } else {
201 *ia_handle_p = g_hv.handle_array[DAT_IA_HANDLE_TO_UL(handle)];
202
203 if (*ia_handle_p == NULL)
204 dat_status = DAT_ERROR(DAT_INVALID_HANDLE,
205 DAT_INVALID_HANDLE_IA);
206 }
207
208 bail:
209 dat_os_dbg_print(DAT_OS_DBG_TYPE_PROVIDER_API,
210 "dat_get_ia_handle from %d to %p\n",
211 handle, *ia_handle_p);
212
213 return dat_status;
214 }
215
216 /***********************************************************************
217 * Function: dats_is_ia_handle
218 *
219 * Unlike other handles, a DAT_IA_HANDLE is a small integer. Therefore,
220 * we must be able to distinguish between a DAT_IA_HANDLE and other
221 * types of handles (which are actually pointers).
222 *
223 * The current implementation assumes that any value for which an IA
224 * handle exists is a DAT_IA_HANDLE. Unfortunately this will result in
225 * false positives. In particular it may identify a NULL pointer as IA
226 * handle 0. An implementation that does not have this deficiency would
227 * be preferable.
228 *
229 ***********************************************************************/
230 DAT_RETURN dats_is_ia_handle(IN DAT_HANDLE dat_handle)
231 {
232 unsigned long handle = DAT_IA_HANDLE_TO_UL((DAT_IA_HANDLE) dat_handle);
233
234 if (g_hv.handle_max <= handle) {
235 return DAT_FALSE;
236 } else if (NULL == g_hv.handle_array[handle]) {
237 return DAT_FALSE;
238 } else {
239 return DAT_TRUE;
240 }
241 }
242
243 /***********************************************************************
244 * Function: dats_free_ia_handle
245 *
246 * Free a handle in a handle vector
247 ***********************************************************************/
248 DAT_RETURN dats_free_ia_handle(IN DAT_IA_HANDLE handle)
249 {
250 DAT_RETURN dat_status;
251
252 if (DAT_IA_HANDLE_TO_UL(handle) >= g_hv.handle_max) {
253 dat_status =
254 DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
255 goto bail;
256 }
257 g_hv.handle_array[DAT_IA_HANDLE_TO_UL(handle)] = NULL;
258 dat_status = DAT_SUCCESS;
259
260 dat_os_dbg_print(DAT_OS_DBG_TYPE_PROVIDER_API,
261 "dats_free_ia_handle %d\n", handle);
262
263 bail:
264 return dat_status;
265 }
266
267 /**********************************************************************
268 * API definitions for common API entry points
269 **********************************************************************/
270 DAT_RETURN DAT_API dat_ia_query(IN DAT_IA_HANDLE ia_handle,
271 OUT DAT_EVD_HANDLE * async_evd_handle,
272 IN DAT_IA_ATTR_MASK ia_attr_mask,
273 OUT DAT_IA_ATTR * ia_attr,
274 IN DAT_PROVIDER_ATTR_MASK provider_attr_mask,
275 OUT DAT_PROVIDER_ATTR * provider_attr)
276 {
277 DAT_IA_HANDLE dapl_ia_handle;
278 DAT_RETURN dat_status;
279
280 dat_status = dats_get_ia_handle(ia_handle, &dapl_ia_handle);
281 if (dat_status == DAT_SUCCESS) {
282 dat_status = DAT_IA_QUERY(dapl_ia_handle,
283 async_evd_handle,
284 ia_attr_mask,
285 ia_attr,
286 provider_attr_mask, provider_attr);
287 }
288
289 return dat_status;
290 }
291
292 DAT_RETURN DAT_API dat_set_consumer_context(IN DAT_HANDLE dat_handle,
293 IN DAT_CONTEXT context)
294 {
295 if (dat_handle == NULL) {
296 return DAT_ERROR(DAT_INVALID_HANDLE,
297 DAT_INVALID_HANDLE1);
298 }
299
300 if (dats_is_ia_handle(dat_handle)) {
301 DAT_IA_HANDLE dapl_ia_handle;
302 DAT_RETURN dat_status;
303
304 dat_status = dats_get_ia_handle((DAT_IA_HANDLE) dat_handle,
305 &dapl_ia_handle);
306
307 /* failure to map the handle is unlikely but possible */
308 /* in a mult-threaded environment */
309 if (DAT_SUCCESS != dat_status) {
310 return DAT_ERROR(DAT_INVALID_HANDLE,
311 DAT_INVALID_HANDLE1);
312 }
313
314 dat_handle = dapl_ia_handle;
315 }
316
317 return DAT_SET_CONSUMER_CONTEXT(dat_handle, context);
318 }
319
320 DAT_RETURN DAT_API dat_get_consumer_context(IN DAT_HANDLE dat_handle,
321 OUT DAT_CONTEXT * context)
322 {
323 if (dat_handle == NULL) {
324 return DAT_ERROR(DAT_INVALID_HANDLE,
325 DAT_INVALID_HANDLE1);
326 }
327
328 if (dats_is_ia_handle(dat_handle)) {
329 DAT_IA_HANDLE dapl_ia_handle;
330 DAT_RETURN dat_status;
331
332 dat_status = dats_get_ia_handle((DAT_IA_HANDLE) dat_handle,
333 &dapl_ia_handle);
334
335 /* failure to map the handle is unlikely but possible */
336 /* in a mult-threaded environment */
337 if (DAT_SUCCESS != dat_status) {
338 return DAT_ERROR(DAT_INVALID_HANDLE,
339 DAT_INVALID_HANDLE1);
340 }
341
342 dat_handle = dapl_ia_handle;
343 }
344
345 return DAT_GET_CONSUMER_CONTEXT(dat_handle, context);
346 }
347
348 DAT_RETURN DAT_API dat_get_handle_type(IN DAT_HANDLE dat_handle,
349 OUT DAT_HANDLE_TYPE * type)
350 {
351 if (dat_handle == NULL) {
352 return DAT_ERROR(DAT_INVALID_HANDLE,
353 DAT_INVALID_HANDLE1);
354 }
355
356 if (dats_is_ia_handle(dat_handle)) {
357 DAT_IA_HANDLE dapl_ia_handle;
358 DAT_RETURN dat_status;
359
360 dat_status = dats_get_ia_handle((DAT_IA_HANDLE) dat_handle,
361 &dapl_ia_handle);
362
363 /* failure to map the handle is unlikely but possible */
364 /* in a mult-threaded environment */
365 if (DAT_SUCCESS != dat_status) {
366 return DAT_ERROR(DAT_INVALID_HANDLE,
367 DAT_INVALID_HANDLE1);
368 }
369
370 dat_handle = dapl_ia_handle;
371 }
372
373 return DAT_GET_HANDLE_TYPE(dat_handle, type);
374 }
375
376 DAT_RETURN DAT_API dat_cr_query(IN DAT_CR_HANDLE cr_handle,
377 IN DAT_CR_PARAM_MASK cr_param_mask,
378 OUT DAT_CR_PARAM * cr_param)
379 {
380 if (cr_handle == NULL) {
381 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR);
382 }
383 return DAT_CR_QUERY(cr_handle, cr_param_mask, cr_param);
384 }
385
386 DAT_RETURN DAT_API dat_cr_accept(IN DAT_CR_HANDLE cr_handle,
387 IN DAT_EP_HANDLE ep_handle,
388 IN DAT_COUNT private_data_size,
389 IN const DAT_PVOID private_data)
390 {
391 if (cr_handle == NULL) {
392 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR);
393 }
394 return DAT_CR_ACCEPT(cr_handle,
395 ep_handle, private_data_size, private_data);
396 }
397
398 DAT_RETURN DAT_API dat_cr_reject(IN DAT_CR_HANDLE cr_handle,
399 IN DAT_COUNT private_data_size,
400 IN const DAT_PVOID private_data)
401 {
402 if (cr_handle == NULL) {
403 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR);
404 }
405 return DAT_CR_REJECT(cr_handle, private_data_size, private_data);
406 }
407
408 DAT_RETURN DAT_API dat_evd_resize(IN DAT_EVD_HANDLE evd_handle,
409 IN DAT_COUNT evd_min_qlen)
410 {
411 if (evd_handle == NULL) {
412 return DAT_ERROR(DAT_INVALID_HANDLE,
413 DAT_INVALID_HANDLE_EVD_REQUEST);
414 }
415 return DAT_EVD_RESIZE(evd_handle, evd_min_qlen);
416 }
417
418 DAT_RETURN DAT_API dat_evd_post_se(IN DAT_EVD_HANDLE evd_handle,
419 IN const DAT_EVENT * event)
420 {
421 if (evd_handle == NULL) {
422 return DAT_ERROR(DAT_INVALID_HANDLE,
423 DAT_INVALID_HANDLE_EVD_REQUEST);
424 }
425 return DAT_EVD_POST_SE(evd_handle, event);
426 }
427
428 DAT_RETURN DAT_API dat_evd_dequeue(IN DAT_EVD_HANDLE evd_handle,
429 OUT DAT_EVENT * event)
430 {
431 if (evd_handle == NULL) {
432 return DAT_ERROR(DAT_INVALID_HANDLE,
433 DAT_INVALID_HANDLE_EVD_REQUEST);
434 }
435 return DAT_EVD_DEQUEUE(evd_handle, event);
436 }
437
438 DAT_RETURN DAT_API dat_evd_free(IN DAT_EVD_HANDLE evd_handle)
439 {
440 if (evd_handle == NULL) {
441 return DAT_ERROR(DAT_INVALID_HANDLE,
442 DAT_INVALID_HANDLE_EVD_REQUEST);
443 }
444 return DAT_EVD_FREE(evd_handle);
445 }
446
447 DAT_RETURN DAT_API dat_evd_query(IN DAT_EVD_HANDLE evd_handle,
448 IN DAT_EVD_PARAM_MASK evd_param_mask,
449 OUT DAT_EVD_PARAM * evd_param)
450 {
451 if (evd_handle == NULL) {
452 return DAT_ERROR(DAT_INVALID_HANDLE,
453 DAT_INVALID_HANDLE_EVD_REQUEST);
454 }
455 return DAT_EVD_QUERY(evd_handle, evd_param_mask, evd_param);
456 }
457
458 DAT_RETURN DAT_API dat_ep_create(IN DAT_IA_HANDLE ia_handle,
459 IN DAT_PZ_HANDLE pz_handle,
460 IN DAT_EVD_HANDLE recv_completion_evd_handle,
461 IN DAT_EVD_HANDLE
462 request_completion_evd_handle,
463 IN DAT_EVD_HANDLE connect_evd_handle,
464 IN const DAT_EP_ATTR * ep_attributes,
465 OUT DAT_EP_HANDLE * ep_handle)
466 {
467 DAT_IA_HANDLE dapl_ia_handle;
468 DAT_RETURN dat_status;
469
470 dat_status = dats_get_ia_handle(ia_handle, &dapl_ia_handle);
471 if (dat_status == DAT_SUCCESS) {
472 dat_status = DAT_EP_CREATE(dapl_ia_handle,
473 pz_handle,
474 recv_completion_evd_handle,
475 request_completion_evd_handle,
476 connect_evd_handle,
477 ep_attributes, ep_handle);
478 }
479
480 return dat_status;
481 }
482
483 DAT_RETURN DAT_API dat_ep_query(IN DAT_EP_HANDLE ep_handle,
484 IN DAT_EP_PARAM_MASK ep_param_mask,
485 OUT DAT_EP_PARAM * ep_param)
486 {
487 if (ep_handle == NULL) {
488 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
489 }
490 return DAT_EP_QUERY(ep_handle, ep_param_mask, ep_param);
491 }
492
493 DAT_RETURN DAT_API dat_ep_modify(IN DAT_EP_HANDLE ep_handle,
494 IN DAT_EP_PARAM_MASK ep_param_mask,
495 IN const DAT_EP_PARAM * ep_param)
496 {
497 if (ep_handle == NULL) {
498 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
499 }
500 return DAT_EP_MODIFY(ep_handle, ep_param_mask, ep_param);
501 }
502
503 DAT_RETURN DAT_API dat_ep_connect(IN DAT_EP_HANDLE ep_handle,
504 IN DAT_IA_ADDRESS_PTR remote_ia_address,
505 IN DAT_CONN_QUAL remote_conn_qual,
506 IN DAT_TIMEOUT timeout,
507 IN DAT_COUNT private_data_size,
508 IN const DAT_PVOID private_data,
509 IN DAT_QOS quality_of_service,
510 IN DAT_CONNECT_FLAGS connect_flags)
511 {
512 if (ep_handle == NULL) {
513 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
514 }
515 return DAT_EP_CONNECT(ep_handle,
516 remote_ia_address,
517 remote_conn_qual,
518 timeout,
519 private_data_size,
520 private_data, quality_of_service, connect_flags);
521 }
522
523 DAT_RETURN DAT_API dat_ep_common_connect(IN DAT_EP_HANDLE ep_handle,
524 IN DAT_IA_ADDRESS_PTR
525 remote_ia_address,
526 IN DAT_TIMEOUT timeout,
527 IN DAT_COUNT private_data_size,
528 IN const DAT_PVOID private_data)
529 {
530 if (ep_handle == NULL) {
531 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
532 }
533 return DAT_EP_COMMON_CONNECT(ep_handle,
534 remote_ia_address,
535 timeout, private_data_size, private_data);
536 }
537
538 DAT_RETURN DAT_API dat_ep_dup_connect(IN DAT_EP_HANDLE ep_handle,
539 IN DAT_EP_HANDLE ep_dup_handle,
540 IN DAT_TIMEOUT timeout,
541 IN DAT_COUNT private_data_size,
542 IN const DAT_PVOID private_data,
543 IN DAT_QOS quality_of_service)
544 {
545 if (ep_handle == NULL) {
546 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
547 }
548 return DAT_EP_DUP_CONNECT(ep_handle,
549 ep_dup_handle,
550 timeout,
551 private_data_size,
552 private_data, quality_of_service);
553 }
554
555 DAT_RETURN DAT_API dat_ep_disconnect(IN DAT_EP_HANDLE ep_handle,
556 IN DAT_CLOSE_FLAGS close_flags)
557 {
558 if (ep_handle == NULL) {
559 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
560 }
561 return DAT_EP_DISCONNECT(ep_handle, close_flags);
562 }
563
564 DAT_RETURN DAT_API dat_ep_post_send(IN DAT_EP_HANDLE ep_handle,
565 IN DAT_COUNT num_segments,
566 IN DAT_LMR_TRIPLET * local_iov,
567 IN DAT_DTO_COOKIE user_cookie,
568 IN DAT_COMPLETION_FLAGS completion_flags)
569 {
570 if (ep_handle == NULL) {
571 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
572 }
573 return DAT_EP_POST_SEND(ep_handle,
574 num_segments,
575 local_iov, user_cookie, completion_flags);
576 }
577
578 DAT_RETURN DAT_API dat_ep_post_send_with_invalidate(IN DAT_EP_HANDLE ep_handle,
579 IN DAT_COUNT num_segments,
580 IN DAT_LMR_TRIPLET *
581 local_iov,
582 IN DAT_DTO_COOKIE
583 user_cookie,
584 IN DAT_COMPLETION_FLAGS
585 completion_flags,
586 IN DAT_BOOLEAN
587 invalidate_flag,
588 IN DAT_RMR_CONTEXT
589 rmr_context)
590 {
591 if (ep_handle == NULL) {
592 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
593 }
594 return DAT_EP_POST_SEND_WITH_INVALIDATE(ep_handle,
595 num_segments,
596 local_iov,
597 user_cookie,
598 completion_flags,
599 invalidate_flag, rmr_context);
600 }
601
602 DAT_RETURN DAT_API dat_ep_post_recv(IN DAT_EP_HANDLE ep_handle,
603 IN DAT_COUNT num_segments,
604 IN DAT_LMR_TRIPLET * local_iov,
605 IN DAT_DTO_COOKIE user_cookie,
606 IN DAT_COMPLETION_FLAGS completion_flags)
607 {
608 if (ep_handle == NULL) {
609 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
610 }
611 return DAT_EP_POST_RECV(ep_handle,
612 num_segments,
613 local_iov, user_cookie, completion_flags);
614 }
615
616 DAT_RETURN DAT_API dat_ep_post_rdma_read(IN DAT_EP_HANDLE ep_handle,
617 IN DAT_COUNT num_segments,
618 IN DAT_LMR_TRIPLET * local_iov,
619 IN DAT_DTO_COOKIE user_cookie,
620 IN const DAT_RMR_TRIPLET * remote_iov,
621 IN DAT_COMPLETION_FLAGS
622 completion_flags)
623 {
624 if (ep_handle == NULL) {
625 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
626 }
627 return DAT_EP_POST_RDMA_READ(ep_handle,
628 num_segments,
629 local_iov,
630 user_cookie, remote_iov, completion_flags);
631 }
632
633 DAT_RETURN DAT_API dat_ep_post_rdma_read_to_rmr(IN DAT_EP_HANDLE ep_handle,
634 IN const DAT_RMR_TRIPLET *
635 local_iov,
636 IN DAT_DTO_COOKIE user_cookie,
637 IN const DAT_RMR_TRIPLET *
638 remote_iov,
639 IN DAT_COMPLETION_FLAGS
640 completion_flags)
641 {
642 if (ep_handle == NULL) {
643 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
644 }
645 return DAT_EP_POST_RDMA_READ_TO_RMR(ep_handle,
646 local_iov,
647 user_cookie,
648 remote_iov, completion_flags);
649 }
650
651 DAT_RETURN DAT_API dat_ep_post_rdma_write(IN DAT_EP_HANDLE ep_handle,
652 IN DAT_COUNT num_segments,
653 IN DAT_LMR_TRIPLET * local_iov,
654 IN DAT_DTO_COOKIE user_cookie,
655 IN const DAT_RMR_TRIPLET * remote_iov,
656 IN DAT_COMPLETION_FLAGS
657 completion_flags)
658 {
659 if (ep_handle == NULL) {
660 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
661 }
662 return DAT_EP_POST_RDMA_WRITE(ep_handle,
663 num_segments,
664 local_iov,
665 user_cookie,
666 remote_iov, completion_flags);
667 }
668
669 DAT_RETURN DAT_API dat_ep_get_status(IN DAT_EP_HANDLE ep_handle,
670 OUT DAT_EP_STATE * ep_state,
671 OUT DAT_BOOLEAN * recv_idle,
672 OUT DAT_BOOLEAN * request_idle)
673 {
674 if (ep_handle == NULL) {
675 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
676 }
677 return DAT_EP_GET_STATUS(ep_handle, ep_state, recv_idle, request_idle);
678 }
679
680 DAT_RETURN DAT_API dat_ep_free(IN DAT_EP_HANDLE ep_handle)
681 {
682 if (ep_handle == NULL) {
683 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
684 }
685 return DAT_EP_FREE(ep_handle);
686 }
687
688 DAT_RETURN DAT_API dat_ep_reset(IN DAT_EP_HANDLE ep_handle)
689 {
690 if (ep_handle == NULL) {
691 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
692 }
693 return DAT_EP_RESET(ep_handle);
694 }
695
696 DAT_RETURN DAT_API dat_lmr_free(IN DAT_LMR_HANDLE lmr_handle)
697 {
698 if (lmr_handle == NULL) {
699 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_LMR);
700 }
701 return DAT_LMR_FREE(lmr_handle);
702 }
703
704 DAT_RETURN DAT_API dat_rmr_create(IN DAT_PZ_HANDLE pz_handle,
705 OUT DAT_RMR_HANDLE * rmr_handle)
706 {
707 if (pz_handle == NULL) {
708 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ);
709 }
710 return DAT_RMR_CREATE(pz_handle, rmr_handle);
711 }
712
713 DAT_RETURN DAT_API dat_rmr_create_for_ep(IN DAT_PZ_HANDLE pz_handle,
714 OUT DAT_RMR_HANDLE * rmr_handle)
715 {
716 if (pz_handle == NULL) {
717 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ);
718 }
719 return DAT_RMR_CREATE_FOR_EP(pz_handle, rmr_handle);
720 }
721 DAT_RETURN DAT_API dat_rmr_query(IN DAT_RMR_HANDLE rmr_handle,
722 IN DAT_RMR_PARAM_MASK rmr_param_mask,
723 OUT DAT_RMR_PARAM * rmr_param)
724 {
725 if (rmr_handle == NULL) {
726 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RMR);
727 }
728 return DAT_RMR_QUERY(rmr_handle, rmr_param_mask, rmr_param);
729 }
730
731 DAT_RETURN DAT_API dat_rmr_bind(IN DAT_RMR_HANDLE rmr_handle,
732 IN DAT_LMR_HANDLE lmr_handle,
733 IN const DAT_LMR_TRIPLET * lmr_triplet,
734 IN DAT_MEM_PRIV_FLAGS mem_priv,
735 IN DAT_VA_TYPE va_type,
736 IN DAT_EP_HANDLE ep_handle,
737 IN DAT_RMR_COOKIE user_cookie,
738 IN DAT_COMPLETION_FLAGS completion_flags,
739 OUT DAT_RMR_CONTEXT * context)
740 {
741 if (rmr_handle == NULL) {
742 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RMR);
743 }
744 return DAT_RMR_BIND(rmr_handle,
745 lmr_handle,
746 lmr_triplet,
747 mem_priv,
748 va_type,
749 ep_handle, user_cookie, completion_flags, context);
750 }
751
752 DAT_RETURN DAT_API dat_rmr_free(IN DAT_RMR_HANDLE rmr_handle)
753 {
754 if (rmr_handle == NULL) {
755 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RMR);
756 }
757 return DAT_RMR_FREE(rmr_handle);
758 }
759
760 DAT_RETURN DAT_API dat_lmr_sync_rdma_read(IN DAT_IA_HANDLE ia_handle,
761 IN const DAT_LMR_TRIPLET *
762 local_segments,
763 IN DAT_VLEN num_segments)
764 {
765 DAT_IA_HANDLE dapl_ia_handle;
766 DAT_RETURN dat_status;
767
768 dat_status = dats_get_ia_handle(ia_handle, &dapl_ia_handle);
769 if (dat_status == DAT_SUCCESS) {
770 dat_status = DAT_LMR_SYNC_RDMA_READ(dapl_ia_handle,
771 local_segments,
772 num_segments);
773
774 }
775
776 return dat_status;
777 }
778
779 DAT_RETURN DAT_API dat_lmr_sync_rdma_write(IN DAT_IA_HANDLE ia_handle,
780 IN const DAT_LMR_TRIPLET *
781 local_segments,
782 IN DAT_VLEN num_segments)
783 {
784 DAT_IA_HANDLE dapl_ia_handle;
785 DAT_RETURN dat_status;
786
787 dat_status = dats_get_ia_handle(ia_handle, &dapl_ia_handle);
788 if (dat_status == DAT_SUCCESS) {
789 dat_status = DAT_LMR_SYNC_RDMA_WRITE(dapl_ia_handle,
790 local_segments,
791 num_segments);
792 }
793
794 return dat_status;
795 }
796
797 DAT_RETURN DAT_API dat_psp_create(IN DAT_IA_HANDLE ia_handle,
798 IN DAT_CONN_QUAL conn_qual,
799 IN DAT_EVD_HANDLE evd_handle,
800 IN DAT_PSP_FLAGS psp_flags,
801 OUT DAT_PSP_HANDLE * psp_handle)
802 {
803 DAT_IA_HANDLE dapl_ia_handle;
804 DAT_RETURN dat_status;
805
806 dat_status = dats_get_ia_handle(ia_handle, &dapl_ia_handle);
807 if (dat_status == DAT_SUCCESS) {
808 dat_status = DAT_PSP_CREATE(dapl_ia_handle,
809 conn_qual,
810 evd_handle, psp_flags, psp_handle);
811 }
812
813 return dat_status;
814 }
815
816 DAT_RETURN DAT_API dat_psp_create_any(IN DAT_IA_HANDLE ia_handle,
817 OUT DAT_CONN_QUAL * conn_qual,
818 IN DAT_EVD_HANDLE evd_handle,
819 IN DAT_PSP_FLAGS psp_flags,
820 OUT DAT_PSP_HANDLE * psp_handle)
821 {
822 DAT_IA_HANDLE dapl_ia_handle;
823 DAT_RETURN dat_status;
824
825 dat_status = dats_get_ia_handle(ia_handle, &dapl_ia_handle);
826 if (dat_status == DAT_SUCCESS) {
827 dat_status = DAT_PSP_CREATE_ANY(dapl_ia_handle,
828 conn_qual,
829 evd_handle,
830 psp_flags, psp_handle);
831 }
832
833 return dat_status;
834 }
835
836 DAT_RETURN DAT_API dat_psp_query(IN DAT_PSP_HANDLE psp_handle,
837 IN DAT_PSP_PARAM_MASK psp_param_mask,
838 OUT DAT_PSP_PARAM * psp_param)
839 {
840 if (psp_handle == NULL) {
841 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PSP);
842 }
843 return DAT_PSP_QUERY(psp_handle, psp_param_mask, psp_param);
844 }
845
846 DAT_RETURN DAT_API dat_psp_free(IN DAT_PSP_HANDLE psp_handle)
847 {
848 if (psp_handle == NULL) {
849 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PSP);
850 }
851 return DAT_PSP_FREE(psp_handle);
852 }
853
854 DAT_RETURN DAT_API dat_csp_create(IN DAT_IA_HANDLE ia_handle,
855 IN DAT_COMM * comm,
856 IN DAT_IA_ADDRESS_PTR address,
857 IN DAT_EVD_HANDLE evd_handle,
858 OUT DAT_CSP_HANDLE * csp_handle)
859 {
860 DAT_IA_HANDLE dapl_ia_handle;
861 DAT_RETURN dat_status;
862
863 dat_status = dats_get_ia_handle(ia_handle, &dapl_ia_handle);
864 if (dat_status == DAT_SUCCESS) {
865 dat_status = DAT_CSP_CREATE(dapl_ia_handle,
866 comm,
867 address, evd_handle, csp_handle);
868 }
869 return dat_status;
870 }
871
872 DAT_RETURN DAT_API dat_csp_query(IN DAT_CSP_HANDLE csp_handle,
873 IN DAT_CSP_PARAM_MASK csp_param_mask,
874 OUT DAT_CSP_PARAM * csp_param)
875 {
876 if (csp_handle == NULL) {
877 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CSP);
878 }
879 return DAT_CSP_QUERY(csp_handle, csp_param_mask, csp_param);
880 }
881
882 DAT_RETURN DAT_API dat_csp_free(IN DAT_CSP_HANDLE csp_handle)
883 {
884 if (csp_handle == NULL) {
885 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CSP);
886 }
887 return DAT_CSP_FREE(csp_handle);
888 }
889
890 DAT_RETURN DAT_API dat_rsp_create(IN DAT_IA_HANDLE ia_handle,
891 IN DAT_CONN_QUAL conn_qual,
892 IN DAT_EP_HANDLE ep_handle,
893 IN DAT_EVD_HANDLE evd_handle,
894 OUT DAT_RSP_HANDLE * rsp_handle)
895 {
896 DAT_IA_HANDLE dapl_ia_handle;
897 DAT_RETURN dat_status;
898
899 dat_status = dats_get_ia_handle(ia_handle, &dapl_ia_handle);
900 if (dat_status == DAT_SUCCESS) {
901 dat_status = DAT_RSP_CREATE(dapl_ia_handle,
902 conn_qual,
903 ep_handle, evd_handle, rsp_handle);
904 }
905
906 return dat_status;
907 }
908
909 DAT_RETURN DAT_API dat_rsp_query(IN DAT_RSP_HANDLE rsp_handle,
910 IN DAT_RSP_PARAM_MASK rsp_param_mask,
911 OUT DAT_RSP_PARAM * rsp_param)
912 {
913 if (rsp_handle == NULL) {
914 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RSP);
915 }
916 return DAT_RSP_QUERY(rsp_handle, rsp_param_mask, rsp_param);
917 }
918
919 DAT_RETURN DAT_API dat_rsp_free(IN DAT_RSP_HANDLE rsp_handle)
920 {
921 if (rsp_handle == NULL) {
922 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RSP);
923 }
924 return DAT_RSP_FREE(rsp_handle);
925 }
926
927 DAT_RETURN DAT_API dat_pz_create(IN DAT_IA_HANDLE ia_handle,
928 OUT DAT_PZ_HANDLE * pz_handle)
929 {
930 DAT_IA_HANDLE dapl_ia_handle;
931 DAT_RETURN dat_status;
932
933 dat_status = dats_get_ia_handle(ia_handle, &dapl_ia_handle);
934 if (dat_status == DAT_SUCCESS) {
935 dat_status = DAT_PZ_CREATE(dapl_ia_handle, pz_handle);
936 }
937
938 return dat_status;
939 }
940
941 DAT_RETURN DAT_API dat_pz_query(IN DAT_PZ_HANDLE pz_handle,
942 IN DAT_PZ_PARAM_MASK pz_param_mask,
943 OUT DAT_PZ_PARAM * pz_param)
944 {
945 if (pz_handle == NULL) {
946 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ);
947 }
948 return DAT_PZ_QUERY(pz_handle, pz_param_mask, pz_param);
949 }
950
951 DAT_RETURN DAT_API dat_pz_free(IN DAT_PZ_HANDLE pz_handle)
952 {
953 if (pz_handle == NULL) {
954 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ);
955 }
956 return DAT_PZ_FREE(pz_handle);
957 }
958
959 DAT_RETURN DAT_API dat_ep_create_with_srq(IN DAT_IA_HANDLE ia_handle,
960 IN DAT_PZ_HANDLE pz_handle,
961 IN DAT_EVD_HANDLE recv_evd_handle,
962 IN DAT_EVD_HANDLE request_evd_handle,
963 IN DAT_EVD_HANDLE connect_evd_handle,
964 IN DAT_SRQ_HANDLE srq_handle,
965 IN const DAT_EP_ATTR * ep_attributes,
966 OUT DAT_EP_HANDLE * ep_handle)
967 {
968 DAT_IA_HANDLE dapl_ia_handle;
969 DAT_RETURN dat_status;
970
971 dat_status = dats_get_ia_handle(ia_handle, &dapl_ia_handle);
972 if (dat_status == DAT_SUCCESS) {
973 dat_status = DAT_EP_CREATE_WITH_SRQ(dapl_ia_handle,
974 pz_handle,
975 recv_evd_handle,
976 request_evd_handle,
977 connect_evd_handle,
978 srq_handle,
979 ep_attributes, ep_handle);
980 }
981
982 return dat_status;
983 }
984
985 DAT_RETURN DAT_API dat_ep_recv_query(IN DAT_EP_HANDLE ep_handle,
986 OUT DAT_COUNT * nbufs_allocated,
987 OUT DAT_COUNT * bufs_alloc_span)
988 {
989 if (ep_handle == NULL) {
990 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
991 }
992 return DAT_EP_RECV_QUERY(ep_handle, nbufs_allocated, bufs_alloc_span);
993 }
994
995 DAT_RETURN DAT_API dat_ep_set_watermark(IN DAT_EP_HANDLE ep_handle,
996 IN DAT_COUNT soft_high_watermark,
997 IN DAT_COUNT hard_high_watermark)
998 {
999 if (ep_handle == NULL) {
1000 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
1001 }
1002 return DAT_EP_SET_WATERMARK(ep_handle,
1003 soft_high_watermark, hard_high_watermark);
1004 }
1005
1006 /* SRQ functions */
1007
1008 DAT_RETURN DAT_API dat_srq_create(IN DAT_IA_HANDLE ia_handle,
1009 IN DAT_PZ_HANDLE pz_handle,
1010 IN DAT_SRQ_ATTR * srq_attr,
1011 OUT DAT_SRQ_HANDLE * srq_handle)
1012 {
1013 DAT_IA_HANDLE dapl_ia_handle;
1014 DAT_RETURN dat_status;
1015
1016 dat_status = dats_get_ia_handle(ia_handle, &dapl_ia_handle);
1017 if (dat_status == DAT_SUCCESS) {
1018 dat_status = DAT_SRQ_CREATE(dapl_ia_handle,
1019 pz_handle, srq_attr, srq_handle);
1020 }
1021
1022 return dat_status;
1023 }
1024
1025 DAT_RETURN DAT_API dat_srq_free(IN DAT_SRQ_HANDLE srq_handle)
1026 {
1027 if (srq_handle == NULL) {
1028 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ);
1029 }
1030 return DAT_SRQ_FREE(srq_handle);
1031 }
1032
1033 DAT_RETURN DAT_API dat_srq_post_recv(IN DAT_SRQ_HANDLE srq_handle,
1034 IN DAT_COUNT num_segments,
1035 IN DAT_LMR_TRIPLET * local_iov,
1036 IN DAT_DTO_COOKIE user_cookie)
1037 {
1038 if (srq_handle == NULL) {
1039 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ);
1040 }
1041 return DAT_SRQ_POST_RECV(srq_handle,
1042 num_segments, local_iov, user_cookie);
1043 }
1044
1045 DAT_RETURN DAT_API dat_srq_query(IN DAT_SRQ_HANDLE srq_handle,
1046 IN DAT_SRQ_PARAM_MASK srq_param_mask,
1047 OUT DAT_SRQ_PARAM * srq_param)
1048 {
1049 if (srq_handle == NULL) {
1050 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ);
1051 }
1052 return DAT_SRQ_QUERY(srq_handle, srq_param_mask, srq_param);
1053 }
1054
1055 DAT_RETURN DAT_API dat_srq_resize(IN DAT_SRQ_HANDLE srq_handle,
1056 IN DAT_COUNT srq_max_recv_dto)
1057 {
1058 if (srq_handle == NULL) {
1059 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ);
1060 }
1061 return DAT_SRQ_RESIZE(srq_handle, srq_max_recv_dto);
1062 }
1063
1064 DAT_RETURN DAT_API dat_srq_set_lw(IN DAT_SRQ_HANDLE srq_handle,
1065 IN DAT_COUNT low_watermark)
1066 {
1067 if (srq_handle == NULL) {
1068 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ);
1069 }
1070 return DAT_SRQ_SET_LW(srq_handle, low_watermark);
1071 }
1072
1073 #ifdef DAT_EXTENSIONS
1074
1075 extern int g_dat_extensions;
1076 extern DAT_RETURN udat_extension_open(IN const DAT_NAME_PTR name,
1077 IN DAT_EXTENDED_OP ext_op,
1078 IN va_list args);
1079 extern DAT_RETURN udat_extension_close(IN const DAT_NAME_PTR name,
1080 IN DAT_EXTENDED_OP ext_op,
1081 IN va_list args);
1082
1083 /* Consumer API - dat_extension_op()
1084 *
1085 * Handle == IA, EP, EVD, etc
1086 * !Handle == direct extension operation to provider without device open
1087 * provider name supplied for linkage to library
1088 *
1089 */
1090 DAT_RETURN DAT_API dat_extension_op(IN DAT_HANDLE handle,
1091 IN DAT_EXTENDED_OP ext_op, IN ...)
1092 {
1093 DAT_RETURN status;
1094 DAT_IA_HANDLE dapl_handle = handle;
1095 va_list args;
1096
1097 dat_os_dbg_print(DAT_OS_DBG_TYPE_CONSUMER_API,
1098 " dat_extension_op: (handle %p, op %d) called\n",
1099 handle, ext_op);
1100
1101 /* only convert if ia_handle vector */
1102 if (handle && dats_is_ia_handle(handle)) {
1103 if (dats_get_ia_handle(handle, &dapl_handle))
1104 return DAT_ERROR(DAT_INVALID_HANDLE,
1105 DAT_INVALID_HANDLE1);
1106 }
1107
1108 dat_os_dbg_print(DAT_OS_DBG_TYPE_CONSUMER_API,
1109 " dat_extension_op: dapl_handle %p \n", handle);
1110
1111 /* verify provider extension support, if open */
1112 if (dapl_handle && !g_dat_extensions)
1113 return DAT_ERROR(DAT_NOT_IMPLEMENTED, 0);
1114
1115 /* extension will validate the handle based on op */
1116 va_start(args, ext_op);
1117 if (ext_op & DAT_OPEN_EXTENSION_BASE) {
1118 const DAT_NAME_PTR name = va_arg(args, const DAT_NAME_PTR);
1119
1120 dat_os_dbg_print(DAT_OS_DBG_TYPE_CONSUMER_API,
1121 " call udat_ext_open: (name %p, %s op %d) called\n",
1122 name, name, handle, ext_op);
1123 if (name == NULL)
1124 status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_ARG3);
1125 else
1126 status = udat_extension_open(name, ext_op, args);
1127
1128 } else if (ext_op & DAT_CLOSE_EXTENSION_BASE) {
1129 dat_os_dbg_print(DAT_OS_DBG_TYPE_CONSUMER_API,
1130 " call udat_ext_close: handle %p\n", handle);
1131 status = udat_extension_close(handle, ext_op, args);
1132 } else {
1133 if (dapl_handle == NULL)
1134 return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE1);
1135
1136 dat_os_dbg_print(DAT_OS_DBG_TYPE_CONSUMER_API,
1137 " call dat_ext_op: handle %p\n", dapl_handle);
1138
1139 status = DAT_HANDLE_EXTENDEDOP(dapl_handle, ext_op, args);
1140 }
1141 va_end(args);
1142 return status;
1143 }
1144 #endif
1145
1146 /*
1147 * Local variables:
1148 * c-indent-level: 4
1149 * c-basic-offset: 4
1150 * tab-width: 8
1151 * End:
1152 */