#include "dapl_osd.h"
#include "dapl_debug.h"
-#ifdef IBAPI
-#include "dapl_ibapi_util.h"
-#elif VAPI
-#include "dapl_vapi_util.h"
-#elif __OPENIB__
-#include "dapl_openib_util.h"
-#include "dapl_openib_cm.h"
-#elif DUMMY
-#include "dapl_dummy_util.h"
-#elif OPENIB
-#include "dapl_ib_util.h"
-#endif
-
/*********************************************************************
* *
* Enumerations *
typedef struct dapl_private DAPL_PRIVATE;
-typedef void (*DAPL_CONNECTION_STATE_HANDLER) (
- IN DAPL_EP *,
- IN ib_cm_events_t,
- IN const void *,
- OUT DAT_EVENT *);
-
/*********************************************************************
* *
DAPL_ATOMIC tail;
};
+#ifdef IBAPI
+#include "dapl_ibapi_util.h"
+#elif VAPI
+#include "dapl_vapi_util.h"
+#elif __OPENIB__
+#include "dapl_openib_util.h"
+#include "dapl_openib_cm.h"
+#elif DUMMY
+#include "dapl_dummy_util.h"
+#elif OPENIB
+#include "dapl_ib_util.h"
+#endif
+
struct dapl_hca
{
DAPL_OS_LOCK lock;
* *
*********************************************************************/
+typedef void (*DAPL_CONNECTION_STATE_HANDLER) (
+ IN DAPL_EP *,
+ IN ib_cm_events_t,
+ IN const void *,
+ OUT DAT_EVENT *);
+
/*
* DAT Mandated functions
*/
p_cq_wait_obj_handle );
/* write to pipe for wake up */
- write(p_cq_wait_obj_handle->pipe[1], "w", sizeof "w");
+ if (write(p_cq_wait_obj_handle->pipe[1], "w", sizeof "w") == -1)\r
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " wait object wakeup write error = %s\n",
+ strerror(errno));
return DAT_SUCCESS;
}
dapl_llist_add_tail(&g_hca_list,
(DAPL_LLIST_ENTRY*)&hca_ptr->ib_trans.entry,
&hca_ptr->ib_trans.entry);
- write(g_ib_pipe[1], "w", sizeof "w");
+ if (write(g_ib_pipe[1], "w", sizeof "w") == -1)\r
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " open_hca: thread wakeup error = %s\n",\r
+ strerror(errno));\r
dapl_os_unlock(&g_hca_lock);
dapl_dbg_log(
* Wakeup work thread to remove from polling list
*/
hca_ptr->ib_trans.destroy = 1;
- write(g_ib_pipe[1], "w", sizeof "w");
+ if (write(g_ib_pipe[1], "w", sizeof "w") == -1)\r
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " close_hca: thread wakeup error = %s\n",\r
+ strerror(errno));
/* wait for thread to remove HCA references */
while (hca_ptr->ib_trans.destroy != 2) {
struct timespec sleep, remain;
sleep.tv_sec = 0;
sleep.tv_nsec = 10000000; /* 10 ms */
- write(g_ib_pipe[1], "w", sizeof "w");
+ if (write(g_ib_pipe[1], "w", sizeof "w") == -1)\r
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " close_hca: thread wakeup error = %s\n",\r
+ strerror(errno));
dapl_dbg_log(DAPL_DBG_TYPE_UTIL,
" ib_thread_destroy: wait on hca %p destroy\n");
nanosleep (&sleep, &remain);
goto bail;
g_ib_thread_state = IB_THREAD_CANCEL;
- write(g_ib_pipe[1], "w", sizeof "w");
+ if (write(g_ib_pipe[1], "w", sizeof "w") == -1)\r
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " destroy: thread wakeup error = %s\n",\r
+ strerror(errno));
while ((g_ib_thread_state != IB_THREAD_EXIT) && (retries--)) {
struct timespec sleep, remain;
sleep.tv_sec = 0;
sleep.tv_nsec = 2000000; /* 2 ms */
dapl_dbg_log(DAPL_DBG_TYPE_UTIL,
" ib_thread_destroy: waiting for ib_thread\n");
- write(g_ib_pipe[1], "w", sizeof "w");
+ if (write(g_ib_pipe[1], "w", sizeof "w") == -1)\r
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " destroy: thread wakeup error = %s\n",\r
+ strerror(errno));
dapl_os_unlock( &g_hca_lock );
nanosleep(&sleep, &remain);
dapl_os_lock( &g_hca_lock );
/* check and process user events, PIPE */
if (ufds[0].revents == POLLIN) {
- read(g_ib_pipe[0], rbuf, 2);
-
+ if (read(g_ib_pipe[0], rbuf, 2) == -1)\r
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " ib_thread: pipe rd err= %s\n",\r
+ strerror(errno));\r
+
/* cleanup any device on list marked for destroy */
for(idx=3;idx<fds;idx++) {
if(uhca[idx] && uhca[idx]->destroy == 1) {
} ib_thread_state_t;
-/*
- * dapl_llist_entry in dapl.h but dapl.h depends on provider
- * typedef's in this file first. move dapl_llist_entry out of dapl.h
- */
-struct ib_llist_entry
-{
- struct dapl_llist_entry *flink;
- struct dapl_llist_entry *blink;
- void *data;
- struct dapl_llist_entry *list_head;
-};
-
struct dapl_cm_id {
DAPL_OS_LOCK lock;
int destroy;
/* ib_hca_transport_t, specific to this implementation */
typedef struct _ib_hca_transport
{
- struct ib_llist_entry entry;
+ struct dapl_llist_entry entry;
int destroy;
struct dapl_hca *d_hca;
struct rdma_cm_id *cm_id;
dapl_os_unlock(&cm_ptr->lock);
/* wakeup work thread */
- write(g_scm_pipe[1], "w", sizeof "w");
+ if (write(g_scm_pipe[1], "w", sizeof "w") == -1)\r
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " cm_destroy: thread wakeup error = %s\n",\r
+ strerror(errno));
}
/* queue socket for processing CM work */
dapl_os_unlock(&cm_ptr->hca->ib_trans.lock);
/* wakeup CM work thread */
- write(g_scm_pipe[1], "w", sizeof "w");
+ if (write(g_scm_pipe[1], "w", sizeof "w") == -1)\r
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " cm_queue: thread wakeup error = %s\n",\r
+ strerror(errno));
}
static uint16_t dapli_get_lid(IN struct ibv_context *ctx, IN uint8_t port)
} else {
/* send disc date, close socket, schedule destroy */
if (cm_ptr->socket >= 0) {
- write(cm_ptr->socket, &disc_data, sizeof(disc_data));
+ if (write(cm_ptr->socket,\r
+ &disc_data, sizeof(disc_data)) == -1)\r
+ dapl_log(DAPL_DBG_TYPE_WARN,\r
+ " cm_disc: write error = %s\n",\r
+ strerror(errno));\r
close(cm_ptr->socket);
cm_ptr->socket = -1;
}
dapl_dbg_log(DAPL_DBG_TYPE_EP," connect_rtu: send RTU\n");
/* complete handshake after final QP state change */
- write(cm_ptr->socket, &rtu_data, sizeof(rtu_data));
+ if (write(cm_ptr->socket, &rtu_data, sizeof(rtu_data)) == -1)
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " CONN_RTU: write error = %s\n",\r
+ strerror(errno));
/* init cm_handle and post the event with private data */
ep_ptr->cm_handle = cm_ptr;
/* cr_thread will free */
cm_ptr->state = SCM_DESTROY;
sp_ptr->cm_srvc_handle = NULL;
- write(g_scm_pipe[1], "w", sizeof "w");
+ if (write(g_scm_pipe[1], "w", sizeof "w") == -1)\r
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " remove_listen: thread wakeup error = %s\n",\r
+ strerror(errno));
}
return DAT_SUCCESS;
}
/* cr_thread will destroy CR */
cm_ptr->state = SCM_REJECTED;
- write(g_scm_pipe[1], "w", sizeof "w");
+ if (write(g_scm_pipe[1], "w", sizeof "w") == -1)\r
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " reject_connection: thread wakeup error = %s\n",\r
+ strerror(errno));
return DAT_SUCCESS;
}
poll(ufds,idx+1,-1); /* infinite, all sockets and pipe */
/* if pipe used to wakeup, consume */
if (ufds[0].revents == POLLIN)
- read(g_scm_pipe[0], rbuf, 2);
+ if (read(g_scm_pipe[0], rbuf, 2) == -1)\r
+ dapl_log(DAPL_DBG_TYPE_CM,\r
+ " cr_thread: read pipe error = %s\n",\r
+ strerror(errno));\r
dapl_dbg_log(DAPL_DBG_TYPE_CM," cr_thread: wakeup\n");
dapl_os_lock(&hca_ptr->ib_trans.lock);
}
/* destroy cr_thread and lock */
hca_ptr->ib_trans.cr_state = IB_THREAD_CANCEL;
- write(g_scm_pipe[1], "w", sizeof "w");
+ if (write(g_scm_pipe[1], "w", sizeof "w") == -1)\r
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " close_hca: thread wakeup error = %s\n",\r
+ strerror(errno));
while (hca_ptr->ib_trans.cr_state != IB_THREAD_EXIT) {
struct timespec sleep, remain;
sleep.tv_sec = 0;
sleep.tv_nsec = 2000000; /* 2 ms */
+ if (write(g_scm_pipe[1], "w", sizeof "w") == -1)\r
+ dapl_log(DAPL_DBG_TYPE_UTIL,\r
+ " close_hca: thread wakeup error = %s\n",\r
+ strerror(errno));
dapl_dbg_log(DAPL_DBG_TYPE_UTIL,
" close_hca: waiting for cr_thread\n");
nanosleep (&sleep, &remain);
union ibv_gid gid;
} ib_qp_cm_t;
-/*
- * dapl_llist_entry in dapl.h but dapl.h depends on provider
- * typedef's in this file first. move dapl_llist_entry out of dapl.h
- */
-struct ib_llist_entry
-{
- struct dapl_llist_entry *flink;
- struct dapl_llist_entry *blink;
- void *data;
- struct dapl_llist_entry *list_head;
-};
-
typedef enum scm_state
{
SCM_INIT,
struct ib_cm_handle
{
- struct ib_llist_entry entry;
+ struct dapl_llist_entry entry;
DAPL_OS_LOCK lock;
SCM_STATE state;
int socket;