goto bail;\r
}\r
\r
- /*\r
- * If we are dealing with event streams besides a CQ event stream,\r
- * be conservative and set producer side locking. Otherwise, no.\r
- * Note: CNO is not considered CQ event stream.\r
- */\r
- evd_ptr->evd_producer_locking_needed =\r
- (!(evd_flags & (DAT_EVD_DTO_FLAG | DAT_EVD_RMR_BIND_FLAG)) ||\r
- evd_ptr->cno_ptr);\r
-\r
/* Before we setup any callbacks, transition state to OPEN. */\r
evd_ptr->evd_state = DAPL_EVD_STATE_OPEN;\r
\r
evd_ptr->evd_flags = evd_flags;\r
evd_ptr->evd_enabled = DAT_TRUE;\r
evd_ptr->evd_waitable = DAT_TRUE;\r
- evd_ptr->evd_producer_locking_needed = 1; /* Conservative value. */\r
evd_ptr->ib_cq_handle = IB_INVALID_HANDLE;\r
dapl_os_atomic_set(&evd_ptr->evd_ref_count, 0);\r
evd_ptr->catastrophic_overflow = DAT_FALSE;\r
* Event posting code follows.\r
*/\r
\r
-/*\r
- * These next two functions (dapli_evd_get_event and dapli_evd_post_event)\r
- * are a pair. They are always called together, from one of the functions\r
- * at the end of this file (dapl_evd_post_*_event).\r
- *\r
- * Note that if producer side locking is enabled, the first one takes the\r
- * EVD lock and the second releases it.\r
- */\r
-\r
-/* dapli_evd_get_event\r
- *\r
- * Get an event struct from the evd. The caller should fill in the event\r
- * and call dapl_evd_post_event.\r
- *\r
- * If there are no events available, an overflow event is generated to the\r
- * async EVD handler.\r
- *\r
- * If this EVD required producer locking, a successful return implies\r
- * that the lock is held.\r
- *\r
- * Input:\r
- * evd_ptr\r
- *\r
- * Output:\r
- * event\r
- *\r
- */\r
-\r
-static DAT_EVENT *dapli_evd_get_event(DAPL_EVD * evd_ptr)\r
-{\r
- DAT_EVENT *event;\r
-\r
- if (evd_ptr->evd_producer_locking_needed) {\r
- dapl_os_lock(&evd_ptr->header.lock);\r
- }\r
-\r
- event = (DAT_EVENT *) dapls_rbuf_remove(&evd_ptr->free_event_queue);\r
-\r
- /* Release the lock if it was taken and the call failed. */\r
- if (!event && evd_ptr->evd_producer_locking_needed) {\r
- dapl_os_unlock(&evd_ptr->header.lock);\r
- }\r
-\r
- return event;\r
-}\r
\r
/* dapli_evd_post_event\r
*\r
* Post the <event> to the evd. If possible, invoke the evd's CNO.\r
* Otherwise post the event on the pending queue.\r
*\r
- * If producer side locking is required, the EVD lock must be held upon\r
- * entry to this function.\r
- *\r
* Input:\r
* evd_ptr\r
* event\r
dapli_evd_post_event(IN DAPL_EVD * evd_ptr, IN const DAT_EVENT * event_ptr)\r
{\r
DAT_RETURN dat_status;\r
- DAPL_CNO *cno_to_trigger = NULL;\r
\r
dapl_dbg_log(DAPL_DBG_TYPE_EVD, "%s: %s evd %p state %d\n",\r
__FUNCTION__, dapl_event_str(event_ptr->event_number), \r
\r
if (evd_ptr->evd_state == DAPL_EVD_STATE_OPEN) {\r
/* No waiter. Arrange to trigger a CNO if it exists. */\r
-\r
- if (evd_ptr->evd_enabled) {\r
- cno_to_trigger = evd_ptr->cno_ptr;\r
- }\r
- if (evd_ptr->evd_producer_locking_needed) {\r
- dapl_os_unlock(&evd_ptr->header.lock);\r
- }\r
+ if (evd_ptr->evd_enabled && evd_ptr->cno_ptr)\r
+ dapl_internal_cno_trigger(evd_ptr->cno_ptr, evd_ptr);\r
} else {\r
if (evd_ptr->evd_state == DAPL_EVD_STATE_WAITED\r
&& (dapls_rbuf_count(&evd_ptr->pending_event_queue)\r
>= evd_ptr->threshold)) {\r
- dapl_os_unlock(&evd_ptr->header.lock);\r
\r
if (evd_ptr->evd_flags & (DAT_EVD_DTO_FLAG | DAT_EVD_RMR_BIND_FLAG)) {\r
dapls_evd_dto_wakeup(evd_ptr);\r
} else {\r
dapl_os_wait_object_wakeup(&evd_ptr->wait_object);\r
}\r
-\r
- } else {\r
- dapl_os_unlock(&evd_ptr->header.lock);\r
}\r
}\r
-\r
- if (cno_to_trigger != NULL) {\r
- dapl_internal_cno_trigger(cno_to_trigger, evd_ptr);\r
- }\r
}\r
\r
-/* dapli_evd_post_event_nosignal\r
- *\r
- * Post the <event> to the evd. Do not do any wakeup processing.\r
- * This function should only be called if it is known that there are\r
- * no waiters that it is appropriate to wakeup on this EVD. An example\r
- * of such a situation is during internal dat_evd_wait() processing.\r
- *\r
- * If producer side locking is required, the EVD lock must be held upon\r
- * entry to this function.\r
- *\r
- * Input:\r
- * evd_ptr\r
- * event\r
- *\r
- * Output:\r
- * none\r
- *\r
- */\r
-\r
-static void\r
-dapli_evd_post_event_nosignal(IN DAPL_EVD * evd_ptr,\r
- IN const DAT_EVENT * event_ptr)\r
+static DAT_EVENT *dapli_evd_get_and_init_event(IN DAPL_EVD * evd_ptr,\r
+ IN DAT_EVENT_NUMBER event_number)\r
{\r
- DAT_RETURN dat_status;\r
-\r
- dapl_dbg_log(DAPL_DBG_TYPE_EVD, "%s: Called with event %s\n",\r
- __FUNCTION__, dapl_event_str(event_ptr->event_number));\r
-\r
- dat_status = dapls_rbuf_add(&evd_ptr->pending_event_queue,\r
- (void *)event_ptr);\r
- dapl_os_assert(dat_status == DAT_SUCCESS);\r
-\r
- dapl_os_assert(evd_ptr->evd_state == DAPL_EVD_STATE_WAITED\r
- || evd_ptr->evd_state == DAPL_EVD_STATE_OPEN);\r
+ DAT_EVENT *event_ptr;\r
\r
- if (evd_ptr->evd_producer_locking_needed) {\r
- dapl_os_unlock(&evd_ptr->header.lock);\r
+ event_ptr = (DAT_EVENT *) dapls_rbuf_remove(&evd_ptr->free_event_queue);\r
+ if (event_ptr) {\r
+ event_ptr->evd_handle = (DAT_EVD_HANDLE) evd_ptr;\r
+ event_ptr->event_number = event_number;\r
}\r
-}\r
\r
-/* dapli_evd_format_overflow_event\r
- *\r
- * format an overflow event for posting\r
- *\r
- * Input:\r
- * evd_ptr\r
- * event_ptr\r
- *\r
- * Output:\r
- * none\r
- *\r
- */\r
-static void\r
-dapli_evd_format_overflow_event(IN DAPL_EVD * evd_ptr,\r
- OUT DAT_EVENT * event_ptr)\r
-{\r
- DAPL_IA *ia_ptr;\r
-\r
- ia_ptr = evd_ptr->header.owner_ia;\r
-\r
- event_ptr->evd_handle = (DAT_EVD_HANDLE) evd_ptr;\r
- event_ptr->event_number = DAT_ASYNC_ERROR_EVD_OVERFLOW;\r
- event_ptr->event_data.asynch_error_event_data.dat_handle =\r
- (DAT_HANDLE) ia_ptr;\r
+ return event_ptr;\r
}\r
\r
-/* dapli_evd_post_overflow_event\r
+/* dapls_evd_post_overflow_event\r
*\r
* post an overflow event\r
*\r
* none\r
*\r
*/\r
-static void\r
-dapli_evd_post_overflow_event(IN DAPL_EVD * async_evd_ptr,\r
- IN DAPL_EVD * overflow_evd_ptr)\r
+void\r
+dapls_evd_post_overflow_event(IN DAPL_EVD * evd_ptr)\r
{\r
- DAT_EVENT *overflow_event;\r
+ DAPL_EVD *async_evd_ptr = evd_ptr->header.owner_ia->async_error_evd;\r
+ DAT_EVENT *event_ptr;\r
\r
- /* The overflow_evd_ptr mght be the same as evd.\r
- * In that case we've got a catastrophic overflow.\r
- */\r
- dapl_log(DAPL_DBG_TYPE_WARN,\r
- " WARNING: overflow event on EVD %p/n", overflow_evd_ptr);\r
+ dapl_log(DAPL_DBG_TYPE_WARN, " WARNING: overflow event on EVD %p/n", evd_ptr);\r
\r
- if (async_evd_ptr == overflow_evd_ptr) {\r
- async_evd_ptr->catastrophic_overflow = DAT_TRUE;\r
- async_evd_ptr->evd_state = DAPL_EVD_STATE_DEAD;\r
- return;\r
- }\r
+ dapl_os_lock(&async_evd_ptr->header.lock);\r
\r
- overflow_event = dapli_evd_get_event(overflow_evd_ptr);\r
- if (!overflow_event) {\r
- /* this is not good */\r
- overflow_evd_ptr->catastrophic_overflow = DAT_TRUE;\r
- overflow_evd_ptr->evd_state = DAPL_EVD_STATE_DEAD;\r
- return;\r
- }\r
- dapli_evd_format_overflow_event(overflow_evd_ptr, overflow_event);\r
- dapli_evd_post_event(overflow_evd_ptr, overflow_event);\r
+ /* The overflow evd_ptr mght be the same as the async evd.\r
+ * In that case we've got a catastrophic overflow.\r
+ */\r
+ if (async_evd_ptr == evd_ptr)\r
+ goto err;\r
+\r
+ event_ptr = dapli_evd_get_and_init_event(async_evd_ptr,\r
+ DAT_ASYNC_ERROR_EVD_OVERFLOW);\r
+ if (!event_ptr)\r
+ goto err;\r
+ \r
+ event_ptr->event_data.asynch_error_event_data.dat_handle =\r
+ (DAT_HANDLE) evd_ptr->header.owner_ia;\r
\r
+ dapli_evd_post_event(async_evd_ptr, event_ptr);\r
+ dapl_os_unlock(&async_evd_ptr->header.lock);\r
return;\r
-}\r
\r
-static DAT_EVENT *dapli_evd_get_and_init_event(IN DAPL_EVD * evd_ptr,\r
- IN DAT_EVENT_NUMBER event_number)\r
-{\r
- DAT_EVENT *event_ptr;\r
-\r
- event_ptr = dapli_evd_get_event(evd_ptr);\r
- if (NULL == event_ptr) {\r
- dapli_evd_post_overflow_event(evd_ptr->header.owner_ia->\r
- async_error_evd, evd_ptr);\r
- } else {\r
- event_ptr->evd_handle = (DAT_EVD_HANDLE) evd_ptr;\r
- event_ptr->event_number = event_number;\r
- }\r
-\r
- return event_ptr;\r
+err:\r
+ async_evd_ptr->catastrophic_overflow = DAT_TRUE;\r
+ async_evd_ptr->evd_state = DAPL_EVD_STATE_DEAD;\r
+ dapl_os_unlock(&async_evd_ptr->header.lock);\r
}\r
\r
DAT_RETURN\r
DAT_CR_HANDLE cr_handle)\r
{\r
DAT_EVENT *event_ptr;\r
- event_ptr = dapli_evd_get_and_init_event(evd_ptr, event_number);\r
- /*\r
- * Note event lock may be held on successful return\r
- * to be released by dapli_evd_post_event(), if provider side locking\r
- * is needed.\r
- */\r
\r
- if (event_ptr == NULL) {\r
- return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,\r
- DAT_RESOURCE_MEMORY);\r
- }\r
+ dapl_os_lock(&evd_ptr->header.lock);\r
+ event_ptr = dapli_evd_get_and_init_event(evd_ptr, event_number);\r
+ if (event_ptr == NULL)\r
+ goto err;\r
\r
event_ptr->event_data.cr_arrival_event_data.sp_handle = sp_handle;\r
event_ptr->event_data.cr_arrival_event_data.local_ia_address_ptr\r
event_ptr->event_data.cr_arrival_event_data.cr_handle = cr_handle;\r
\r
dapli_evd_post_event(evd_ptr, event_ptr);\r
-\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
return DAT_SUCCESS;\r
+\r
+err:\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
+ dapls_evd_post_overflow_event(evd_ptr);\r
+ return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);\r
}\r
\r
DAT_RETURN\r
IN DAT_PVOID private_data)\r
{\r
DAT_EVENT *event_ptr;\r
- event_ptr = dapli_evd_get_and_init_event(evd_ptr, event_number);\r
- /*\r
- * Note event lock may be held on successful return\r
- * to be released by dapli_evd_post_event(), if provider side locking\r
- * is needed.\r
- */\r
\r
- if (event_ptr == NULL) {\r
- return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,\r
- DAT_RESOURCE_MEMORY);\r
- }\r
+ dapl_os_lock(&evd_ptr->header.lock);\r
+ event_ptr = dapli_evd_get_and_init_event(evd_ptr, event_number);\r
+ if (event_ptr == NULL)\r
+ goto err;\r
\r
event_ptr->event_data.connect_event_data.ep_handle = ep_handle;\r
event_ptr->event_data.connect_event_data.private_data_size\r
event_ptr->event_data.connect_event_data.private_data = private_data;\r
\r
dapli_evd_post_event(evd_ptr, event_ptr);\r
-\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
return DAT_SUCCESS;\r
+\r
+err:\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
+ dapls_evd_post_overflow_event(evd_ptr);\r
+ return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);\r
}\r
\r
DAT_RETURN\r
IN DAT_IA_HANDLE ia_handle)\r
{\r
DAT_EVENT *event_ptr;\r
- event_ptr = dapli_evd_get_and_init_event(evd_ptr, event_number);\r
- /*\r
- * Note event lock may be held on successful return\r
- * to be released by dapli_evd_post_event(), if provider side locking\r
- * is needed.\r
- */\r
+\r
dapl_log(DAPL_DBG_TYPE_WARN,\r
" WARNING: async event - %s evd=%p/n",\r
dapl_event_str(event_number), evd_ptr);\r
\r
- if (event_ptr == NULL) {\r
- return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,\r
- DAT_RESOURCE_MEMORY);\r
- }\r
+ dapl_os_lock(&evd_ptr->header.lock);\r
+ event_ptr = dapli_evd_get_and_init_event(evd_ptr, event_number);\r
+ if (event_ptr == NULL)\r
+ goto err;\r
\r
event_ptr->event_data.asynch_error_event_data.dat_handle =\r
(DAT_HANDLE) ia_handle;\r
\r
dapli_evd_post_event(evd_ptr, event_ptr);\r
-\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
return DAT_SUCCESS;\r
+\r
+err:\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
+ dapls_evd_post_overflow_event(evd_ptr);\r
+ return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);\r
}\r
\r
DAT_RETURN\r
IN DAT_PVOID pointer)\r
{\r
DAT_EVENT *event_ptr;\r
- event_ptr = dapli_evd_get_and_init_event(evd_ptr, event_number);\r
- /*\r
- * Note event lock may be held on successful return\r
- * to be released by dapli_evd_post_event(), if provider side locking\r
- * is needed.\r
- */\r
\r
- if (event_ptr == NULL) {\r
- return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,\r
- DAT_RESOURCE_MEMORY);\r
- }\r
+ dapl_os_lock(&evd_ptr->header.lock);\r
+ event_ptr = dapli_evd_get_and_init_event(evd_ptr, event_number);\r
+ if (event_ptr == NULL)\r
+ goto err;\r
\r
event_ptr->event_data.software_event_data.pointer = pointer;\r
\r
dapli_evd_post_event(evd_ptr, event_ptr);\r
-\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
return DAT_SUCCESS;\r
+\r
+err:\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
+ dapls_evd_post_overflow_event(evd_ptr);\r
+ return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);\r
}\r
\r
/*\r
{\r
DAT_EVENT *event_ptr;\r
\r
+ dapl_os_lock(&evd_ptr->header.lock);\r
event_ptr = dapli_evd_get_and_init_event(evd_ptr, event_number);\r
- /*\r
- * Note event lock may be held on successful return\r
- * to be released by dapli_evd_post_event(), if provider side locking\r
- * is needed.\r
- */\r
-\r
- if (event_ptr == NULL) {\r
- return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,\r
- DAT_RESOURCE_MEMORY);\r
- }\r
+ if (event_ptr == NULL)\r
+ goto err;\r
\r
event_ptr->event_data = *data;\r
\r
dapli_evd_post_event(evd_ptr, event_ptr);\r
-\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
return DAT_SUCCESS;\r
+\r
+err:\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
+ dapls_evd_post_overflow_event(evd_ptr);\r
+ return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);\r
}\r
\r
#ifdef DAT_EXTENSIONS\r
+DAT_RETURN\r
+dapls_evd_do_post_cr_event_ext(IN DAPL_EVD * evd_ptr,\r
+ IN DAT_EVENT_NUMBER event_number,\r
+ IN DAPL_SP *sp_ptr,\r
+ IN DAPL_CR *cr_ptr,\r
+ IN DAT_PVOID ext_data)\r
+{\r
+ DAT_EVENT *event_ptr;\r
+\r
+ dapl_os_lock(&evd_ptr->header.lock);\r
+ event_ptr = dapli_evd_get_and_init_event(evd_ptr, event_number);\r
+ if (event_ptr == NULL)\r
+ goto err;\r
+\r
+ event_ptr->event_data.cr_arrival_event_data.sp_handle.psp_handle =\r
+ (DAT_PSP_HANDLE) sp_ptr;\r
+ event_ptr->event_data.cr_arrival_event_data.local_ia_address_ptr =\r
+ (DAT_IA_ADDRESS_PTR) &sp_ptr->header.owner_ia->hca_ptr->hca_address;\r
+ event_ptr->event_data.cr_arrival_event_data.conn_qual = sp_ptr->conn_qual;\r
+ event_ptr->event_data.cr_arrival_event_data.cr_handle = (DAT_CR_HANDLE) cr_ptr;\r
+\r
+ dapl_os_memcpy(&event_ptr->event_extension_data[0], ext_data, 64);\r
+\r
+ dapli_evd_post_event(sp_ptr->evd_handle, event_ptr);\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
+ return DAT_SUCCESS;\r
+\r
+err:\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
+ dapls_evd_post_overflow_event(evd_ptr);\r
+ return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);\r
+}\r
+\r
DAT_RETURN\r
dapls_evd_post_cr_event_ext(IN DAPL_SP * sp_ptr,\r
IN DAT_EVENT_NUMBER event_number,\r
DAPL_CR *cr_ptr;\r
DAPL_EP *ep_ptr;\r
DAT_EVENT *event_ptr;\r
- DAT_SP_HANDLE sp_handle;\r
\r
dapl_os_lock(&sp_ptr->header.lock);\r
if (sp_ptr->listening == DAT_FALSE) {\r
/* link the CR onto the SP so we can pick it up later */\r
dapl_sp_link_cr(sp_ptr, cr_ptr);\r
\r
- /* assign sp_ptr to union to avoid typecast errors from some compilers */\r
- sp_handle.psp_handle = (DAT_PSP_HANDLE) sp_ptr;\r
-\r
- /* Post the event. */\r
-\r
- /*\r
- * Note event lock may be held on successful return\r
- * to be released by dapli_evd_post_event(), if provider side locking\r
- * is needed.\r
- */\r
- event_ptr = dapli_evd_get_and_init_event(sp_ptr->evd_handle,\r
- event_number);\r
- if (event_ptr == NULL)\r
- return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,\r
- DAT_RESOURCE_MEMORY);\r
-\r
- event_ptr->event_data.cr_arrival_event_data.sp_handle = sp_handle;\r
- event_ptr->event_data.cr_arrival_event_data.local_ia_address_ptr =\r
- (DAT_IA_ADDRESS_PTR) & sp_ptr->header.owner_ia->hca_ptr->\r
- hca_address;\r
- event_ptr->event_data.cr_arrival_event_data.conn_qual =\r
- sp_ptr->conn_qual;\r
- event_ptr->event_data.cr_arrival_event_data.cr_handle =\r
- (DAT_HANDLE) cr_ptr;\r
-\r
- dapl_os_memcpy(&event_ptr->event_extension_data[0], ext_data, 64);\r
-\r
- dapli_evd_post_event(sp_ptr->evd_handle, event_ptr);\r
-\r
- return DAT_SUCCESS;\r
+ return dapls_evd_do_post_cr_event_ext(sp_ptr->evd_handle, event_number,\r
+ sp_ptr, cr_ptr, ext_data);\r
}\r
\r
DAT_RETURN\r
IN DAT_PVOID ext_data)\r
{\r
DAT_EVENT *event_ptr;\r
+\r
+ dapl_os_lock(&evd_ptr->header.lock);\r
event_ptr = dapli_evd_get_and_init_event(evd_ptr, event_number);\r
- /*\r
- * Note event lock may be held on successful return\r
- * to be released by dapli_evd_post_event(), if provider side locking\r
- * is needed.\r
- */\r
if (event_ptr == NULL)\r
- return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,\r
- DAT_RESOURCE_MEMORY);\r
+ goto err;\r
\r
event_ptr->event_data.connect_event_data.ep_handle = ep_handle;\r
event_ptr->event_data.connect_event_data.private_data_size\r
dapl_os_memcpy(&event_ptr->event_extension_data[0], ext_data, 64);\r
\r
dapli_evd_post_event(evd_ptr, event_ptr);\r
-\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
return DAT_SUCCESS;\r
+\r
+err:\r
+ dapl_os_unlock(&evd_ptr->header.lock);\r
+ dapls_evd_post_overflow_event(evd_ptr);\r
+ return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);\r
}\r
#endif\r
\r
* Copy all entries on a CQ associated with the EVD onto that EVD\r
* Up to caller to handle races, if any. Note that no EVD waiters will\r
* be awoken by this copy.\r
- *\r
- * Input:\r
- * evd_ptr\r
- *\r
- * Output:\r
- * None\r
- *\r
- * Returns:\r
- * none\r
- *\r
*/\r
-void dapls_evd_copy_cq(DAPL_EVD * evd_ptr)\r
+DAT_RETURN dapls_evd_copy_cq(DAPL_EVD * evd_ptr)\r
{\r
ib_work_completion_t cur_cqe;\r
DAT_RETURN dat_status;\r
\r
if (evd_ptr->ib_cq_handle == IB_INVALID_HANDLE) {\r
/* Nothing to do if no CQ. */\r
- return;\r
+ return DAT_QUEUE_EMPTY;\r
}\r
\r
while (1) {\r
* Can use DAT_DTO_COMPLETION_EVENT because dapli_evd_cqe_to_event\r
* will overwrite.\r
*/\r
-\r
- event =\r
- dapli_evd_get_and_init_event(evd_ptr,\r
- DAT_DTO_COMPLETION_EVENT);\r
- if (event == NULL) {\r
- /* We've already attempted the overflow post; return. */\r
- return;\r
- }\r
+ event = dapli_evd_get_and_init_event(evd_ptr, DAT_DTO_COMPLETION_EVENT);\r
+ if (event == NULL)\r
+ return DAT_QUEUE_FULL;\r
\r
dapli_evd_cqe_to_event(evd_ptr, &cur_cqe, event);\r
\r
dat_status);\r
dapl_os_assert(!"Bad return from dapls_ib_completion_poll");\r
}\r
+ return dat_status;\r
}\r
\r
/*\r
projects / ~shefty / rdma-win.git / commitdiff