From d0898091090ff19be7929fed0d14f1ca696d5e53 Mon Sep 17 00:00:00 2001 From: Arlin Davis Date: Tue, 21 Apr 2009 15:39:01 -0700 Subject: [PATCH] udapl: Cleanup code with Lindent Signed-off-by: Arlin Davis --- dapl/udapl/dapl_cno_create.c | 62 +- dapl/udapl/dapl_cno_free.c | 45 +- dapl/udapl/dapl_cno_modify_agent.c | 37 +- dapl/udapl/dapl_cno_query.c | 48 +- dapl/udapl/dapl_cno_wait.c | 118 ++-- dapl/udapl/dapl_evd_clear_unwaitable.c | 35 +- dapl/udapl/dapl_evd_create.c | 217 ++++--- dapl/udapl/dapl_evd_disable.c | 28 +- dapl/udapl/dapl_evd_enable.c | 49 +- dapl/udapl/dapl_evd_modify_cno.c | 89 ++- dapl/udapl/dapl_evd_query.c | 92 ++- dapl/udapl/dapl_evd_set_unwaitable.c | 59 +- dapl/udapl/dapl_evd_wait.c | 391 ++++++------ dapl/udapl/dapl_init.c | 366 ++++++----- dapl/udapl/dapl_lmr_create.c | 822 ++++++++++++------------- dapl/udapl/linux/dapl_osd.c | 708 ++++++++++----------- dapl/udapl/udapl_sources.c | 1 - 17 files changed, 1507 insertions(+), 1660 deletions(-) diff --git a/dapl/udapl/dapl_cno_create.c b/dapl/udapl/dapl_cno_create.c index 088992a..a214c33 100644 --- a/dapl/udapl/dapl_cno_create.c +++ b/dapl/udapl/dapl_cno_create.c @@ -61,45 +61,41 @@ * DAT_INVALID_HANDLE * DAT_INVALID_PARAMETER */ -DAT_RETURN DAT_API dapl_cno_create( - IN DAT_IA_HANDLE ia_handle, /* ia_handle */ - IN DAT_OS_WAIT_PROXY_AGENT wait_agent, /* agent */ - OUT DAT_CNO_HANDLE *cno_handle) /* cno_handle */ +DAT_RETURN DAT_API dapl_cno_create(IN DAT_IA_HANDLE ia_handle, /* ia_handle */ + IN DAT_OS_WAIT_PROXY_AGENT wait_agent, /* agent */ + OUT DAT_CNO_HANDLE * cno_handle) +{ /* cno_handle */ + DAPL_IA *ia_ptr; + DAPL_CNO *cno_ptr; + DAT_RETURN dat_status; -{ - DAPL_IA *ia_ptr; - DAPL_CNO *cno_ptr; - DAT_RETURN dat_status; + ia_ptr = (DAPL_IA *) ia_handle; + cno_ptr = NULL; + dat_status = DAT_SUCCESS; - ia_ptr = (DAPL_IA *)ia_handle; - cno_ptr = NULL; - dat_status = DAT_SUCCESS; + if (DAPL_BAD_HANDLE(ia_handle, DAPL_MAGIC_IA)) { + dat_status = + DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA); + goto bail; + } - if (DAPL_BAD_HANDLE (ia_handle, DAPL_MAGIC_IA)) - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE,DAT_INVALID_HANDLE_IA); - goto bail; - } + cno_ptr = dapl_cno_alloc(ia_ptr, wait_agent); - cno_ptr = dapl_cno_alloc(ia_ptr, wait_agent); + if (!cno_ptr) { + dat_status = + DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY); + goto bail; + } - if (!cno_ptr) - { - dat_status = DAT_ERROR (DAT_INSUFFICIENT_RESOURCES,DAT_RESOURCE_MEMORY); - goto bail; - } + cno_ptr->cno_state = DAPL_CNO_STATE_UNTRIGGERED; - cno_ptr->cno_state = DAPL_CNO_STATE_UNTRIGGERED; + dapl_ia_link_cno(ia_ptr, cno_ptr); - dapl_ia_link_cno(ia_ptr, cno_ptr); + *cno_handle = cno_ptr; - *cno_handle = cno_ptr; - - bail: - if (dat_status != DAT_SUCCESS && cno_ptr != NULL) - { - dapl_cno_dealloc(cno_ptr); - } - return dat_status; + bail: + if (dat_status != DAT_SUCCESS && cno_ptr != NULL) { + dapl_cno_dealloc(cno_ptr); + } + return dat_status; } - diff --git a/dapl/udapl/dapl_cno_free.c b/dapl/udapl/dapl_cno_free.c index 053bde6..572fb98 100644 --- a/dapl/udapl/dapl_cno_free.c +++ b/dapl/udapl/dapl_cno_free.c @@ -58,33 +58,30 @@ * DAT_INVALID_HANDLE * DAT_INVALID_STATE */ -DAT_RETURN DAT_API dapl_cno_free( - IN DAT_CNO_HANDLE cno_handle) /* cno_handle */ +DAT_RETURN DAT_API dapl_cno_free(IN DAT_CNO_HANDLE cno_handle) +{ /* cno_handle */ + DAPL_CNO *cno_ptr; + DAT_RETURN dat_status; -{ - DAPL_CNO *cno_ptr; - DAT_RETURN dat_status; + dat_status = DAT_SUCCESS; + cno_ptr = (DAPL_CNO *) cno_handle; - dat_status = DAT_SUCCESS; - cno_ptr = (DAPL_CNO *)cno_handle; + if (DAPL_BAD_HANDLE(cno_handle, DAPL_MAGIC_CNO)) { + dat_status = + DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CNO); + goto bail; + } - if (DAPL_BAD_HANDLE (cno_handle, DAPL_MAGIC_CNO)) - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE,DAT_INVALID_HANDLE_CNO); - goto bail; - } + if (dapl_os_atomic_read(&cno_ptr->cno_ref_count) != 0 + || cno_ptr->cno_waiters != 0) { + dat_status = + DAT_ERROR(DAT_INVALID_STATE, DAT_INVALID_STATE_CNO_IN_USE); + goto bail; + } - if (dapl_os_atomic_read(&cno_ptr->cno_ref_count) != 0 - || cno_ptr->cno_waiters != 0) - { - dat_status = DAT_ERROR (DAT_INVALID_STATE,DAT_INVALID_STATE_CNO_IN_USE); - goto bail; - } + dapl_ia_unlink_cno(cno_ptr->header.owner_ia, cno_ptr); + dapl_cno_dealloc(cno_ptr); - dapl_ia_unlink_cno (cno_ptr->header.owner_ia, cno_ptr); - dapl_cno_dealloc (cno_ptr); - -bail: - return dat_status; + bail: + return dat_status; } - diff --git a/dapl/udapl/dapl_cno_modify_agent.c b/dapl/udapl/dapl_cno_modify_agent.c index c4847ff..887e984 100644 --- a/dapl/udapl/dapl_cno_modify_agent.c +++ b/dapl/udapl/dapl_cno_modify_agent.c @@ -57,27 +57,24 @@ * DAT_INVALID_HANDLE * DAT_INVALID_PARAMETER */ -DAT_RETURN DAT_API dapl_cno_modify_agent( - IN DAT_CNO_HANDLE cno_handle, /* cno_handle */ - IN DAT_OS_WAIT_PROXY_AGENT prx_agent ) /* agent */ +DAT_RETURN DAT_API dapl_cno_modify_agent(IN DAT_CNO_HANDLE cno_handle, /* cno_handle */ + IN DAT_OS_WAIT_PROXY_AGENT prx_agent) +{ /* agent */ + DAPL_CNO *cno_ptr; + DAT_RETURN dat_status; -{ - DAPL_CNO *cno_ptr; - DAT_RETURN dat_status; + dat_status = DAT_SUCCESS; + if (DAPL_BAD_HANDLE(cno_handle, DAPL_MAGIC_CNO)) { + dat_status = + DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CNO); + goto bail; + } - dat_status = DAT_SUCCESS; - if ( DAPL_BAD_HANDLE (cno_handle, DAPL_MAGIC_CNO) ) - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE,DAT_INVALID_HANDLE_CNO); - goto bail; - } + cno_ptr = (DAPL_CNO *) cno_handle; + dapl_os_lock(&cno_ptr->header.lock); + cno_ptr->cno_wait_agent = prx_agent; + dapl_os_unlock(&cno_ptr->header.lock); - cno_ptr = (DAPL_CNO *) cno_handle; - dapl_os_lock(&cno_ptr->header.lock); - cno_ptr->cno_wait_agent = prx_agent; - dapl_os_unlock(&cno_ptr->header.lock); - - bail: - return dat_status; + bail: + return dat_status; } - diff --git a/dapl/udapl/dapl_cno_query.c b/dapl/udapl/dapl_cno_query.c index b7275be..5112e33 100644 --- a/dapl/udapl/dapl_cno_query.c +++ b/dapl/udapl/dapl_cno_query.c @@ -61,36 +61,32 @@ * DAT_INVALID_HANDLE * DAT_INVALID_PARAMETER */ -DAT_RETURN DAT_API dapl_cno_query( - IN DAT_CNO_HANDLE cno_handle, /* cno_handle */ - IN DAT_CNO_PARAM_MASK cno_param_mask, /* cno_param_mask */ - OUT DAT_CNO_PARAM *cno_param ) /* cno_param */ +DAT_RETURN DAT_API dapl_cno_query(IN DAT_CNO_HANDLE cno_handle, /* cno_handle */ + IN DAT_CNO_PARAM_MASK cno_param_mask, /* cno_param_mask */ + OUT DAT_CNO_PARAM * cno_param) +{ /* cno_param */ + DAPL_CNO *cno_ptr; + DAT_RETURN dat_status; -{ - DAPL_CNO *cno_ptr; - DAT_RETURN dat_status; + dat_status = DAT_SUCCESS; - dat_status = DAT_SUCCESS; + if (DAPL_BAD_HANDLE(cno_handle, DAPL_MAGIC_CNO)) { + dat_status = + DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CNO); + goto bail; + } - if ( DAPL_BAD_HANDLE (cno_handle, DAPL_MAGIC_CNO) ) - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE,DAT_INVALID_HANDLE_CNO); - goto bail; - } + if (NULL == cno_param) { + dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3); + goto bail; + } - if ( NULL == cno_param ) - { - dat_status = DAT_ERROR (DAT_INVALID_PARAMETER,DAT_INVALID_ARG3); - goto bail; - } + cno_ptr = (DAPL_CNO *) cno_handle; + cno_param->ia_handle = cno_ptr->header.owner_ia; + cno_param->proxy_type = DAT_PROXY_TYPE_AGENT; + cno_param->proxy.agent = cno_ptr->cno_wait_agent; - cno_ptr = (DAPL_CNO *) cno_handle; - cno_param->ia_handle = cno_ptr->header.owner_ia; - cno_param->proxy_type = DAT_PROXY_TYPE_AGENT; - cno_param->proxy.agent = cno_ptr->cno_wait_agent; - - bail: - return dat_status; + bail: + return dat_status; } - diff --git a/dapl/udapl/dapl_cno_wait.c b/dapl/udapl/dapl_cno_wait.c index fce9f88..e89317d 100644 --- a/dapl/udapl/dapl_cno_wait.c +++ b/dapl/udapl/dapl_cno_wait.c @@ -59,75 +59,65 @@ * DAT_QUEUE_EMPTY * DAT_INVALID_PARAMETER */ -DAT_RETURN DAT_API dapl_cno_wait( - IN DAT_CNO_HANDLE cno_handle, /* cno_handle */ - IN DAT_TIMEOUT timeout, /* agent */ - OUT DAT_EVD_HANDLE *evd_handle) /* ia_handle */ +DAT_RETURN DAT_API dapl_cno_wait(IN DAT_CNO_HANDLE cno_handle, /* cno_handle */ + IN DAT_TIMEOUT timeout, /* agent */ + OUT DAT_EVD_HANDLE * evd_handle) +{ /* ia_handle */ + DAPL_CNO *cno_ptr; + DAT_RETURN dat_status; -{ - DAPL_CNO *cno_ptr; - DAT_RETURN dat_status; + if (DAPL_BAD_HANDLE(cno_handle, DAPL_MAGIC_CNO)) { + dat_status = DAT_INVALID_HANDLE | DAT_INVALID_HANDLE_CNO; + goto bail; + } - if ( DAPL_BAD_HANDLE (cno_handle, DAPL_MAGIC_CNO) ) - { - dat_status = DAT_INVALID_HANDLE | DAT_INVALID_HANDLE_CNO; - goto bail; - } + dat_status = DAT_SUCCESS; - dat_status = DAT_SUCCESS; + cno_ptr = (DAPL_CNO *) cno_handle; - cno_ptr = (DAPL_CNO *) cno_handle; + if (cno_ptr->cno_state == DAPL_CNO_STATE_DEAD) { + dat_status = + DAT_ERROR(DAT_INVALID_STATE, DAT_INVALID_STATE_CNO_DEAD); + goto bail; + } - if ( cno_ptr->cno_state == DAPL_CNO_STATE_DEAD ) - { - dat_status = DAT_ERROR (DAT_INVALID_STATE,DAT_INVALID_STATE_CNO_DEAD); - goto bail; - } + dapl_os_lock(&cno_ptr->header.lock); + while (cno_ptr->cno_state == DAPL_CNO_STATE_UNTRIGGERED + && DAT_GET_TYPE(dat_status) != DAT_TIMEOUT_EXPIRED) { + cno_ptr->cno_waiters++; + dapl_os_unlock(&cno_ptr->header.lock); + dat_status = dapl_os_wait_object_wait(&cno_ptr->cno_wait_object, + timeout); + dapl_os_lock(&cno_ptr->header.lock); + cno_ptr->cno_waiters--; + } - dapl_os_lock ( &cno_ptr->header.lock ); - while (cno_ptr->cno_state == DAPL_CNO_STATE_UNTRIGGERED - && DAT_GET_TYPE(dat_status) != DAT_TIMEOUT_EXPIRED) - { - cno_ptr->cno_waiters++; - dapl_os_unlock ( &cno_ptr->header.lock ); - dat_status = dapl_os_wait_object_wait (&cno_ptr->cno_wait_object, - timeout); - dapl_os_lock ( &cno_ptr->header.lock ); - cno_ptr->cno_waiters--; - } + if (cno_ptr->cno_state == DAPL_CNO_STATE_DEAD) { + dat_status = + DAT_ERROR(DAT_INVALID_STATE, DAT_INVALID_STATE_CNO_DEAD); + } else if (dat_status == DAT_SUCCESS) { + /* + * After the first triggering, this will be a valid handle. + * If we're racing with wakeups of other CNO waiters, + * that's ok. + */ + dapl_os_assert(cno_ptr->cno_state == DAPL_CNO_STATE_TRIGGERED); + cno_ptr->cno_state = DAPL_CNO_STATE_UNTRIGGERED; + *evd_handle = cno_ptr->cno_evd_triggered; + } else if (DAT_GET_TYPE(dat_status) == DAT_TIMEOUT_EXPIRED) { + cno_ptr->cno_state = DAPL_CNO_STATE_UNTRIGGERED; + *evd_handle = NULL; + dat_status = DAT_QUEUE_EMPTY; + } else { + /* + * The only other reason we could have made it out of + * the loop is an interrupted system call. + */ + dapl_os_assert(DAT_GET_TYPE(dat_status) == + DAT_INTERRUPTED_CALL); + } + dapl_os_unlock(&cno_ptr->header.lock); - if ( cno_ptr->cno_state == DAPL_CNO_STATE_DEAD ) - { - dat_status = DAT_ERROR (DAT_INVALID_STATE,DAT_INVALID_STATE_CNO_DEAD); - } - else if ( dat_status == DAT_SUCCESS ) - { - /* - * After the first triggering, this will be a valid handle. - * If we're racing with wakeups of other CNO waiters, - * that's ok. - */ - dapl_os_assert ( cno_ptr->cno_state == DAPL_CNO_STATE_TRIGGERED ); - cno_ptr->cno_state = DAPL_CNO_STATE_UNTRIGGERED; - *evd_handle = cno_ptr->cno_evd_triggered; - } - else if ( DAT_GET_TYPE(dat_status) == DAT_TIMEOUT_EXPIRED ) - { - cno_ptr->cno_state = DAPL_CNO_STATE_UNTRIGGERED; - *evd_handle = NULL; - dat_status = DAT_QUEUE_EMPTY; - } - else - { - /* - * The only other reason we could have made it out of - * the loop is an interrupted system call. - */ - dapl_os_assert(DAT_GET_TYPE(dat_status) == DAT_INTERRUPTED_CALL); - } - dapl_os_unlock ( &cno_ptr->header.lock ); - - bail: - return dat_status; + bail: + return dat_status; } - diff --git a/dapl/udapl/dapl_evd_clear_unwaitable.c b/dapl/udapl/dapl_evd_clear_unwaitable.c index 35dd3ae..ab24c04 100644 --- a/dapl/udapl/dapl_evd_clear_unwaitable.c +++ b/dapl/udapl/dapl_evd_clear_unwaitable.c @@ -55,28 +55,25 @@ * DAT_SUCCESS * DAT_INVALID_HANDLE */ -DAT_RETURN DAT_API -dapl_evd_clear_unwaitable ( - IN DAT_EVD_HANDLE evd_handle ) +DAT_RETURN DAT_API dapl_evd_clear_unwaitable(IN DAT_EVD_HANDLE evd_handle) { - DAPL_EVD *evd_ptr; - DAT_RETURN dat_status; + DAPL_EVD *evd_ptr; + DAT_RETURN dat_status; - evd_ptr = (DAPL_EVD *)evd_handle; - dat_status = DAT_SUCCESS; + evd_ptr = (DAPL_EVD *) evd_handle; + dat_status = DAT_SUCCESS; - if ( DAPL_BAD_HANDLE (evd_handle, DAPL_MAGIC_EVD) ) + if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) + { + dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 0); + goto bail; + } + dapl_os_lock(&evd_ptr->header.lock); + evd_ptr->evd_waitable = DAT_TRUE; + dapl_os_unlock(&evd_ptr->header.lock); - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE,0); - goto bail; - } - dapl_os_lock ( &evd_ptr->header.lock ); - evd_ptr->evd_waitable = DAT_TRUE; - dapl_os_unlock ( &evd_ptr->header.lock ); + dat_status = DAT_SUCCESS; - dat_status = DAT_SUCCESS; - -bail: - return dat_status; + bail: + return dat_status; } diff --git a/dapl/udapl/dapl_evd_create.c b/dapl/udapl/dapl_evd_create.c index 5ca5c22..548c2ae 100644 --- a/dapl/udapl/dapl_evd_create.c +++ b/dapl/udapl/dapl_evd_create.c @@ -72,124 +72,113 @@ * even if it is not required. However, it will not be armed. */ -DAT_RETURN DAT_API dapl_evd_create ( - IN DAT_IA_HANDLE ia_handle, - IN DAT_COUNT evd_min_qlen, - IN DAT_CNO_HANDLE cno_handle, - IN DAT_EVD_FLAGS evd_flags, - OUT DAT_EVD_HANDLE *evd_handle ) +DAT_RETURN DAT_API dapl_evd_create(IN DAT_IA_HANDLE ia_handle, + IN DAT_COUNT evd_min_qlen, + IN DAT_CNO_HANDLE cno_handle, + IN DAT_EVD_FLAGS evd_flags, + OUT DAT_EVD_HANDLE * evd_handle) { - DAPL_IA *ia_ptr; - DAPL_EVD *evd_ptr; - DAPL_CNO *cno_ptr; - DAT_RETURN dat_status; - DAT_PROVIDER_ATTR provider_attr; - int i; - int j; - int flag_mask[6]; - - dapl_dbg_log (DAPL_DBG_TYPE_API, - "dapl_evd_create (%p, %d, %p, 0x%x, %p)\n", - ia_handle, - evd_min_qlen, - cno_handle, - evd_flags, - evd_handle); - - ia_ptr = (DAPL_IA *)ia_handle; - cno_ptr = (DAPL_CNO *)cno_handle; - evd_ptr = NULL; - *evd_handle = NULL; - dat_status = DAT_SUCCESS; - - if (DAPL_BAD_HANDLE (ia_handle, DAPL_MAGIC_IA)) - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE,DAT_INVALID_HANDLE_IA); - goto bail; - } - - DAPL_CNTR(ia_ptr, DCNT_IA_EVD_CREATE); - - if ( evd_min_qlen <= 0 ) - { - dat_status = DAT_ERROR (DAT_INVALID_PARAMETER,DAT_INVALID_ARG2); - goto bail; - } - if ( evd_min_qlen > ia_ptr->hca_ptr->ia_attr.max_evd_qlen ) - { - dat_status = DAT_ERROR (DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_TEVD); - goto bail; - } - - if (cno_handle != DAT_HANDLE_NULL - && DAPL_BAD_HANDLE(cno_handle, DAPL_MAGIC_CNO)) - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE,DAT_INVALID_HANDLE_CNO); - goto bail; - } - - /* - * Check the merging attributes to ensure the combination of - * flags requested is supported. - */ - dapl_ia_query (ia_handle, NULL, - 0, NULL, - DAT_PROVIDER_FIELD_ALL, &provider_attr); - - /* Set up an array of flags to compare against; the EVD bits are - * a sparse array that need to be mapped to the merging flags - */ - flag_mask[0] = DAT_EVD_SOFTWARE_FLAG; - flag_mask[1] = DAT_EVD_CR_FLAG; - flag_mask[2] = DAT_EVD_DTO_FLAG; - flag_mask[3] = DAT_EVD_CONNECTION_FLAG; - flag_mask[4] = DAT_EVD_RMR_BIND_FLAG; - flag_mask[5] = DAT_EVD_ASYNC_FLAG; - - for (i = 0; i < 6; i++) - { - if (flag_mask[i] & evd_flags) - { - for (j = 0; j < 6; j++) - { - if (flag_mask[j] & evd_flags) - { - if (provider_attr.evd_stream_merging_supported[i][j] == DAT_FALSE) - { - dat_status = DAT_ERROR (DAT_INVALID_PARAMETER,DAT_INVALID_ARG4); - goto bail; - } + DAPL_IA *ia_ptr; + DAPL_EVD *evd_ptr; + DAPL_CNO *cno_ptr; + DAT_RETURN dat_status; + DAT_PROVIDER_ATTR provider_attr; + int i; + int j; + int flag_mask[6]; + + dapl_dbg_log(DAPL_DBG_TYPE_API, + "dapl_evd_create (%p, %d, %p, 0x%x, %p)\n", + ia_handle, + evd_min_qlen, cno_handle, evd_flags, evd_handle); + + ia_ptr = (DAPL_IA *) ia_handle; + cno_ptr = (DAPL_CNO *) cno_handle; + evd_ptr = NULL; + *evd_handle = NULL; + dat_status = DAT_SUCCESS; + + if (DAPL_BAD_HANDLE(ia_handle, DAPL_MAGIC_IA)) { + dat_status = + DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA); + goto bail; + } + + DAPL_CNTR(ia_ptr, DCNT_IA_EVD_CREATE); + + if (evd_min_qlen <= 0) { + dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2); + goto bail; + } + if (evd_min_qlen > ia_ptr->hca_ptr->ia_attr.max_evd_qlen) { + dat_status = + DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_TEVD); + goto bail; + } + + if (cno_handle != DAT_HANDLE_NULL + && DAPL_BAD_HANDLE(cno_handle, DAPL_MAGIC_CNO)) { + dat_status = + DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CNO); + goto bail; + } + + /* + * Check the merging attributes to ensure the combination of + * flags requested is supported. + */ + dapl_ia_query(ia_handle, NULL, + 0, NULL, DAT_PROVIDER_FIELD_ALL, &provider_attr); + + /* Set up an array of flags to compare against; the EVD bits are + * a sparse array that need to be mapped to the merging flags + */ + flag_mask[0] = DAT_EVD_SOFTWARE_FLAG; + flag_mask[1] = DAT_EVD_CR_FLAG; + flag_mask[2] = DAT_EVD_DTO_FLAG; + flag_mask[3] = DAT_EVD_CONNECTION_FLAG; + flag_mask[4] = DAT_EVD_RMR_BIND_FLAG; + flag_mask[5] = DAT_EVD_ASYNC_FLAG; + + for (i = 0; i < 6; i++) { + if (flag_mask[i] & evd_flags) { + for (j = 0; j < 6; j++) { + if (flag_mask[j] & evd_flags) { + if (provider_attr. + evd_stream_merging_supported[i][j] + == DAT_FALSE) { + dat_status = + DAT_ERROR + (DAT_INVALID_PARAMETER, + DAT_INVALID_ARG4); + goto bail; + } + } + } /* end for j */ } - } /* end for j */ + } /* end for i */ + + dat_status = dapls_evd_internal_create(ia_ptr, + cno_ptr, + evd_min_qlen, + evd_flags, &evd_ptr); + if (dat_status != DAT_SUCCESS) { + goto bail; } - } /* end for i */ - - dat_status = dapls_evd_internal_create (ia_ptr, - cno_ptr, - evd_min_qlen, - evd_flags, - &evd_ptr); - if (dat_status != DAT_SUCCESS) - { - goto bail; - } - - evd_ptr->evd_state = DAPL_EVD_STATE_OPEN; - - *evd_handle = (DAT_EVD_HANDLE) evd_ptr; - -bail: - if (dat_status != DAT_SUCCESS) - { - if (evd_ptr) - { - dapl_evd_free (evd_ptr); + + evd_ptr->evd_state = DAPL_EVD_STATE_OPEN; + + *evd_handle = (DAT_EVD_HANDLE) evd_ptr; + + bail: + if (dat_status != DAT_SUCCESS) { + if (evd_ptr) { + dapl_evd_free(evd_ptr); + } } - } - dapl_dbg_log (DAPL_DBG_TYPE_RTN, - "dapl_evd_create () returns 0x%x\n", - dat_status); + dapl_dbg_log(DAPL_DBG_TYPE_RTN, + "dapl_evd_create () returns 0x%x\n", dat_status); - return dat_status; + return dat_status; } diff --git a/dapl/udapl/dapl_evd_disable.c b/dapl/udapl/dapl_evd_disable.c index 0187d7f..78f1b0e 100644 --- a/dapl/udapl/dapl_evd_disable.c +++ b/dapl/udapl/dapl_evd_disable.c @@ -57,24 +57,22 @@ * DAT_INVALID_HANDLE */ -DAT_RETURN DAT_API dapl_evd_disable ( - IN DAT_EVD_HANDLE evd_handle) +DAT_RETURN DAT_API dapl_evd_disable(IN DAT_EVD_HANDLE evd_handle) { - DAPL_EVD *evd_ptr; - DAT_RETURN dat_status; + DAPL_EVD *evd_ptr; + DAT_RETURN dat_status; - evd_ptr = (DAPL_EVD *)evd_handle; - dat_status = DAT_SUCCESS; + evd_ptr = (DAPL_EVD *) evd_handle; + dat_status = DAT_SUCCESS; - if ( DAPL_BAD_HANDLE (evd_handle, DAPL_MAGIC_EVD) ) + if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) + { + dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 0); + goto bail; + } - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE,0); - goto bail; - } + evd_ptr->evd_enabled = DAT_FALSE; - evd_ptr->evd_enabled = DAT_FALSE; - -bail: - return dat_status; + bail: + return dat_status; } diff --git a/dapl/udapl/dapl_evd_enable.c b/dapl/udapl/dapl_evd_enable.c index 6f41eeb..b5991c7 100644 --- a/dapl/udapl/dapl_evd_enable.c +++ b/dapl/udapl/dapl_evd_enable.c @@ -58,37 +58,34 @@ * DAT_INVALID_HANDLE */ -DAT_RETURN DAT_API dapl_evd_enable ( - IN DAT_EVD_HANDLE evd_handle) +DAT_RETURN DAT_API dapl_evd_enable(IN DAT_EVD_HANDLE evd_handle) { - DAPL_EVD *evd_ptr; - DAT_RETURN dat_status; + DAPL_EVD *evd_ptr; + DAT_RETURN dat_status; - evd_ptr = (DAPL_EVD *)evd_handle; - dat_status = DAT_SUCCESS; + evd_ptr = (DAPL_EVD *) evd_handle; + dat_status = DAT_SUCCESS; - if ( DAPL_BAD_HANDLE (evd_handle, DAPL_MAGIC_EVD) ) + if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) + { + dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 0); + goto bail; + } - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE,0); - goto bail; - } + evd_ptr->evd_enabled = DAT_TRUE; - evd_ptr->evd_enabled = DAT_TRUE; + /* We need to enable the callback handler if there is a CNO. */ + if (evd_ptr->cno_ptr != NULL && + evd_ptr->ib_cq_handle != IB_INVALID_HANDLE) { + dat_status = + dapls_ib_completion_notify(evd_ptr->header.owner_ia-> + hca_ptr->ib_hca_handle, evd_ptr, + IB_NOTIFY_ON_NEXT_COMP); - /* We need to enable the callback handler if there is a CNO. */ - if (evd_ptr->cno_ptr != NULL && - evd_ptr->ib_cq_handle != IB_INVALID_HANDLE ) - { - dat_status = dapls_ib_completion_notify ( - evd_ptr->header.owner_ia->hca_ptr->ib_hca_handle, - evd_ptr, - IB_NOTIFY_ON_NEXT_COMP); + /* FIXME report error */ + dapl_os_assert(dat_status == DAT_SUCCESS); + } - /* FIXME report error */ - dapl_os_assert(dat_status == DAT_SUCCESS); - } - -bail: - return dat_status; + bail: + return dat_status; } diff --git a/dapl/udapl/dapl_evd_modify_cno.c b/dapl/udapl/dapl_evd_modify_cno.c index 1ee2231..955a835 100644 --- a/dapl/udapl/dapl_evd_modify_cno.c +++ b/dapl/udapl/dapl_evd_modify_cno.c @@ -59,59 +59,52 @@ * DAT_INVALID_HANDLE */ -DAT_RETURN DAT_API dapl_evd_modify_cno ( - IN DAT_EVD_HANDLE evd_handle, - IN DAT_CNO_HANDLE cno_handle) - +DAT_RETURN DAT_API dapl_evd_modify_cno(IN DAT_EVD_HANDLE evd_handle, + IN DAT_CNO_HANDLE cno_handle) { - DAPL_EVD *evd_ptr; - DAPL_CNO *cno_ptr; - DAPL_CNO *old_cno_ptr; - DAT_RETURN dat_status; + DAPL_EVD *evd_ptr; + DAPL_CNO *cno_ptr; + DAPL_CNO *old_cno_ptr; + DAT_RETURN dat_status; - evd_ptr = (DAPL_EVD *)evd_handle; - cno_ptr = (DAPL_CNO *)cno_handle; - dat_status = DAT_SUCCESS; + evd_ptr = (DAPL_EVD *) evd_handle; + cno_ptr = (DAPL_CNO *) cno_handle; + dat_status = DAT_SUCCESS; - if (DAPL_BAD_HANDLE (evd_handle, DAPL_MAGIC_EVD)) - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE, 0); - goto bail; - } - if (cno_handle != NULL && - DAPL_BAD_HANDLE (cno_handle, DAPL_MAGIC_CNO)) - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CNO); - goto bail; - } - dapl_os_lock (&evd_ptr->header.lock); - old_cno_ptr = evd_ptr->cno_ptr; - evd_ptr->cno_ptr = cno_ptr; - dapl_os_unlock (&evd_ptr->header.lock); - if (cno_ptr) - { - dapl_os_atomic_inc ( & (cno_ptr->cno_ref_count) ); - } - if (old_cno_ptr) - { - dapl_os_atomic_dec ( & (old_cno_ptr->cno_ref_count) ); - } + if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) { + dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 0); + goto bail; + } + if (cno_handle != NULL && DAPL_BAD_HANDLE(cno_handle, DAPL_MAGIC_CNO)) { + dat_status = + DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CNO); + goto bail; + } + dapl_os_lock(&evd_ptr->header.lock); + old_cno_ptr = evd_ptr->cno_ptr; + evd_ptr->cno_ptr = cno_ptr; + dapl_os_unlock(&evd_ptr->header.lock); + if (cno_ptr) { + dapl_os_atomic_inc(&(cno_ptr->cno_ref_count)); + } + if (old_cno_ptr) { + dapl_os_atomic_dec(&(old_cno_ptr->cno_ref_count)); + } - /* We need to enable the callback handler if the EVD is enabled. */ - if (evd_ptr->evd_enabled && - cno_handle != DAT_HANDLE_NULL && - evd_ptr->ib_cq_handle != IB_INVALID_HANDLE) - { - dat_status = dapls_ib_completion_notify ( - evd_ptr->header.owner_ia->hca_ptr->ib_hca_handle, - evd_ptr, - IB_NOTIFY_ON_NEXT_COMP); + /* We need to enable the callback handler if the EVD is enabled. */ + if (evd_ptr->evd_enabled && + cno_handle != DAT_HANDLE_NULL && + evd_ptr->ib_cq_handle != IB_INVALID_HANDLE) { + dat_status = + dapls_ib_completion_notify(evd_ptr->header.owner_ia-> + hca_ptr->ib_hca_handle, evd_ptr, + IB_NOTIFY_ON_NEXT_COMP); - /* FIXME report error */ - dapl_os_assert (dat_status == DAT_SUCCESS); - } + /* FIXME report error */ + dapl_os_assert(dat_status == DAT_SUCCESS); + } -bail: - return dat_status; + bail: + return dat_status; } diff --git a/dapl/udapl/dapl_evd_query.c b/dapl/udapl/dapl_evd_query.c index 6983d23..09abcad 100644 --- a/dapl/udapl/dapl_evd_query.c +++ b/dapl/udapl/dapl_evd_query.c @@ -57,58 +57,56 @@ * DAT_INVALID_PARAMETER */ DAT_RETURN DAT_API -dapl_evd_query ( - IN DAT_EVD_HANDLE evd_handle, - IN DAT_EVD_PARAM_MASK evd_param_mask, - OUT DAT_EVD_PARAM *evd_param ) +dapl_evd_query(IN DAT_EVD_HANDLE evd_handle, + IN DAT_EVD_PARAM_MASK evd_param_mask, + OUT DAT_EVD_PARAM * evd_param) { - DAPL_EVD *evd_ptr; - DAT_RETURN dat_status; + DAPL_EVD *evd_ptr; + DAT_RETURN dat_status; - dat_status = DAT_SUCCESS; + dat_status = DAT_SUCCESS; - if ( NULL == evd_param ) - { - dat_status = DAT_ERROR (DAT_INVALID_PARAMETER,DAT_INVALID_ARG3); - goto bail; - } - - /* Note: the spec. allows for events to be directed to a NULL EVD */ - /* with handle of type DAT_HANDLE_NULL. See 6.3.1 */ - if ( DAT_HANDLE_NULL == evd_handle ) - { - dapl_os_memzero (evd_param, sizeof (DAT_EVD_PARAM)); - } - else - { - if ( DAPL_BAD_HANDLE (evd_handle, DAPL_MAGIC_EVD) ) - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE,0); - goto bail; + if (NULL == evd_param) { + dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3); + goto bail; } - evd_ptr = (DAPL_EVD *) evd_handle; + /* Note: the spec. allows for events to be directed to a NULL EVD */ + /* with handle of type DAT_HANDLE_NULL. See 6.3.1 */ + if (DAT_HANDLE_NULL == evd_handle) { + dapl_os_memzero(evd_param, sizeof(DAT_EVD_PARAM)); + } else { + if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) { + dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 0); + goto bail; + } + + evd_ptr = (DAPL_EVD *) evd_handle; - /* - * We may be racing against the thread safe modify - * calls here (dat_evd_{enable,disable,{set,clear}_unwaitable}). - * They are thread safe, so our reads need to be atomic with - * regard to those calls. The below is ok (a single bit - * read counts as atomic; if it's in transition you'll get one - * of the correct values) but we'll need to be careful - * about reading the state variable atomically when we add - * in waitable/unwaitable. - */ - evd_param->evd_state = - (evd_ptr->evd_enabled ? DAT_EVD_STATE_ENABLED : DAT_EVD_STATE_DISABLED); - evd_param->evd_state |= - (evd_ptr->evd_waitable ? DAT_EVD_STATE_WAITABLE : DAT_EVD_STATE_UNWAITABLE); - evd_param->ia_handle = evd_ptr->header.owner_ia; - evd_param->evd_qlen = evd_ptr->qlen; - evd_param->cno_handle = (DAT_CNO_HANDLE) evd_ptr->cno_ptr; - evd_param->evd_flags = evd_ptr->evd_flags; - } + /* + * We may be racing against the thread safe modify + * calls here (dat_evd_{enable,disable,{set,clear}_unwaitable}). + * They are thread safe, so our reads need to be atomic with + * regard to those calls. The below is ok (a single bit + * read counts as atomic; if it's in transition you'll get one + * of the correct values) but we'll need to be careful + * about reading the state variable atomically when we add + * in waitable/unwaitable. + */ + evd_param->evd_state = + (evd_ptr-> + evd_enabled ? DAT_EVD_STATE_ENABLED : + DAT_EVD_STATE_DISABLED); + evd_param->evd_state |= + (evd_ptr-> + evd_waitable ? DAT_EVD_STATE_WAITABLE : + DAT_EVD_STATE_UNWAITABLE); + evd_param->ia_handle = evd_ptr->header.owner_ia; + evd_param->evd_qlen = evd_ptr->qlen; + evd_param->cno_handle = (DAT_CNO_HANDLE) evd_ptr->cno_ptr; + evd_param->evd_flags = evd_ptr->evd_flags; + } -bail: - return dat_status; + bail: + return dat_status; } diff --git a/dapl/udapl/dapl_evd_set_unwaitable.c b/dapl/udapl/dapl_evd_set_unwaitable.c index 35250ff..bf41662 100644 --- a/dapl/udapl/dapl_evd_set_unwaitable.c +++ b/dapl/udapl/dapl_evd_set_unwaitable.c @@ -56,43 +56,40 @@ * DAT_SUCCESS * DAT_INVALID_HANDLE */ -DAT_RETURN DAT_API -dapl_evd_set_unwaitable ( - IN DAT_EVD_HANDLE evd_handle ) +DAT_RETURN DAT_API dapl_evd_set_unwaitable(IN DAT_EVD_HANDLE evd_handle) { - DAPL_EVD *evd_ptr; - DAT_RETURN dat_status; + DAPL_EVD *evd_ptr; + DAT_RETURN dat_status; - evd_ptr = (DAPL_EVD *)evd_handle; - dat_status = DAT_SUCCESS; + evd_ptr = (DAPL_EVD *) evd_handle; + dat_status = DAT_SUCCESS; - if ( DAPL_BAD_HANDLE (evd_handle, DAPL_MAGIC_EVD) ) + if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) + { + dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 0); + goto bail; + } + dapl_os_lock(&evd_ptr->header.lock); + evd_ptr->evd_waitable = DAT_FALSE; + dapl_os_unlock(&evd_ptr->header.lock); - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE,0); - goto bail; - } - dapl_os_lock ( &evd_ptr->header.lock ); - evd_ptr->evd_waitable = DAT_FALSE; - dapl_os_unlock ( &evd_ptr->header.lock ); - - /* - * If this evd is waiting, wake it up. There is an obvious race - * condition here where we may wakeup the waiter before it goes to - * sleep; but the wait_object allows this and will do the right - * thing. - */ - if (evd_ptr->evd_state == DAPL_EVD_STATE_WAITED) - { + /* + * If this evd is waiting, wake it up. There is an obvious race + * condition here where we may wakeup the waiter before it goes to + * sleep; but the wait_object allows this and will do the right + * thing. + */ + if (evd_ptr->evd_state == DAPL_EVD_STATE_WAITED) { #ifdef CQ_WAIT_OBJECT - if (evd_ptr->cq_wait_obj_handle) - dapls_ib_wait_object_wakeup (evd_ptr->cq_wait_obj_handle); - else + if (evd_ptr->cq_wait_obj_handle) + dapls_ib_wait_object_wakeup(evd_ptr-> + cq_wait_obj_handle); + else #endif - dapl_os_wait_object_wakeup (&evd_ptr->wait_object); - } -bail: - return dat_status; + dapl_os_wait_object_wakeup(&evd_ptr->wait_object); + } + bail: + return dat_status; } /* diff --git a/dapl/udapl/dapl_evd_wait.c b/dapl/udapl/dapl_evd_wait.c index c973397..8d82d63 100644 --- a/dapl/udapl/dapl_evd_wait.c +++ b/dapl/udapl/dapl_evd_wait.c @@ -63,226 +63,215 @@ * DAT_INVALID_STATE */ -DAT_RETURN DAT_API dapl_evd_wait ( - IN DAT_EVD_HANDLE evd_handle, - IN DAT_TIMEOUT time_out, - IN DAT_COUNT threshold, - OUT DAT_EVENT *event, - OUT DAT_COUNT *nmore) - +DAT_RETURN DAT_API dapl_evd_wait(IN DAT_EVD_HANDLE evd_handle, + IN DAT_TIMEOUT time_out, + IN DAT_COUNT threshold, + OUT DAT_EVENT * event, OUT DAT_COUNT * nmore) { - DAPL_EVD *evd_ptr; - DAT_RETURN dat_status; - DAT_EVENT *local_event; - DAT_BOOLEAN notify_requested = DAT_FALSE; - DAT_BOOLEAN waitable; - DAPL_EVD_STATE evd_state; - - dapl_dbg_log (DAPL_DBG_TYPE_API, - "dapl_evd_wait (%p, %d, %d, %p, %p)\n", - evd_handle, - time_out, - threshold, - event, - nmore); - - evd_ptr = (DAPL_EVD *)evd_handle; - dat_status = DAT_SUCCESS; - - if (DAPL_BAD_HANDLE (evd_ptr, DAPL_MAGIC_EVD)) - { - /* - * We return directly rather than bailing because - * bailing attempts to update the evd, and we don't have - * one. - */ - dat_status = DAT_ERROR (DAT_INVALID_HANDLE,0); - goto bail; - } - if (!event) - { - dat_status = DAT_ERROR (DAT_INVALID_PARAMETER,DAT_INVALID_ARG4); - goto bail; - } - if (!nmore) - { - dat_status = DAT_ERROR (DAT_INVALID_PARAMETER,DAT_INVALID_ARG5); - goto bail; - } - if (threshold <= 0 || - (threshold > 1 && evd_ptr->completion_type != DAPL_EVD_STATE_THRESHOLD) || - threshold > evd_ptr->qlen) - { - dat_status = DAT_ERROR (DAT_INVALID_PARAMETER,DAT_INVALID_ARG3); - goto bail; - } - if ( evd_ptr->catastrophic_overflow ) - { - dat_status = DAT_ERROR (DAT_INVALID_STATE,0); - goto bail; - } - DAPL_CNTR(evd_ptr, DCNT_EVD_WAIT); - - dapl_dbg_log (DAPL_DBG_TYPE_EVD, - "dapl_evd_wait: EVD %p, CQ %p\n", - evd_ptr, - (void *)evd_ptr->ib_cq_handle); - - /* - * Make sure there are no other waiters and the evd is active. - * Currently this means only the OPEN state is allowed. - * Do this atomically. We need to take a lock to synchronize - * with dapl_evd_dequeue(), but the atomic transition allows - * non-locking synchronization with dapl_evd_query() and - * dapl_evd_{query,enable,disable,{set,clear}_unwaitable}. - */ - - dapl_os_lock ( &evd_ptr->header.lock ); - waitable = evd_ptr->evd_waitable; - - dapl_os_assert ( sizeof(DAT_COUNT) == sizeof(DAPL_EVD_STATE) ); - evd_state = evd_ptr->evd_state; - if (evd_ptr->evd_state == DAPL_EVD_STATE_OPEN) - evd_ptr->evd_state = DAPL_EVD_STATE_WAITED; - - if ( evd_state != DAPL_EVD_STATE_OPEN ) - { - /* Bogus state, bail out */ - dat_status = DAT_ERROR (DAT_INVALID_STATE,0); - goto bail; - } - - if (!waitable) - { - /* This EVD is not waitable, reset the state and bail */ - if (evd_ptr->evd_state == DAPL_EVD_STATE_WAITED) - evd_ptr->evd_state = evd_state; - - dat_status = DAT_ERROR (DAT_INVALID_STATE, DAT_INVALID_STATE_EVD_UNWAITABLE); - goto bail; - } - - - /* - * We now own the EVD, even though we don't have the lock anymore, - * because we're in the WAITED state. - */ - - evd_ptr->threshold = threshold; - - for (;;) - { + DAPL_EVD *evd_ptr; + DAT_RETURN dat_status; + DAT_EVENT *local_event; + DAT_BOOLEAN notify_requested = DAT_FALSE; + DAT_BOOLEAN waitable; + DAPL_EVD_STATE evd_state; + + dapl_dbg_log(DAPL_DBG_TYPE_API, + "dapl_evd_wait (%p, %d, %d, %p, %p)\n", + evd_handle, time_out, threshold, event, nmore); + + evd_ptr = (DAPL_EVD *) evd_handle; + dat_status = DAT_SUCCESS; + + if (DAPL_BAD_HANDLE(evd_ptr, DAPL_MAGIC_EVD)) { + /* + * We return directly rather than bailing because + * bailing attempts to update the evd, and we don't have + * one. + */ + dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 0); + goto bail; + } + if (!event) { + dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG4); + goto bail; + } + if (!nmore) { + dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG5); + goto bail; + } + if (threshold <= 0 || + (threshold > 1 + && evd_ptr->completion_type != DAPL_EVD_STATE_THRESHOLD) + || threshold > evd_ptr->qlen) { + dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3); + goto bail; + } + if (evd_ptr->catastrophic_overflow) { + dat_status = DAT_ERROR(DAT_INVALID_STATE, 0); + goto bail; + } + DAPL_CNTR(evd_ptr, DCNT_EVD_WAIT); + + dapl_dbg_log(DAPL_DBG_TYPE_EVD, + "dapl_evd_wait: EVD %p, CQ %p\n", + evd_ptr, (void *)evd_ptr->ib_cq_handle); + /* - * Ideally we'd just check the number of entries on the CQ, but - * we don't have a way to do that. Because we have to set *nmore - * at some point in this routine, we'll need to do this copy - * sometime even if threshold == 1. - * - * For connection evd or async evd, the function checks and - * return right away if the ib_cq_handle associate with these evd - * equal to IB_INVALID_HANDLE + * Make sure there are no other waiters and the evd is active. + * Currently this means only the OPEN state is allowed. + * Do this atomically. We need to take a lock to synchronize + * with dapl_evd_dequeue(), but the atomic transition allows + * non-locking synchronization with dapl_evd_query() and + * dapl_evd_{query,enable,disable,{set,clear}_unwaitable}. */ - dapl_os_unlock(&evd_ptr->header.lock); - dapls_evd_copy_cq(evd_ptr); + dapl_os_lock(&evd_ptr->header.lock); + waitable = evd_ptr->evd_waitable; - if (dapls_rbuf_count(&evd_ptr->pending_event_queue) >= threshold) - { - break; - } + dapl_os_assert(sizeof(DAT_COUNT) == sizeof(DAPL_EVD_STATE)); + evd_state = evd_ptr->evd_state; + if (evd_ptr->evd_state == DAPL_EVD_STATE_OPEN) + evd_ptr->evd_state = DAPL_EVD_STATE_WAITED; - /* - * Do not enable the completion notification if this evd is not - * a DTO_EVD or RMR_BIND_EVD - */ - if ( (!notify_requested) && - ((evd_ptr->evd_flags & DAT_EVD_DTO_FLAG) || - (evd_ptr->evd_flags & DAT_EVD_RMR_BIND_FLAG)) ) - { - dat_status = dapls_ib_completion_notify ( - evd_ptr->header.owner_ia->hca_ptr->ib_hca_handle, - evd_ptr, - (evd_ptr->completion_type == DAPL_EVD_STATE_SOLICITED_WAIT) ? - IB_NOTIFY_ON_SOLIC_COMP : IB_NOTIFY_ON_NEXT_COMP ); - - DAPL_CNTR(evd_ptr, DCNT_EVD_WAIT_NOTIFY); - /* FIXME report error */ - dapl_os_assert(dat_status == DAT_SUCCESS); - - notify_requested = DAT_TRUE; - - /* Try again. */ - continue; + if (evd_state != DAPL_EVD_STATE_OPEN) { + /* Bogus state, bail out */ + dat_status = DAT_ERROR(DAT_INVALID_STATE, 0); + goto bail; } + if (!waitable) { + /* This EVD is not waitable, reset the state and bail */ + if (evd_ptr->evd_state == DAPL_EVD_STATE_WAITED) + evd_ptr->evd_state = evd_state; + + dat_status = + DAT_ERROR(DAT_INVALID_STATE, + DAT_INVALID_STATE_EVD_UNWAITABLE); + goto bail; + } /* - * Unused by poster; it has no way to tell how many - * items are on the queue without copying them over to the - * EVD queue, and we're the only ones allowed to dequeue - * from the CQ for synchronization/locking reasons. + * We now own the EVD, even though we don't have the lock anymore, + * because we're in the WAITED state. */ - evd_ptr->threshold = threshold; - DAPL_CNTR(evd_ptr, DCNT_EVD_WAIT_BLOCKED); - dapl_os_unlock(&evd_ptr->header.lock); + evd_ptr->threshold = threshold; + + for (;;) { + /* + * Ideally we'd just check the number of entries on the CQ, but + * we don't have a way to do that. Because we have to set *nmore + * at some point in this routine, we'll need to do this copy + * sometime even if threshold == 1. + * + * For connection evd or async evd, the function checks and + * return right away if the ib_cq_handle associate with these evd + * equal to IB_INVALID_HANDLE + */ + dapl_os_unlock(&evd_ptr->header.lock); + dapls_evd_copy_cq(evd_ptr); + dapl_os_lock(&evd_ptr->header.lock); + + if (dapls_rbuf_count(&evd_ptr->pending_event_queue) >= + threshold) { + break; + } + + /* + * Do not enable the completion notification if this evd is not + * a DTO_EVD or RMR_BIND_EVD + */ + if ((!notify_requested) && + ((evd_ptr->evd_flags & DAT_EVD_DTO_FLAG) || + (evd_ptr->evd_flags & DAT_EVD_RMR_BIND_FLAG))) { + dat_status = + dapls_ib_completion_notify(evd_ptr->header. + owner_ia->hca_ptr-> + ib_hca_handle, evd_ptr, + (evd_ptr-> + completion_type == + DAPL_EVD_STATE_SOLICITED_WAIT) + ? IB_NOTIFY_ON_SOLIC_COMP + : + IB_NOTIFY_ON_NEXT_COMP); + + DAPL_CNTR(evd_ptr, DCNT_EVD_WAIT_NOTIFY); + /* FIXME report error */ + dapl_os_assert(dat_status == DAT_SUCCESS); + + notify_requested = DAT_TRUE; + + /* Try again. */ + continue; + } + + /* + * Unused by poster; it has no way to tell how many + * items are on the queue without copying them over to the + * EVD queue, and we're the only ones allowed to dequeue + * from the CQ for synchronization/locking reasons. + */ + evd_ptr->threshold = threshold; + + DAPL_CNTR(evd_ptr, DCNT_EVD_WAIT_BLOCKED); + dapl_os_unlock(&evd_ptr->header.lock); #ifdef CQ_WAIT_OBJECT - if (evd_ptr->cq_wait_obj_handle) - dat_status = dapls_ib_wait_object_wait ( - evd_ptr->cq_wait_obj_handle, time_out ); - else + if (evd_ptr->cq_wait_obj_handle) + dat_status = + dapls_ib_wait_object_wait(evd_ptr-> + cq_wait_obj_handle, + time_out); + else #endif - dat_status = dapl_os_wait_object_wait ( - &evd_ptr->wait_object, time_out ); + dat_status = + dapl_os_wait_object_wait(&evd_ptr->wait_object, + time_out); + + dapl_os_lock(&evd_ptr->header.lock); + + /* + * FIXME: if the thread loops around and waits again + * the time_out value needs to be updated. + */ + + notify_requested = DAT_FALSE; /* We've used it up. */ + + /* See if we were awakened by evd_set_unwaitable */ + if (!evd_ptr->evd_waitable) { + dat_status = DAT_ERROR(DAT_INVALID_STATE, 0); + } + + if (dat_status != DAT_SUCCESS) { + /* + * If the status is DAT_TIMEOUT, we'll break out of the + * loop, *not* dequeue an event (because dat_status + * != DAT_SUCCESS), set *nmore (as we should for timeout) + * and return DAT_TIMEOUT. + */ + break; + } + } - dapl_os_lock(&evd_ptr->header.lock); + evd_ptr->evd_state = DAPL_EVD_STATE_OPEN; + + if (dat_status == DAT_SUCCESS) { + local_event = dapls_rbuf_remove(&evd_ptr->pending_event_queue); + *event = *local_event; + dapls_rbuf_add(&evd_ptr->free_event_queue, local_event); + } /* - * FIXME: if the thread loops around and waits again - * the time_out value needs to be updated. + * Valid if dat_status == DAT_SUCCESS || dat_status == DAT_TIMEOUT + * Undefined otherwise, so ok to set it. */ + *nmore = dapls_rbuf_count(&evd_ptr->pending_event_queue); - notify_requested = DAT_FALSE; /* We've used it up. */ - - /* See if we were awakened by evd_set_unwaitable */ - if ( !evd_ptr->evd_waitable ) - { - dat_status = DAT_ERROR (DAT_INVALID_STATE,0); - } - - if (dat_status != DAT_SUCCESS) - { - /* - * If the status is DAT_TIMEOUT, we'll break out of the - * loop, *not* dequeue an event (because dat_status - * != DAT_SUCCESS), set *nmore (as we should for timeout) - * and return DAT_TIMEOUT. - */ - break; + bail: + dapl_os_unlock(&evd_ptr->header.lock); + if (dat_status) { + dapl_dbg_log(DAPL_DBG_TYPE_RTN, + "dapl_evd_wait () returns 0x%x\n", dat_status); } - } - - evd_ptr->evd_state = DAPL_EVD_STATE_OPEN; - - if (dat_status == DAT_SUCCESS) - { - local_event = dapls_rbuf_remove(&evd_ptr->pending_event_queue); - *event = *local_event; - dapls_rbuf_add(&evd_ptr->free_event_queue, local_event); - } - - /* - * Valid if dat_status == DAT_SUCCESS || dat_status == DAT_TIMEOUT - * Undefined otherwise, so ok to set it. - */ - *nmore = dapls_rbuf_count(&evd_ptr->pending_event_queue); - - bail: - dapl_os_unlock(&evd_ptr->header.lock); - if ( dat_status ) { - dapl_dbg_log (DAPL_DBG_TYPE_RTN, - "dapl_evd_wait () returns 0x%x\n", dat_status); - } - return dat_status; + return dat_status; } diff --git a/dapl/udapl/dapl_init.c b/dapl/udapl/dapl_init.c index f19468b..e0af8f7 100644 --- a/dapl/udapl/dapl_init.c +++ b/dapl/udapl/dapl_init.c @@ -37,7 +37,7 @@ **********************************************************************/ #include "dapl.h" -#include /* Provider API function prototypes */ +#include /* Provider API function prototypes */ #include "dapl_hca_util.h" #include "dapl_init.h" #include "dapl_provider.h" @@ -48,7 +48,6 @@ #include "dapl_timer_util.h" #include "dapl_vendor.h" - /* * dapl_init * @@ -66,62 +65,60 @@ * * Return Values: */ -void dapl_init ( void ) +void dapl_init(void) { - DAT_RETURN dat_status; - - /* set up debug type */ - g_dapl_dbg_type = dapl_os_get_env_val ( "DAPL_DBG_TYPE", - DAPL_DBG_TYPE_ERR ); - /* set up debug destination */ - g_dapl_dbg_dest = dapl_os_get_env_val ( "DAPL_DBG_DEST", - DAPL_DBG_DEST_STDOUT ); - - /* open log file on first logging call if necessary */ - if (g_dapl_dbg_dest & DAPL_DBG_DEST_SYSLOG) - openlog("libdapl", LOG_ODELAY|LOG_PID|LOG_CONS, LOG_USER); - - dapl_log (DAPL_DBG_TYPE_UTIL, "dapl_init: dbg_type=0x%x,dbg_dest=0x%x\n", - g_dapl_dbg_type, g_dapl_dbg_dest); - - /* See if the user is on a loopback setup */ - g_dapl_loopback_connection = dapl_os_get_env_bool ( "DAPL_LOOPBACK" ); - - dapl_dbg_log (DAPL_DBG_TYPE_UTIL, "DAPL: %s Setting Loopback\n", - g_dapl_loopback_connection ? "" : "NOT"); - - /* initialize verbs library */ - dapls_ib_init (); - - /* initialize the timer */ - dapls_timer_init(); - - /* Set up name services */ - dat_status = dapls_ns_init (); - if (DAT_SUCCESS != dat_status) - { - dapl_dbg_log (DAPL_DBG_TYPE_ERR, - "dapls_ns_init failed %d\n", dat_status); - goto bail; - } - - /* initialize the provider list */ - dat_status = dapl_provider_list_create (); - - if (DAT_SUCCESS != dat_status) - { - dapl_dbg_log (DAPL_DBG_TYPE_ERR, - "dapl_provider_list_create failed %d\n", dat_status); - goto bail; - } - - return; - -bail: - dapl_dbg_log (DAPL_DBG_TYPE_ERR, "ERROR: dapl_init failed\n"); - return; -} + DAT_RETURN dat_status; + + /* set up debug type */ + g_dapl_dbg_type = dapl_os_get_env_val("DAPL_DBG_TYPE", + DAPL_DBG_TYPE_ERR); + /* set up debug destination */ + g_dapl_dbg_dest = dapl_os_get_env_val("DAPL_DBG_DEST", + DAPL_DBG_DEST_STDOUT); + + /* open log file on first logging call if necessary */ + if (g_dapl_dbg_dest & DAPL_DBG_DEST_SYSLOG) + openlog("libdapl", LOG_ODELAY | LOG_PID | LOG_CONS, LOG_USER); + + dapl_log(DAPL_DBG_TYPE_UTIL, "dapl_init: dbg_type=0x%x,dbg_dest=0x%x\n", + g_dapl_dbg_type, g_dapl_dbg_dest); + + /* See if the user is on a loopback setup */ + g_dapl_loopback_connection = dapl_os_get_env_bool("DAPL_LOOPBACK"); + + dapl_dbg_log(DAPL_DBG_TYPE_UTIL, "DAPL: %s Setting Loopback\n", + g_dapl_loopback_connection ? "" : "NOT"); + + /* initialize verbs library */ + dapls_ib_init(); + + /* initialize the timer */ + dapls_timer_init(); + + /* Set up name services */ + dat_status = dapls_ns_init(); + if (DAT_SUCCESS != dat_status) { + dapl_dbg_log(DAPL_DBG_TYPE_ERR, + "dapls_ns_init failed %d\n", dat_status); + goto bail; + } + + /* initialize the provider list */ + dat_status = dapl_provider_list_create(); + if (DAT_SUCCESS != dat_status) { + dapl_dbg_log(DAPL_DBG_TYPE_ERR, + "dapl_provider_list_create failed %d\n", + dat_status); + goto bail; + } + + return; + + bail: + dapl_dbg_log(DAPL_DBG_TYPE_ERR, "ERROR: dapl_init failed\n"); + return; +} /* * dapl_fini @@ -140,29 +137,28 @@ bail: * * Return Values: */ -void dapl_fini ( void ) +void dapl_fini(void) { - DAT_RETURN dat_status; + DAT_RETURN dat_status; - dapl_dbg_log (DAPL_DBG_TYPE_UTIL, "DAPL: ENTER (dapl_fini)\n"); + dapl_dbg_log(DAPL_DBG_TYPE_UTIL, "DAPL: ENTER (dapl_fini)\n"); - dat_status = dapl_provider_list_destroy (); - if (DAT_SUCCESS != dat_status) - { - dapl_dbg_log (DAPL_DBG_TYPE_ERR, - "dapl_provider_list_destroy failed %d\n", dat_status); - } - - dapls_ib_release (); + dat_status = dapl_provider_list_destroy(); + if (DAT_SUCCESS != dat_status) { + dapl_dbg_log(DAPL_DBG_TYPE_ERR, + "dapl_provider_list_destroy failed %d\n", + dat_status); + } - dapl_dbg_log (DAPL_DBG_TYPE_UTIL, "DAPL: Exit (dapl_fini)\n"); + dapls_ib_release(); - if (g_dapl_dbg_dest & DAPL_DBG_DEST_SYSLOG) - closelog(); + dapl_dbg_log(DAPL_DBG_TYPE_UTIL, "DAPL: Exit (dapl_fini)\n"); - return; -} + if (g_dapl_dbg_dest & DAPL_DBG_DEST_SYSLOG) + closelog(); + return; +} /* * @@ -174,143 +170,133 @@ void dapl_fini ( void ) * */ void DAT_API -DAT_PROVIDER_INIT_FUNC_NAME ( - IN const DAT_PROVIDER_INFO *provider_info, - IN const char *instance_data ) +DAT_PROVIDER_INIT_FUNC_NAME(IN const DAT_PROVIDER_INFO * provider_info, + IN const char *instance_data) { - DAT_PROVIDER *provider; - DAPL_HCA *hca_ptr; - DAT_RETURN dat_status; - char * data; - char * name; - char * port; - unsigned int len; - unsigned int i; - - data = NULL; - provider = NULL; - hca_ptr = NULL; + DAT_PROVIDER *provider; + DAPL_HCA *hca_ptr; + DAT_RETURN dat_status; + char *data; + char *name; + char *port; + unsigned int len; + unsigned int i; + + data = NULL; + provider = NULL; + hca_ptr = NULL; #if defined(_WIN32) || defined(_WIN64) - /* initialize DAPL library here as when called from DLL context in DLLmain() - * the IB (ibal) call hangs. - */ - dapl_init(); + /* initialize DAPL library here as when called from DLL context in DLLmain() + * the IB (ibal) call hangs. + */ + dapl_init(); #endif - dat_status = dapl_provider_list_insert(provider_info->ia_name, &provider); - if ( DAT_SUCCESS != dat_status ) - { - dapl_dbg_log (DAPL_DBG_TYPE_ERR, - "dat_provider_list_insert failed: %x\n", dat_status); - goto bail; - } - - data = dapl_os_strdup(instance_data); - if ( NULL == data ) - { - goto bail; - } - - len = dapl_os_strlen(data); - - for ( i = 0; i < len; i++ ) - { - if ( ' ' == data[i] ) - { - data[i] = '\0'; - break; - } - } - - /* if the instance data did not have a valid format */ - if ( i == len ) - { - goto bail; - } - - name = data; - port = data + (i + 1); - - hca_ptr = dapl_hca_alloc (name, port); - if ( NULL == hca_ptr ) - { - dapl_dbg_log (DAPL_DBG_TYPE_ERR, "%s() dapl_hca_alloc failed?\n"); - goto bail; - } - - provider->extension = hca_ptr; - dat_status = dat_registry_add_provider (provider, provider_info); - if ( DAT_SUCCESS != dat_status ) - { - dapl_dbg_log (DAPL_DBG_TYPE_ERR, - "dat_registry_add_provider failed: %x\n", dat_status); - } - - bail: - if ( NULL != data ) - { - dapl_os_free(data, len + 1); - } - - if ( DAT_SUCCESS != dat_status ) - { - if ( NULL != provider ) - { - (void) dapl_provider_list_remove(provider_info->ia_name); - } - - if ( NULL != hca_ptr ) - { - dapl_hca_free (hca_ptr); - } - } + dat_status = + dapl_provider_list_insert(provider_info->ia_name, &provider); + if (DAT_SUCCESS != dat_status) { + dapl_dbg_log(DAPL_DBG_TYPE_ERR, + "dat_provider_list_insert failed: %x\n", + dat_status); + goto bail; + } + + data = dapl_os_strdup(instance_data); + if (NULL == data) { + goto bail; + } + + len = dapl_os_strlen(data); + + for (i = 0; i < len; i++) { + if (' ' == data[i]) { + data[i] = '\0'; + break; + } + } + + /* if the instance data did not have a valid format */ + if (i == len) { + goto bail; + } + + name = data; + port = data + (i + 1); + + hca_ptr = dapl_hca_alloc(name, port); + if (NULL == hca_ptr) { + dapl_dbg_log(DAPL_DBG_TYPE_ERR, + "%s() dapl_hca_alloc failed?\n"); + goto bail; + } + + provider->extension = hca_ptr; + dat_status = dat_registry_add_provider(provider, provider_info); + if (DAT_SUCCESS != dat_status) { + dapl_dbg_log(DAPL_DBG_TYPE_ERR, + "dat_registry_add_provider failed: %x\n", + dat_status); + } + + bail: + if (NULL != data) { + dapl_os_free(data, len + 1); + } + + if (DAT_SUCCESS != dat_status) { + if (NULL != provider) { + (void)dapl_provider_list_remove(provider_info->ia_name); + } + + if (NULL != hca_ptr) { + dapl_hca_free(hca_ptr); + } + } } - /* * * This function is called by the registry to de-initialize a provider * */ void DAT_API -DAT_PROVIDER_FINI_FUNC_NAME ( - IN const DAT_PROVIDER_INFO *provider_info ) +DAT_PROVIDER_FINI_FUNC_NAME(IN const DAT_PROVIDER_INFO * provider_info) { - DAT_PROVIDER *provider; - DAT_RETURN dat_status; - - dat_status = dapl_provider_list_search(provider_info->ia_name, &provider); - if ( DAT_SUCCESS != dat_status ) - { - dapl_dbg_log (DAPL_DBG_TYPE_ERR, - "dat_registry_add_provider failed: %x\n", dat_status); - return; - } - - dat_status = dat_registry_remove_provider (provider, provider_info); - if ( DAT_SUCCESS != dat_status ) - { - dapl_dbg_log (DAPL_DBG_TYPE_ERR, - "dat_registry_add_provider failed: %x\n", dat_status); - } - - /* - * free HCA memory - */ - dapl_hca_free (provider->extension); - - (void) dapl_provider_list_remove(provider_info->ia_name); + DAT_PROVIDER *provider; + DAT_RETURN dat_status; + + dat_status = + dapl_provider_list_search(provider_info->ia_name, &provider); + if (DAT_SUCCESS != dat_status) { + dapl_dbg_log(DAPL_DBG_TYPE_ERR, + "dat_registry_add_provider failed: %x\n", + dat_status); + return; + } + + dat_status = dat_registry_remove_provider(provider, provider_info); + if (DAT_SUCCESS != dat_status) { + dapl_dbg_log(DAPL_DBG_TYPE_ERR, + "dat_registry_add_provider failed: %x\n", + dat_status); + } + + /* + * free HCA memory + */ + dapl_hca_free(provider->extension); + + (void)dapl_provider_list_remove(provider_info->ia_name); #if defined(_WIN32) || defined(_WIN64) - /* cleanup DAPL library - relocated here from OSD DLL context as the IBAL - * calls hung in the DLL context? - */ - dapl_fini(); + /* cleanup DAPL library - relocated here from OSD DLL context as the IBAL + * calls hung in the DLL context? + */ + dapl_fini(); #endif } - /* * Local variables: * c-indent-level: 4 diff --git a/dapl/udapl/dapl_lmr_create.c b/dapl/udapl/dapl_lmr_create.c index dd93445..849f4fe 100644 --- a/dapl/udapl/dapl_lmr_create.c +++ b/dapl/udapl/dapl_lmr_create.c @@ -45,46 +45,42 @@ *********************************************************************/ STATIC _INLINE_ DAT_RETURN -dapli_lmr_create_virtual ( - IN DAPL_IA *ia, - IN DAT_PVOID virt_addr, - IN DAT_VLEN length, - IN DAPL_PZ *pz, - IN DAT_MEM_PRIV_FLAGS privileges, - IN DAT_VA_TYPE va_type, - OUT DAT_LMR_HANDLE *lmr_handle, - OUT DAT_LMR_CONTEXT *lmr_context, - OUT DAT_RMR_CONTEXT *rmr_context, - OUT DAT_VLEN *registered_length, - OUT DAT_VADDR *registered_address ); +dapli_lmr_create_virtual(IN DAPL_IA * ia, + IN DAT_PVOID virt_addr, + IN DAT_VLEN length, + IN DAPL_PZ * pz, + IN DAT_MEM_PRIV_FLAGS privileges, + IN DAT_VA_TYPE va_type, + OUT DAT_LMR_HANDLE * lmr_handle, + OUT DAT_LMR_CONTEXT * lmr_context, + OUT DAT_RMR_CONTEXT * rmr_context, + OUT DAT_VLEN * registered_length, + OUT DAT_VADDR * registered_address); STATIC _INLINE_ DAT_RETURN -dapli_lmr_create_lmr ( - IN DAPL_IA *ia, - IN DAPL_LMR *original_lmr, - IN DAPL_PZ *pz, - IN DAT_MEM_PRIV_FLAGS privileges, - IN DAT_VA_TYPE va_type, - OUT DAT_LMR_HANDLE *lmr_handle, - OUT DAT_LMR_CONTEXT *lmr_context, - OUT DAT_RMR_CONTEXT *rmr_context, - OUT DAT_VLEN *registered_length, - OUT DAT_VADDR *registered_address ); - +dapli_lmr_create_lmr(IN DAPL_IA * ia, + IN DAPL_LMR * original_lmr, + IN DAPL_PZ * pz, + IN DAT_MEM_PRIV_FLAGS privileges, + IN DAT_VA_TYPE va_type, + OUT DAT_LMR_HANDLE * lmr_handle, + OUT DAT_LMR_CONTEXT * lmr_context, + OUT DAT_RMR_CONTEXT * rmr_context, + OUT DAT_VLEN * registered_length, + OUT DAT_VADDR * registered_address); STATIC _INLINE_ DAT_RETURN -dapli_lmr_create_shared ( - IN DAPL_IA *ia, - IN DAT_REGION_DESCRIPTION reg_desc, - IN DAT_VLEN length, - IN DAPL_PZ *pz, - IN DAT_MEM_PRIV_FLAGS privileges, - IN DAT_VA_TYPE va_type, - OUT DAT_LMR_HANDLE *lmr_handle, - OUT DAT_LMR_CONTEXT *lmr_context, - OUT DAT_RMR_CONTEXT *rmr_context, - OUT DAT_VLEN *registered_length, - OUT DAT_VADDR *registered_address ); +dapli_lmr_create_shared(IN DAPL_IA * ia, + IN DAT_REGION_DESCRIPTION reg_desc, + IN DAT_VLEN length, + IN DAPL_PZ * pz, + IN DAT_MEM_PRIV_FLAGS privileges, + IN DAT_VA_TYPE va_type, + OUT DAT_LMR_HANDLE * lmr_handle, + OUT DAT_LMR_CONTEXT * lmr_context, + OUT DAT_RMR_CONTEXT * rmr_context, + OUT DAT_VLEN * registered_length, + OUT DAT_VADDR * registered_address); /********************************************************************* * * @@ -93,335 +89,291 @@ dapli_lmr_create_shared ( *********************************************************************/ DAT_RETURN -dapli_lmr_create_virtual ( - IN DAPL_IA *ia, - IN DAT_PVOID virt_addr, - IN DAT_VLEN length, - IN DAPL_PZ *pz, - IN DAT_MEM_PRIV_FLAGS privileges, - IN DAT_VA_TYPE va_type, - OUT DAT_LMR_HANDLE *lmr_handle, - OUT DAT_LMR_CONTEXT *lmr_context, - OUT DAT_RMR_CONTEXT *rmr_context, - OUT DAT_VLEN *registered_length, - OUT DAT_VADDR *registered_address ) +dapli_lmr_create_virtual(IN DAPL_IA * ia, + IN DAT_PVOID virt_addr, + IN DAT_VLEN length, + IN DAPL_PZ * pz, + IN DAT_MEM_PRIV_FLAGS privileges, + IN DAT_VA_TYPE va_type, + OUT DAT_LMR_HANDLE * lmr_handle, + OUT DAT_LMR_CONTEXT * lmr_context, + OUT DAT_RMR_CONTEXT * rmr_context, + OUT DAT_VLEN * registered_length, + OUT DAT_VADDR * registered_address) { - DAPL_LMR *lmr; - DAT_REGION_DESCRIPTION reg_desc; - DAT_RETURN dat_status; - - reg_desc.for_va = virt_addr; - dat_status = DAT_SUCCESS; - - lmr = dapl_lmr_alloc (ia, - DAT_MEM_TYPE_VIRTUAL, - reg_desc, - length, - (DAT_PZ_HANDLE) pz, - privileges); - - if ( NULL == lmr ) - { - dat_status = DAT_ERROR (DAT_INSUFFICIENT_RESOURCES,DAT_RESOURCE_MEMORY); - goto bail; - } - - dat_status = dapls_ib_mr_register (ia, - lmr, - virt_addr, - length, - privileges, - va_type); - - if (DAT_SUCCESS != dat_status) - { - dapl_lmr_dealloc (lmr); - goto bail; - } - - /* if the LMR context is already in the hash table */ - dat_status = dapls_hash_search (ia->hca_ptr->lmr_hash_table, - lmr->param.lmr_context, - NULL); - if (dat_status == DAT_SUCCESS) - { - (void)dapls_ib_mr_deregister (lmr); - dapl_lmr_dealloc (lmr); - - dat_status = DAT_ERROR (DAT_INVALID_STATE,DAT_INVALID_STATE_LMR_IN_USE); - goto bail; - } - - dat_status = dapls_hash_insert (ia->hca_ptr->lmr_hash_table, - lmr->param.lmr_context, - lmr); - if (dat_status != DAT_SUCCESS) - { - (void)dapls_ib_mr_deregister (lmr); - dapl_lmr_dealloc (lmr); - - /* The value returned by dapls_hash_insert(.) is not */ - /* returned to the consumer because the spec. requires */ - /* that dat_lmr_create(.) return only certain values. */ - dat_status = DAT_ERROR (DAT_INSUFFICIENT_RESOURCES,DAT_RESOURCE_MEMORY); - goto bail; - } - - dapl_os_atomic_inc (&pz->pz_ref_count); - *lmr_handle = (DAT_LMR_HANDLE) lmr; - - if (NULL != lmr_context) - { - *lmr_context = lmr->param.lmr_context; - } - if (NULL != rmr_context) - { - *rmr_context = lmr->param.rmr_context; - } - if (NULL != registered_length) - { - *registered_length = lmr->param.registered_size; - } - if (NULL != registered_address) - { - *registered_address = lmr->param.registered_address; - } - - bail: - return dat_status; -} + DAPL_LMR *lmr; + DAT_REGION_DESCRIPTION reg_desc; + DAT_RETURN dat_status; + + reg_desc.for_va = virt_addr; + dat_status = DAT_SUCCESS; + + lmr = dapl_lmr_alloc(ia, + DAT_MEM_TYPE_VIRTUAL, + reg_desc, length, (DAT_PZ_HANDLE) pz, privileges); + + if (NULL == lmr) { + dat_status = + DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY); + goto bail; + } + + dat_status = dapls_ib_mr_register(ia, + lmr, + virt_addr, + length, privileges, va_type); + + if (DAT_SUCCESS != dat_status) { + dapl_lmr_dealloc(lmr); + goto bail; + } + + /* if the LMR context is already in the hash table */ + dat_status = dapls_hash_search(ia->hca_ptr->lmr_hash_table, + lmr->param.lmr_context, NULL); + if (dat_status == DAT_SUCCESS) { + (void)dapls_ib_mr_deregister(lmr); + dapl_lmr_dealloc(lmr); + + dat_status = + DAT_ERROR(DAT_INVALID_STATE, DAT_INVALID_STATE_LMR_IN_USE); + goto bail; + } + + dat_status = dapls_hash_insert(ia->hca_ptr->lmr_hash_table, + lmr->param.lmr_context, lmr); + if (dat_status != DAT_SUCCESS) { + (void)dapls_ib_mr_deregister(lmr); + dapl_lmr_dealloc(lmr); + + /* The value returned by dapls_hash_insert(.) is not */ + /* returned to the consumer because the spec. requires */ + /* that dat_lmr_create(.) return only certain values. */ + dat_status = + DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY); + goto bail; + } + + dapl_os_atomic_inc(&pz->pz_ref_count); + *lmr_handle = (DAT_LMR_HANDLE) lmr; + + if (NULL != lmr_context) { + *lmr_context = lmr->param.lmr_context; + } + if (NULL != rmr_context) { + *rmr_context = lmr->param.rmr_context; + } + if (NULL != registered_length) { + *registered_length = lmr->param.registered_size; + } + if (NULL != registered_address) { + *registered_address = lmr->param.registered_address; + } + bail: + return dat_status; +} DAT_RETURN -dapli_lmr_create_lmr ( - IN DAPL_IA *ia, - IN DAPL_LMR *original_lmr, - IN DAPL_PZ *pz, - IN DAT_MEM_PRIV_FLAGS privileges, - IN DAT_VA_TYPE va_type, - OUT DAT_LMR_HANDLE *lmr_handle, - OUT DAT_LMR_CONTEXT *lmr_context, - OUT DAT_RMR_CONTEXT *rmr_context, - OUT DAT_VLEN *registered_length, - OUT DAT_VADDR *registered_address ) +dapli_lmr_create_lmr(IN DAPL_IA * ia, + IN DAPL_LMR * original_lmr, + IN DAPL_PZ * pz, + IN DAT_MEM_PRIV_FLAGS privileges, + IN DAT_VA_TYPE va_type, + OUT DAT_LMR_HANDLE * lmr_handle, + OUT DAT_LMR_CONTEXT * lmr_context, + OUT DAT_RMR_CONTEXT * rmr_context, + OUT DAT_VLEN * registered_length, + OUT DAT_VADDR * registered_address) { - DAPL_LMR *lmr; - DAT_REGION_DESCRIPTION reg_desc; - DAT_RETURN dat_status; - DAPL_HASH_DATA hash_lmr; - - dapl_dbg_log (DAPL_DBG_TYPE_API, - "dapl_lmr_create_lmr (%p, %p, %p, %x, %x, %p, %p, %p, %p)\n", - ia, - original_lmr, - pz, privileges, va_type, - lmr_handle, - lmr_context, - registered_length, - registered_address); - - dat_status = dapls_hash_search (ia->hca_ptr->lmr_hash_table, - original_lmr->param.lmr_context, - &hash_lmr); - if ( dat_status != DAT_SUCCESS ) - { - dat_status = DAT_ERROR (DAT_INVALID_PARAMETER,DAT_INVALID_ARG2); - goto bail; - } - lmr = (DAPL_LMR*)hash_lmr; - reg_desc.for_lmr_handle = (DAT_LMR_HANDLE) original_lmr; - - lmr = dapl_lmr_alloc (ia, - DAT_MEM_TYPE_LMR, - reg_desc, - original_lmr->param.length, - (DAT_PZ_HANDLE) pz, - privileges); - - if (NULL == lmr) - { - dat_status = DAT_ERROR (DAT_INSUFFICIENT_RESOURCES,DAT_RESOURCE_MEMORY); - goto bail; - } - - dat_status = dapls_ib_mr_register_shared (ia, - lmr, - privileges, - va_type); - - if (DAT_SUCCESS != dat_status) - { - dapl_lmr_dealloc (lmr); - goto bail; - } - - /* if the LMR context is already in the hash table */ - dat_status = dapls_hash_search (ia->hca_ptr->lmr_hash_table, - lmr->param.lmr_context, - NULL); - if (dat_status == DAT_SUCCESS) - { - dapls_ib_mr_deregister (lmr); - dapl_lmr_dealloc (lmr); - - dat_status = DAT_ERROR (DAT_INVALID_STATE,DAT_INVALID_STATE_LMR_IN_USE); - goto bail; - } - - dat_status = dapls_hash_insert (ia->hca_ptr->lmr_hash_table, - lmr->param.lmr_context, - lmr); - if (dat_status != DAT_SUCCESS) - { - dapls_ib_mr_deregister (lmr); - dapl_lmr_dealloc (lmr); - - /* The value returned by dapls_hash_insert(.) is not */ - /* returned to the consumer because the spec. requires */ - /* that dat_lmr_create(.) return only certain values. */ - dat_status = DAT_ERROR (DAT_INSUFFICIENT_RESOURCES,DAT_RESOURCE_MEMORY); - goto bail; - } - - dapl_os_atomic_inc (&pz->pz_ref_count); - *lmr_handle = (DAT_LMR_HANDLE) lmr; - - if (NULL != lmr_context) - { - *lmr_context = lmr->param.lmr_context; - } - if (NULL != rmr_context) - { - *rmr_context = lmr->param.rmr_context; - } - if (NULL != registered_length) - { - *registered_length = lmr->param.registered_size; - } - if (NULL != registered_address) - { - *registered_address = lmr->param.registered_address; - } - - bail: - return dat_status; -} + DAPL_LMR *lmr; + DAT_REGION_DESCRIPTION reg_desc; + DAT_RETURN dat_status; + DAPL_HASH_DATA hash_lmr; + + dapl_dbg_log(DAPL_DBG_TYPE_API, + "dapl_lmr_create_lmr (%p, %p, %p, %x, %x, %p, %p, %p, %p)\n", + ia, + original_lmr, + pz, privileges, va_type, + lmr_handle, + lmr_context, registered_length, registered_address); + + dat_status = dapls_hash_search(ia->hca_ptr->lmr_hash_table, + original_lmr->param.lmr_context, + &hash_lmr); + if (dat_status != DAT_SUCCESS) { + dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2); + goto bail; + } + lmr = (DAPL_LMR *) hash_lmr; + reg_desc.for_lmr_handle = (DAT_LMR_HANDLE) original_lmr; + + lmr = dapl_lmr_alloc(ia, + DAT_MEM_TYPE_LMR, + reg_desc, + original_lmr->param.length, + (DAT_PZ_HANDLE) pz, privileges); + + if (NULL == lmr) { + dat_status = + DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY); + goto bail; + } + + dat_status = dapls_ib_mr_register_shared(ia, lmr, privileges, va_type); + + if (DAT_SUCCESS != dat_status) { + dapl_lmr_dealloc(lmr); + goto bail; + } + + /* if the LMR context is already in the hash table */ + dat_status = dapls_hash_search(ia->hca_ptr->lmr_hash_table, + lmr->param.lmr_context, NULL); + if (dat_status == DAT_SUCCESS) { + dapls_ib_mr_deregister(lmr); + dapl_lmr_dealloc(lmr); + + dat_status = + DAT_ERROR(DAT_INVALID_STATE, DAT_INVALID_STATE_LMR_IN_USE); + goto bail; + } + + dat_status = dapls_hash_insert(ia->hca_ptr->lmr_hash_table, + lmr->param.lmr_context, lmr); + if (dat_status != DAT_SUCCESS) { + dapls_ib_mr_deregister(lmr); + dapl_lmr_dealloc(lmr); + + /* The value returned by dapls_hash_insert(.) is not */ + /* returned to the consumer because the spec. requires */ + /* that dat_lmr_create(.) return only certain values. */ + dat_status = + DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY); + goto bail; + } + + dapl_os_atomic_inc(&pz->pz_ref_count); + *lmr_handle = (DAT_LMR_HANDLE) lmr; + if (NULL != lmr_context) { + *lmr_context = lmr->param.lmr_context; + } + if (NULL != rmr_context) { + *rmr_context = lmr->param.rmr_context; + } + if (NULL != registered_length) { + *registered_length = lmr->param.registered_size; + } + if (NULL != registered_address) { + *registered_address = lmr->param.registered_address; + } + bail: + return dat_status; +} DAT_RETURN -dapli_lmr_create_shared ( - IN DAPL_IA *ia, - IN DAT_REGION_DESCRIPTION reg_desc, - IN DAT_VLEN length, - IN DAPL_PZ *pz, - IN DAT_MEM_PRIV_FLAGS privileges, - IN DAT_VA_TYPE va_type, - OUT DAT_LMR_HANDLE *lmr_handle, - OUT DAT_LMR_CONTEXT *lmr_context, - OUT DAT_RMR_CONTEXT *rmr_context, - OUT DAT_VLEN *registered_length, - OUT DAT_VADDR *registered_address ) +dapli_lmr_create_shared(IN DAPL_IA * ia, + IN DAT_REGION_DESCRIPTION reg_desc, + IN DAT_VLEN length, + IN DAPL_PZ * pz, + IN DAT_MEM_PRIV_FLAGS privileges, + IN DAT_VA_TYPE va_type, + OUT DAT_LMR_HANDLE * lmr_handle, + OUT DAT_LMR_CONTEXT * lmr_context, + OUT DAT_RMR_CONTEXT * rmr_context, + OUT DAT_VLEN * registered_length, + OUT DAT_VADDR * registered_address) { - DAPL_LMR *lmr; - DAT_RETURN dat_status; - - dat_status = DAT_SUCCESS; - - dapl_dbg_log (DAPL_DBG_TYPE_API, - "dapl_lmr_create_shared_virtual (ia=%p len=%x pz=%p priv=%x)\n", - ia, - length, - pz, privileges); - - lmr = dapl_lmr_alloc (ia, - DAT_MEM_TYPE_LMR, - reg_desc, - length, /* length is meaningless */ - (DAT_PZ_HANDLE) pz, - privileges); - - if (NULL == lmr) - { - dat_status = DAT_ERROR (DAT_INSUFFICIENT_RESOURCES,DAT_RESOURCE_MEMORY); - goto bail; - } - - /* - * Added for the shared memory support - - - - * Save the region description. We need to copy the shared - * memory id because the region_desc only contains a pointer - * to it. - */ - dapl_os_memcpy(&lmr->shmid, - reg_desc.for_shared_memory.shared_memory_id, - sizeof(lmr->shmid)); - lmr->param.region_desc = reg_desc; - lmr->param.length = length; - lmr->param.mem_type = DAT_MEM_TYPE_SHARED_VIRTUAL; - lmr->param.region_desc.for_shared_memory.shared_memory_id = &lmr->shmid; - - dat_status = dapls_ib_mr_register_shared(ia, lmr, privileges, va_type); - if (dat_status != DAT_SUCCESS) - { - dapl_lmr_dealloc (lmr); - dat_status = DAT_ERROR (DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY_REGION); - goto bail; - } - - /* if the LMR context is already in the hash table */ - dat_status = dapls_hash_search(ia->hca_ptr->lmr_hash_table, - lmr->param.lmr_context, - NULL); - if (DAT_SUCCESS == dat_status) - { - (void)dapls_ib_mr_deregister (lmr); - dapl_lmr_dealloc (lmr); - - dat_status = DAT_ERROR (DAT_INVALID_STATE,DAT_INVALID_STATE_LMR_IN_USE); - goto bail; - } - - dat_status = dapls_hash_insert(ia->hca_ptr->lmr_hash_table, - lmr->param.lmr_context, - lmr); - if (dat_status != DAT_SUCCESS) - { - (void)dapls_ib_mr_deregister (lmr); - dapl_lmr_dealloc (lmr); - - /* The value returned by dapls_hash_insert(.) is not */ - /* returned to the consumer because the spec. requires */ - /* that dat_lmr_create(.) return only certain values. */ - dat_status = DAT_ERROR (DAT_INSUFFICIENT_RESOURCES,DAT_RESOURCE_MEMORY); - goto bail; - } - - dapl_os_atomic_inc (&pz->pz_ref_count); - *lmr_handle = (DAT_LMR_HANDLE) lmr; - - if (NULL != lmr_context) - { - *lmr_context = (DAT_LMR_CONTEXT) lmr->param.lmr_context; - } - if (NULL != rmr_context) - { - *rmr_context = (DAT_LMR_CONTEXT) lmr->param.rmr_context; - } - if (NULL != registered_length) - { - *registered_length = lmr->param.length; - } - if (NULL != registered_address) - { - *registered_address = (DAT_VADDR) (uintptr_t) - lmr->param.region_desc.for_shared_memory.virtual_address; - } - bail: - - return dat_status; -} + DAPL_LMR *lmr; + DAT_RETURN dat_status; + + dat_status = DAT_SUCCESS; + + dapl_dbg_log(DAPL_DBG_TYPE_API, + "dapl_lmr_create_shared_virtual (ia=%p len=%x pz=%p priv=%x)\n", + ia, length, pz, privileges); + + lmr = dapl_lmr_alloc(ia, DAT_MEM_TYPE_LMR, reg_desc, length, /* length is meaningless */ + (DAT_PZ_HANDLE) pz, privileges); + + if (NULL == lmr) { + dat_status = + DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY); + goto bail; + } + + /* + * Added for the shared memory support - - - + * Save the region description. We need to copy the shared + * memory id because the region_desc only contains a pointer + * to it. + */ + dapl_os_memcpy(&lmr->shmid, + reg_desc.for_shared_memory.shared_memory_id, + sizeof(lmr->shmid)); + lmr->param.region_desc = reg_desc; + lmr->param.length = length; + lmr->param.mem_type = DAT_MEM_TYPE_SHARED_VIRTUAL; + lmr->param.region_desc.for_shared_memory.shared_memory_id = &lmr->shmid; + + dat_status = dapls_ib_mr_register_shared(ia, lmr, privileges, va_type); + if (dat_status != DAT_SUCCESS) { + dapl_lmr_dealloc(lmr); + dat_status = + DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, + DAT_RESOURCE_MEMORY_REGION); + goto bail; + } + + /* if the LMR context is already in the hash table */ + dat_status = dapls_hash_search(ia->hca_ptr->lmr_hash_table, + lmr->param.lmr_context, NULL); + if (DAT_SUCCESS == dat_status) { + (void)dapls_ib_mr_deregister(lmr); + dapl_lmr_dealloc(lmr); + + dat_status = + DAT_ERROR(DAT_INVALID_STATE, DAT_INVALID_STATE_LMR_IN_USE); + goto bail; + } + + dat_status = dapls_hash_insert(ia->hca_ptr->lmr_hash_table, + lmr->param.lmr_context, lmr); + if (dat_status != DAT_SUCCESS) { + (void)dapls_ib_mr_deregister(lmr); + dapl_lmr_dealloc(lmr); + + /* The value returned by dapls_hash_insert(.) is not */ + /* returned to the consumer because the spec. requires */ + /* that dat_lmr_create(.) return only certain values. */ + dat_status = + DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY); + goto bail; + } + + dapl_os_atomic_inc(&pz->pz_ref_count); + *lmr_handle = (DAT_LMR_HANDLE) lmr; + if (NULL != lmr_context) { + *lmr_context = (DAT_LMR_CONTEXT) lmr->param.lmr_context; + } + if (NULL != rmr_context) { + *rmr_context = (DAT_LMR_CONTEXT) lmr->param.rmr_context; + } + if (NULL != registered_length) { + *registered_length = lmr->param.length; + } + if (NULL != registered_address) { + *registered_address = (DAT_VADDR) (uintptr_t) + lmr->param.region_desc.for_shared_memory.virtual_address; + } + bail: + + return dat_status; +} /* * dapl_lmr_create @@ -452,91 +404,103 @@ dapli_lmr_create_shared ( * */ DAT_RETURN DAT_API -dapl_lmr_create ( - IN DAT_IA_HANDLE ia_handle, - IN DAT_MEM_TYPE mem_type, - IN DAT_REGION_DESCRIPTION region_description, - IN DAT_VLEN length, - IN DAT_PZ_HANDLE pz_handle, - IN DAT_MEM_PRIV_FLAGS privileges, - IN DAT_VA_TYPE va_type, - OUT DAT_LMR_HANDLE *lmr_handle, - OUT DAT_LMR_CONTEXT *lmr_context, - OUT DAT_RMR_CONTEXT *rmr_context, - OUT DAT_VLEN *registered_length, - OUT DAT_VADDR *registered_address ) +dapl_lmr_create(IN DAT_IA_HANDLE ia_handle, + IN DAT_MEM_TYPE mem_type, + IN DAT_REGION_DESCRIPTION region_description, + IN DAT_VLEN length, + IN DAT_PZ_HANDLE pz_handle, + IN DAT_MEM_PRIV_FLAGS privileges, + IN DAT_VA_TYPE va_type, + OUT DAT_LMR_HANDLE * lmr_handle, + OUT DAT_LMR_CONTEXT * lmr_context, + OUT DAT_RMR_CONTEXT * rmr_context, + OUT DAT_VLEN * registered_length, + OUT DAT_VADDR * registered_address) { - DAPL_IA *ia; - DAPL_PZ *pz; - DAT_RETURN dat_status; - - if ( DAPL_BAD_HANDLE (ia_handle, DAPL_MAGIC_IA) ) - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA); - goto bail; - } - if ( DAPL_BAD_HANDLE (pz_handle, DAPL_MAGIC_PZ) ) - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ); - goto bail; - } - if (NULL == lmr_handle) - { - dat_status = DAT_ERROR (DAT_INVALID_PARAMETER, DAT_INVALID_ARG7); - goto bail; - } - - ia = (DAPL_IA *) ia_handle; - pz = (DAPL_PZ *) pz_handle; - - DAPL_CNTR(ia, DCNT_IA_LMR_CREATE); - - switch (mem_type) - { - case DAT_MEM_TYPE_VIRTUAL: - { - dat_status = dapli_lmr_create_virtual ( - ia, region_description.for_va, length, pz, privileges, va_type, - lmr_handle, lmr_context, rmr_context, registered_length, - registered_address); - break; - } - case DAT_MEM_TYPE_LMR: - { - DAPL_LMR *lmr; + DAPL_IA *ia; + DAPL_PZ *pz; + DAT_RETURN dat_status; - if ( DAPL_BAD_HANDLE (region_description.for_lmr_handle, DAPL_MAGIC_LMR) ) - { - dat_status = DAT_ERROR (DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_LMR); + if (DAPL_BAD_HANDLE(ia_handle, DAPL_MAGIC_IA)) { + dat_status = + DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA); goto bail; - } + } + if (DAPL_BAD_HANDLE(pz_handle, DAPL_MAGIC_PZ)) { + dat_status = + DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ); + goto bail; + } + if (NULL == lmr_handle) { + dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG7); + goto bail; + } - lmr = (DAPL_LMR *) region_description.for_lmr_handle; + ia = (DAPL_IA *) ia_handle; + pz = (DAPL_PZ *) pz_handle; - dat_status = dapli_lmr_create_lmr ( - ia, lmr, pz, privileges, va_type, lmr_handle, - lmr_context, rmr_context, registered_length, registered_address); - break; - } + DAPL_CNTR(ia, DCNT_IA_LMR_CREATE); + + switch (mem_type) { + case DAT_MEM_TYPE_VIRTUAL: + { + dat_status = + dapli_lmr_create_virtual(ia, + region_description.for_va, + length, pz, privileges, + va_type, lmr_handle, + lmr_context, rmr_context, + registered_length, + registered_address); + break; + } + case DAT_MEM_TYPE_LMR: + { + DAPL_LMR *lmr; + + if (DAPL_BAD_HANDLE + (region_description.for_lmr_handle, + DAPL_MAGIC_LMR)) { + dat_status = + DAT_ERROR(DAT_INVALID_HANDLE, + DAT_INVALID_HANDLE_LMR); + goto bail; + } + + lmr = (DAPL_LMR *) region_description.for_lmr_handle; + + dat_status = + dapli_lmr_create_lmr(ia, lmr, pz, privileges, + va_type, lmr_handle, + lmr_context, rmr_context, + registered_length, + registered_address); + break; + } case DAT_MEM_TYPE_SHARED_VIRTUAL: - { + { #if (VN_MEM_SHARED_VIRTUAL_SUPPORT > 0) - dat_status = dapli_lmr_create_shared ( - ia, region_description, length, pz, privileges, va_type, - lmr_handle, lmr_context, rmr_context, registered_length, - registered_address); + dat_status = + dapli_lmr_create_shared(ia, region_description, + length, pz, privileges, + va_type, lmr_handle, + lmr_context, rmr_context, + registered_length, + registered_address); #else - dat_status = DAT_ERROR (DAT_NOT_IMPLEMENTED, DAT_NO_SUBTYPE); + dat_status = + DAT_ERROR(DAT_NOT_IMPLEMENTED, DAT_NO_SUBTYPE); #endif - break; - } + break; + } default: - { - dat_status = DAT_ERROR (DAT_INVALID_PARAMETER, DAT_INVALID_ARG2); - break; + { + dat_status = + DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2); + break; + } } - } -bail: - return dat_status; + bail: + return dat_status; } diff --git a/dapl/udapl/linux/dapl_osd.c b/dapl/udapl/linux/dapl_osd.c index 26c778c..78d7735 100644 --- a/dapl/udapl/linux/dapl_osd.c +++ b/dapl/udapl/linux/dapl_osd.c @@ -57,11 +57,11 @@ #include "dapl_debug.h" #include -#include /* needed for getenv() */ -#include /* needed for pthread_atfork() */ -#include /* needed for thread setup */ +#include /* needed for getenv() */ +#include /* needed for pthread_atfork() */ +#include /* needed for thread setup */ -static void dapls_osd_fork_cleanup (void); +static void dapls_osd_fork_cleanup(void); /* * dapl_osd_init @@ -76,21 +76,18 @@ static void dapls_osd_fork_cleanup (void); * Returns: * DAT_SUCCESS */ -void -dapl_os_init ( ) +void dapl_os_init() { - int status; - - /* - * Set up fork control - */ - status = pthread_atfork ( NULL, NULL, dapls_osd_fork_cleanup ); - if ( status != 0 ) - { - dapl_os_printf ("WARNING: pthread_atfork %d\n", status); - } -} + int status; + /* + * Set up fork control + */ + status = pthread_atfork(NULL, NULL, dapls_osd_fork_cleanup); + if (status != 0) { + dapl_os_printf("WARNING: pthread_atfork %d\n", status); + } +} /* * dapl_os_get_time @@ -104,21 +101,17 @@ dapl_os_init ( ) * DAT_SUCCESS */ -DAT_RETURN -dapl_os_get_time ( - OUT DAPL_OS_TIMEVAL * loc) +DAT_RETURN dapl_os_get_time(OUT DAPL_OS_TIMEVAL * loc) { - struct timeval tv; - struct timezone tz; - + struct timeval tv; + struct timezone tz; - gettimeofday (&tv, &tz); - *loc = ((DAT_UINT64) (tv.tv_sec) * 1000000L) + (DAT_UINT64) tv.tv_usec; + gettimeofday(&tv, &tz); + *loc = ((DAT_UINT64) (tv.tv_sec) * 1000000L) + (DAT_UINT64) tv.tv_usec; - return DAT_SUCCESS; + return DAT_SUCCESS; } - /* * dapl_os_get__env_bool * @@ -131,22 +124,18 @@ dapl_os_get_time ( * Returns: * TRUE or FALSE */ -int -dapl_os_get_env_bool ( - char *env_str ) +int dapl_os_get_env_bool(char *env_str) { - char *env_var; + char *env_var; - env_var = getenv (env_str); - if (env_var != NULL) - { - return 1; - } + env_var = getenv(env_str); + if (env_var != NULL) { + return 1; + } - return 0; + return 0; } - /* * dapl_os_get_env_val * @@ -159,23 +148,18 @@ dapl_os_get_env_bool ( * Returns: * TRUE or FALSE */ -int -dapl_os_get_env_val ( - char *env_str, - int def_val ) +int dapl_os_get_env_val(char *env_str, int def_val) { - char *env_var; + char *env_var; - env_var = getenv (env_str); - if ( env_var != NULL ) - { - def_val = strtol (env_var, NULL, 0); - } + env_var = getenv(env_str); + if (env_var != NULL) { + def_val = strtol(env_var, NULL, 0); + } - return def_val; + return def_val; } - /* * Wait object routines */ @@ -192,23 +176,19 @@ dapl_os_get_env_val ( * DAT_SUCCESS * DAT_INTERNAL_ERROR */ -DAT_RETURN -dapl_os_wait_object_init ( - IN DAPL_OS_WAIT_OBJECT *wait_obj) +DAT_RETURN dapl_os_wait_object_init(IN DAPL_OS_WAIT_OBJECT * wait_obj) { - wait_obj->signaled = DAT_FALSE; - if ( 0 != pthread_cond_init ( &wait_obj->cv, NULL ) ) - { - return DAT_ERROR (DAT_INTERNAL_ERROR,0); - } + wait_obj->signaled = DAT_FALSE; + if (0 != pthread_cond_init(&wait_obj->cv, NULL)) { + return DAT_ERROR(DAT_INTERNAL_ERROR, 0); + } - /* Always returns 0. */ - pthread_mutex_init ( &wait_obj->lock, NULL ); + /* Always returns 0. */ + pthread_mutex_init(&wait_obj->lock, NULL); - return DAT_SUCCESS; + return DAT_SUCCESS; } - /* Wait on the supplied wait object, up to the specified time_out. * A timeout of DAT_TIMEOUT_INFINITE will wait indefinitely. * Timeout should be specified in micro seconds. @@ -222,84 +202,71 @@ dapl_os_wait_object_init ( * DAT_TIMEOUT -- the specified time limit was reached. */ -DAT_RETURN -dapl_os_wait_object_wait ( - IN DAPL_OS_WAIT_OBJECT *wait_obj, - IN DAT_TIMEOUT timeout_val) +DAT_RETURN +dapl_os_wait_object_wait(IN DAPL_OS_WAIT_OBJECT * wait_obj, + IN DAT_TIMEOUT timeout_val) { - DAT_RETURN dat_status; - int pthread_status; - struct timespec future; + DAT_RETURN dat_status; + int pthread_status; + struct timespec future; - dat_status = DAT_SUCCESS; - pthread_status = 0; + dat_status = DAT_SUCCESS; + pthread_status = 0; - if ( timeout_val != DAT_TIMEOUT_INFINITE ) - { - struct timeval now; - struct timezone tz; - unsigned int microsecs; + if (timeout_val != DAT_TIMEOUT_INFINITE) { + struct timeval now; + struct timezone tz; + unsigned int microsecs; - gettimeofday (&now, &tz); + gettimeofday(&now, &tz); #define USEC_PER_SEC 1000000 - microsecs = now.tv_usec + timeout_val; - now.tv_sec = now.tv_sec + microsecs/USEC_PER_SEC; - now.tv_usec = microsecs % USEC_PER_SEC; - - /* Convert timeval to timespec */ - future.tv_sec = now.tv_sec; - future.tv_nsec = now.tv_usec * 1000; - - pthread_mutex_lock (&wait_obj->lock); - while ( wait_obj->signaled == DAT_FALSE && pthread_status == 0) - { - pthread_status = pthread_cond_timedwait ( - &wait_obj->cv , &wait_obj->lock , &future ); - - /* - * No need to reset &future if we go around the loop; - * It's an absolute time. - */ - } - /* Reset the signaled status if we were woken up. */ - if (pthread_status == 0) - { - wait_obj->signaled = DAT_FALSE; - } - pthread_mutex_unlock (&wait_obj->lock); - } - else - { - pthread_mutex_lock (&wait_obj->lock); - while ( wait_obj->signaled == DAT_FALSE && pthread_status == 0) - { - pthread_status = pthread_cond_wait ( - &wait_obj->cv , &wait_obj->lock ); + microsecs = now.tv_usec + timeout_val; + now.tv_sec = now.tv_sec + microsecs / USEC_PER_SEC; + now.tv_usec = microsecs % USEC_PER_SEC; + + /* Convert timeval to timespec */ + future.tv_sec = now.tv_sec; + future.tv_nsec = now.tv_usec * 1000; + + pthread_mutex_lock(&wait_obj->lock); + while (wait_obj->signaled == DAT_FALSE && pthread_status == 0) { + pthread_status = + pthread_cond_timedwait(&wait_obj->cv, + &wait_obj->lock, &future); + + /* + * No need to reset &future if we go around the loop; + * It's an absolute time. + */ + } + /* Reset the signaled status if we were woken up. */ + if (pthread_status == 0) { + wait_obj->signaled = DAT_FALSE; + } + pthread_mutex_unlock(&wait_obj->lock); + } else { + pthread_mutex_lock(&wait_obj->lock); + while (wait_obj->signaled == DAT_FALSE && pthread_status == 0) { + pthread_status = + pthread_cond_wait(&wait_obj->cv, &wait_obj->lock); + } + /* Reset the signaled status if we were woken up. */ + if (pthread_status == 0) { + wait_obj->signaled = DAT_FALSE; + } + pthread_mutex_unlock(&wait_obj->lock); } - /* Reset the signaled status if we were woken up. */ - if (pthread_status == 0) - { - wait_obj->signaled = DAT_FALSE; + + if (ETIMEDOUT == pthread_status) { + dat_status = DAT_ERROR(DAT_TIMEOUT_EXPIRED, 0); + } else if (EINTR == pthread_status) { + dat_status = DAT_ERROR(DAT_INTERRUPTED_CALL, 0); + } else if (0 != pthread_status) { + dat_status = DAT_ERROR(DAT_INTERNAL_ERROR, 0); } - pthread_mutex_unlock (&wait_obj->lock); - } - - if (ETIMEDOUT == pthread_status) - { - dat_status = DAT_ERROR (DAT_TIMEOUT_EXPIRED, 0); - } - else if ( EINTR == pthread_status) - { - dat_status = DAT_ERROR (DAT_INTERRUPTED_CALL, 0); - } - else if ( 0 != pthread_status) - { - dat_status = DAT_ERROR (DAT_INTERNAL_ERROR, 0); - } - - return dat_status; -} + return dat_status; +} /* * dapl_os_wait_object_wakeup @@ -313,21 +280,17 @@ dapl_os_wait_object_wait ( * DAT_SUCCESS * DAT_INTERNAL_ERROR */ -DAT_RETURN -dapl_os_wait_object_wakeup ( - IN DAPL_OS_WAIT_OBJECT *wait_obj) +DAT_RETURN dapl_os_wait_object_wakeup(IN DAPL_OS_WAIT_OBJECT * wait_obj) { - pthread_mutex_lock ( &wait_obj->lock ); - wait_obj->signaled = DAT_TRUE; - pthread_mutex_unlock ( &wait_obj->lock ); - if ( 0 != pthread_cond_signal ( &wait_obj->cv ) ) - { - return DAT_ERROR (DAT_INTERNAL_ERROR,0); - } - - return DAT_SUCCESS; -} + pthread_mutex_lock(&wait_obj->lock); + wait_obj->signaled = DAT_TRUE; + pthread_mutex_unlock(&wait_obj->lock); + if (0 != pthread_cond_signal(&wait_obj->cv)) { + return DAT_ERROR(DAT_INTERNAL_ERROR, 0); + } + return DAT_SUCCESS; +} /* * dapl_os_wait_object_destroy @@ -341,22 +304,17 @@ dapl_os_wait_object_wakeup ( * DAT_SUCCESS * DAT_INTERNAL_ERROR */ -DAT_RETURN -dapl_os_wait_object_destroy ( - IN DAPL_OS_WAIT_OBJECT *wait_obj) +DAT_RETURN dapl_os_wait_object_destroy(IN DAPL_OS_WAIT_OBJECT * wait_obj) { - if ( 0 != pthread_cond_destroy ( &wait_obj->cv ) ) - { - return DAT_ERROR (DAT_INTERNAL_ERROR,0); - } - if ( 0 != pthread_mutex_destroy ( &wait_obj->lock ) ) - { - return DAT_ERROR (DAT_INTERNAL_ERROR,0); - } - - return DAT_SUCCESS; -} + if (0 != pthread_cond_destroy(&wait_obj->cv)) { + return DAT_ERROR(DAT_INTERNAL_ERROR, 0); + } + if (0 != pthread_mutex_destroy(&wait_obj->lock)) { + return DAT_ERROR(DAT_INTERNAL_ERROR, 0); + } + return DAT_SUCCESS; +} /* * dapls_osd_fork_cleanup @@ -370,166 +328,180 @@ dapl_os_wait_object_destroy ( * Returns: * TRUE or FALSE */ -void dapls_osd_fork_cleanup (void) +void dapls_osd_fork_cleanup(void) { - DAPL_PROVIDER_LIST_NODE *cur_node; - DAPL_HCA *hca_ptr; - DAPL_IA *ia_ptr; - DAPL_LMR *lmr_ptr; - DAPL_RMR *rmr_ptr; - DAPL_PZ *pz_ptr; - DAPL_CR *cr_ptr; - DAPL_EP *ep_ptr; - DAPL_EVD *evd_ptr; - DAT_EP_PARAM *param; - DAPL_SP *sp_ptr; - - while ( NULL != g_dapl_provider_list.head ) - { - cur_node = g_dapl_provider_list.head; - g_dapl_provider_list.head = cur_node->next; - - hca_ptr = (DAPL_HCA *) cur_node->data.extension; - - /* - * Walk the list of IA ptrs & clean up. This is purposely - * a destructive list walk, we really don't want to preserve - * any of it. - */ - while (!dapl_llist_is_empty ( &hca_ptr->ia_list_head ) ) - { - ia_ptr = (DAPL_IA *) - dapl_llist_peek_head ( &hca_ptr->ia_list_head ); - - /* - * The rest of the cleanup code is similar to dapl_ia_close, - * the big difference is that we don't release IB resources, - * only memory; the underlying IB subsystem doesn't deal - * with fork at all, so leave IB handles alone. - */ - while (!dapl_llist_is_empty ( &ia_ptr->rmr_list_head ) ) - { - rmr_ptr = (DAPL_RMR *) - dapl_llist_peek_head (&ia_ptr->rmr_list_head); - if ( rmr_ptr->param.lmr_triplet.virtual_address != 0 ) - { - dapl_os_atomic_dec (&rmr_ptr->lmr->lmr_ref_count); - rmr_ptr->param.lmr_triplet.virtual_address = 0; - } - dapl_os_atomic_dec ( &rmr_ptr->pz->pz_ref_count ); - dapl_ia_unlink_rmr ( rmr_ptr->header.owner_ia, rmr_ptr ); - dapl_rmr_dealloc ( rmr_ptr ); - } - - while (!dapl_llist_is_empty ( &ia_ptr->rsp_list_head )) - { - sp_ptr = (DAPL_SP *) - dapl_llist_peek_head ( &ia_ptr->rsp_list_head ); - dapl_os_atomic_dec (& ((DAPL_EVD *)sp_ptr->evd_handle)->evd_ref_count); - dapls_ia_unlink_sp ( ia_ptr, sp_ptr ); - dapls_sp_free_sp ( sp_ptr ); - } - - while (!dapl_llist_is_empty ( &ia_ptr->ep_list_head ) ) - { - ep_ptr = (DAPL_EP *) - dapl_llist_peek_head ( &ia_ptr->ep_list_head ); - param = &ep_ptr->param; - if ( param->pz_handle != NULL ) - { - dapl_os_atomic_dec ( & ((DAPL_PZ *)param->pz_handle)->pz_ref_count ); - } - if ( param->recv_evd_handle != NULL ) - { - dapl_os_atomic_dec (& ((DAPL_EVD *)param->recv_evd_handle)->evd_ref_count); - } - if ( param->request_evd_handle ) - { - dapl_os_atomic_dec (& ((DAPL_EVD *)param->request_evd_handle)->evd_ref_count); - } - if ( param->connect_evd_handle != NULL ) - { - dapl_os_atomic_dec (& ((DAPL_EVD *)param->connect_evd_handle)->evd_ref_count); - } - - /* ...and free the resource */ - dapl_ia_unlink_ep ( ia_ptr, ep_ptr ); - dapl_ep_dealloc ( ep_ptr ); - } - - while ( !dapl_llist_is_empty (&ia_ptr->lmr_list_head) ) - { - lmr_ptr = (DAPL_LMR *) - dapl_llist_peek_head ( &ia_ptr->lmr_list_head ); - - (void) dapls_hash_remove ( lmr_ptr->header.owner_ia->hca_ptr->lmr_hash_table, - lmr_ptr->param.lmr_context, - NULL ); - - pz_ptr = (DAPL_PZ *) lmr_ptr->param.pz_handle; - dapl_os_atomic_dec ( &pz_ptr->pz_ref_count ); - dapl_ia_unlink_lmr ( lmr_ptr->header.owner_ia, lmr_ptr ); - dapl_lmr_dealloc ( lmr_ptr ); - } - - while ( !dapl_llist_is_empty ( &ia_ptr->psp_list_head ) ) - { - sp_ptr = (DAPL_SP *) - dapl_llist_peek_head ( &ia_ptr->psp_list_head ); - while ( !dapl_llist_is_empty (&sp_ptr->cr_list_head) ) - { - cr_ptr = (DAPL_CR *) - dapl_llist_peek_head ( &sp_ptr->cr_list_head ); - dapl_sp_remove_cr (sp_ptr, cr_ptr); - dapls_cr_free (cr_ptr); - } - - dapls_ia_unlink_sp ( ia_ptr, sp_ptr ); - dapl_os_atomic_dec (& ((DAPL_EVD *)sp_ptr->evd_handle)->evd_ref_count); - dapls_sp_free_sp ( sp_ptr ); - } - - while (!dapl_llist_is_empty ( &ia_ptr->pz_list_head ) ) - { - pz_ptr = (DAPL_PZ *) - dapl_llist_peek_head ( &ia_ptr->pz_list_head ); - dapl_ia_unlink_pz (pz_ptr->header.owner_ia, pz_ptr); - dapl_pz_dealloc ( pz_ptr ); - } - - while (!dapl_llist_is_empty (&ia_ptr->evd_list_head)) - { - evd_ptr = (DAPL_EVD *) - dapl_llist_peek_head ( &ia_ptr->evd_list_head ); - dapl_ia_unlink_evd ( evd_ptr->header.owner_ia, evd_ptr ); - /* reset the cq_handle to avoid having it removed */ - evd_ptr->ib_cq_handle = IB_INVALID_HANDLE; - dapls_evd_dealloc ( evd_ptr ); - } - - dapl_hca_unlink_ia ( ia_ptr->hca_ptr, ia_ptr ); - /* asycn error evd was taken care of above, reset the pointer */ - ia_ptr->async_error_evd = NULL; - dapls_ia_free ( ia_ptr ); - } /* end while ( ia_ptr != NULL ) */ - - - dapl_os_free (cur_node, sizeof (DAPL_PROVIDER_LIST_NODE)); - } /* end while (NULL != g_dapl_provider_list.head) */ + DAPL_PROVIDER_LIST_NODE *cur_node; + DAPL_HCA *hca_ptr; + DAPL_IA *ia_ptr; + DAPL_LMR *lmr_ptr; + DAPL_RMR *rmr_ptr; + DAPL_PZ *pz_ptr; + DAPL_CR *cr_ptr; + DAPL_EP *ep_ptr; + DAPL_EVD *evd_ptr; + DAT_EP_PARAM *param; + DAPL_SP *sp_ptr; + + while (NULL != g_dapl_provider_list.head) { + cur_node = g_dapl_provider_list.head; + g_dapl_provider_list.head = cur_node->next; + + hca_ptr = (DAPL_HCA *) cur_node->data.extension; + + /* + * Walk the list of IA ptrs & clean up. This is purposely + * a destructive list walk, we really don't want to preserve + * any of it. + */ + while (!dapl_llist_is_empty(&hca_ptr->ia_list_head)) { + ia_ptr = (DAPL_IA *) + dapl_llist_peek_head(&hca_ptr->ia_list_head); + + /* + * The rest of the cleanup code is similar to dapl_ia_close, + * the big difference is that we don't release IB resources, + * only memory; the underlying IB subsystem doesn't deal + * with fork at all, so leave IB handles alone. + */ + while (!dapl_llist_is_empty(&ia_ptr->rmr_list_head)) { + rmr_ptr = (DAPL_RMR *) + dapl_llist_peek_head(&ia_ptr-> + rmr_list_head); + if (rmr_ptr->param.lmr_triplet. + virtual_address != 0) { + dapl_os_atomic_dec(&rmr_ptr->lmr-> + lmr_ref_count); + rmr_ptr->param.lmr_triplet. + virtual_address = 0; + } + dapl_os_atomic_dec(&rmr_ptr->pz->pz_ref_count); + dapl_ia_unlink_rmr(rmr_ptr->header.owner_ia, + rmr_ptr); + dapl_rmr_dealloc(rmr_ptr); + } + + while (!dapl_llist_is_empty(&ia_ptr->rsp_list_head)) { + sp_ptr = (DAPL_SP *) + dapl_llist_peek_head(&ia_ptr-> + rsp_list_head); + dapl_os_atomic_dec(& + ((DAPL_EVD *) sp_ptr-> + evd_handle)->evd_ref_count); + dapls_ia_unlink_sp(ia_ptr, sp_ptr); + dapls_sp_free_sp(sp_ptr); + } + + while (!dapl_llist_is_empty(&ia_ptr->ep_list_head)) { + ep_ptr = (DAPL_EP *) + dapl_llist_peek_head(&ia_ptr->ep_list_head); + param = &ep_ptr->param; + if (param->pz_handle != NULL) { + dapl_os_atomic_dec(& + ((DAPL_PZ *) param-> + pz_handle)-> + pz_ref_count); + } + if (param->recv_evd_handle != NULL) { + dapl_os_atomic_dec(& + ((DAPL_EVD *) param-> + recv_evd_handle)-> + evd_ref_count); + } + if (param->request_evd_handle) { + dapl_os_atomic_dec(& + ((DAPL_EVD *) param-> + request_evd_handle)-> + evd_ref_count); + } + if (param->connect_evd_handle != NULL) { + dapl_os_atomic_dec(& + ((DAPL_EVD *) param-> + connect_evd_handle)-> + evd_ref_count); + } + + /* ...and free the resource */ + dapl_ia_unlink_ep(ia_ptr, ep_ptr); + dapl_ep_dealloc(ep_ptr); + } + + while (!dapl_llist_is_empty(&ia_ptr->lmr_list_head)) { + lmr_ptr = (DAPL_LMR *) + dapl_llist_peek_head(&ia_ptr-> + lmr_list_head); + + (void)dapls_hash_remove(lmr_ptr->header. + owner_ia->hca_ptr-> + lmr_hash_table, + lmr_ptr->param. + lmr_context, NULL); + + pz_ptr = (DAPL_PZ *) lmr_ptr->param.pz_handle; + dapl_os_atomic_dec(&pz_ptr->pz_ref_count); + dapl_ia_unlink_lmr(lmr_ptr->header.owner_ia, + lmr_ptr); + dapl_lmr_dealloc(lmr_ptr); + } + + while (!dapl_llist_is_empty(&ia_ptr->psp_list_head)) { + sp_ptr = (DAPL_SP *) + dapl_llist_peek_head(&ia_ptr-> + psp_list_head); + while (!dapl_llist_is_empty + (&sp_ptr->cr_list_head)) { + cr_ptr = (DAPL_CR *) + dapl_llist_peek_head(&sp_ptr-> + cr_list_head); + dapl_sp_remove_cr(sp_ptr, cr_ptr); + dapls_cr_free(cr_ptr); + } + + dapls_ia_unlink_sp(ia_ptr, sp_ptr); + dapl_os_atomic_dec(& + ((DAPL_EVD *) sp_ptr-> + evd_handle)->evd_ref_count); + dapls_sp_free_sp(sp_ptr); + } + + while (!dapl_llist_is_empty(&ia_ptr->pz_list_head)) { + pz_ptr = (DAPL_PZ *) + dapl_llist_peek_head(&ia_ptr->pz_list_head); + dapl_ia_unlink_pz(pz_ptr->header.owner_ia, + pz_ptr); + dapl_pz_dealloc(pz_ptr); + } + + while (!dapl_llist_is_empty(&ia_ptr->evd_list_head)) { + evd_ptr = (DAPL_EVD *) + dapl_llist_peek_head(&ia_ptr-> + evd_list_head); + dapl_ia_unlink_evd(evd_ptr->header.owner_ia, + evd_ptr); + /* reset the cq_handle to avoid having it removed */ + evd_ptr->ib_cq_handle = IB_INVALID_HANDLE; + dapls_evd_dealloc(evd_ptr); + } + + dapl_hca_unlink_ia(ia_ptr->hca_ptr, ia_ptr); + /* asycn error evd was taken care of above, reset the pointer */ + ia_ptr->async_error_evd = NULL; + dapls_ia_free(ia_ptr); + } /* end while ( ia_ptr != NULL ) */ + + dapl_os_free(cur_node, sizeof(DAPL_PROVIDER_LIST_NODE)); + } /* end while (NULL != g_dapl_provider_list.head) */ } - /* * Structure to contain all elements of a thread in order to enable a * local routine to intercept and do some necessary initialization. */ -struct thread_draft -{ - void (*func) (void *); /* start routine */ - void *data; /* argument to start routine */ +struct thread_draft { + void (*func) (void *); /* start routine */ + void *data; /* argument to start routine */ }; -void dapli_thread_init ( struct thread_draft *thread_draft); +void dapli_thread_init(struct thread_draft *thread_draft); /* * dapls_os_thread_create @@ -546,56 +518,51 @@ void dapli_thread_init ( struct thread_draft *thread_draft); * Returns: * DAT_SUCCESS */ -DAT_RETURN -dapl_os_thread_create ( - IN void (*func) (void *), - IN void *data, - OUT DAPL_OS_THREAD *thread_id ) +DAT_RETURN +dapl_os_thread_create(IN void (*func) (void *), + IN void *data, OUT DAPL_OS_THREAD * thread_id) { - pthread_attr_t thread_attr; - struct thread_draft *thread_draft; - int status; - - /* - * Get default set of thread attributes - */ - status = pthread_attr_init ( &thread_attr ); - if ( status != 0 ) - { - return DAT_ERROR (DAT_INTERNAL_ERROR,0); - } - - /* Create dapl threads as detached from this process */ - status = pthread_attr_setdetachstate ( &thread_attr, - PTHREAD_CREATE_DETACHED ); - if ( status != 0 ) - { - return DAT_ERROR (DAT_INTERNAL_ERROR,0); - } - - thread_draft = dapl_os_alloc (sizeof ( struct thread_draft)); - - thread_draft->func = func; - thread_draft->data = data; - - /* Create the thread. Observe that we first invoke a local - * routine to set up OS parameters, before invoking the user - * specified routine. - */ - status = pthread_create ( thread_id, - &thread_attr, - (void * (*) (void *))dapli_thread_init, - (void *)thread_draft ); - - /* clean up resources */ - (void) pthread_attr_destroy ( &thread_attr ); - - if ( status != 0 ) - { - return DAT_ERROR (DAT_INSUFFICIENT_RESOURCES,0); - } - - return DAT_SUCCESS; + pthread_attr_t thread_attr; + struct thread_draft *thread_draft; + int status; + + /* + * Get default set of thread attributes + */ + status = pthread_attr_init(&thread_attr); + if (status != 0) { + return DAT_ERROR(DAT_INTERNAL_ERROR, 0); + } + + /* Create dapl threads as detached from this process */ + status = pthread_attr_setdetachstate(&thread_attr, + PTHREAD_CREATE_DETACHED); + if (status != 0) { + return DAT_ERROR(DAT_INTERNAL_ERROR, 0); + } + + thread_draft = dapl_os_alloc(sizeof(struct thread_draft)); + + thread_draft->func = func; + thread_draft->data = data; + + /* Create the thread. Observe that we first invoke a local + * routine to set up OS parameters, before invoking the user + * specified routine. + */ + status = pthread_create(thread_id, + &thread_attr, + (void *(*)(void *))dapli_thread_init, + (void *)thread_draft); + + /* clean up resources */ + (void)pthread_attr_destroy(&thread_attr); + + if (status != 0) { + return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, 0); + } + + return DAT_SUCCESS; } /* @@ -607,25 +574,22 @@ dapl_os_thread_create ( * this should be a user thread, not a dapl thread */ -void -dapli_thread_init ( - struct thread_draft *thread_draft) +void dapli_thread_init(struct thread_draft *thread_draft) { - sigset_t sigset; - void (*func) (void *); - void *data; + sigset_t sigset; + void (*func) (void *); + void *data; - sigfillset (&sigset); - pthread_sigmask ( SIG_BLOCK, &sigset, NULL); + sigfillset(&sigset); + pthread_sigmask(SIG_BLOCK, &sigset, NULL); - func = thread_draft->func; - data = thread_draft->data; - dapl_os_free (thread_draft, sizeof ( struct thread_draft )); + func = thread_draft->func; + data = thread_draft->data; + dapl_os_free(thread_draft, sizeof(struct thread_draft)); - (*func) (data); + (*func) (data); } - /* * Local variables: * c-indent-level: 4 diff --git a/dapl/udapl/udapl_sources.c b/dapl/udapl/udapl_sources.c index bf87b4c..bbb77f2 100644 --- a/dapl/udapl/udapl_sources.c +++ b/dapl/udapl/udapl_sources.c @@ -99,4 +99,3 @@ #endif #include "windows\dapl_osd.c" - -- 2.41.0