reported private_data_len for the size, and not IB maximums.
This fixes a bug running over the librdmacm on windows, where
DAPL accessed invalid memory.
Signed-off-by: Sean Hefty <sean.hefty@intel.com>
Signed-off-by: Arlin Davis <arlin.r.davis@intel.com>
IN DAT_HANDLE dat_handle,
OUT DAT_SOCK_ADDR6 *remote_ia_address);
-int dapls_ib_private_data_size (
- IN DAPL_PRIVATE *prd_ptr,
- IN DAPL_PDATA_OP conn_op,
- IN DAPL_HCA *hca_ptr);
+int dapls_ib_private_data_size(
+ IN DAPL_HCA *hca_ptr);
void
dapls_query_provider_specific_attr(
DAT_RETURN dapli_connection_request(IN dp_ib_cm_handle_t ib_cm_handle,
IN DAPL_SP * sp_ptr,
IN DAPL_PRIVATE * prd_ptr,
+ IN int private_data_size,
IN DAPL_EVD * evd_ptr);
DAPL_EP *dapli_get_sp_ep(IN dp_ib_cm_handle_t ib_cm_handle,
* None
*
*/
-void dapls_cr_callback(IN dp_ib_cm_handle_t ib_cm_handle, IN const ib_cm_events_t ib_cm_event, IN const void *private_data_ptr, /* event data */
- IN const void *context)
+void dapls_cr_callback(IN dp_ib_cm_handle_t ib_cm_handle, IN const ib_cm_events_t ib_cm_event,
+ IN const void *private_data_ptr, IN const int private_data_size,
+ IN const void *context)
{
DAPL_EP *ep_ptr;
DAPL_EVD *evd_ptr;
* event if appropriate.
*/
dat_status = dapli_connection_request(ib_cm_handle,
- sp_ptr,
- prd_ptr, evd_ptr);
+ sp_ptr, prd_ptr, private_data_size, evd_ptr);
/* Set evd_ptr = NULL so we don't generate an event below */
evd_ptr = NULL;
DAT_RETURN
dapli_connection_request(IN dp_ib_cm_handle_t ib_cm_handle,
IN DAPL_SP * sp_ptr,
- IN DAPL_PRIVATE * prd_ptr, IN DAPL_EVD * evd_ptr)
+ IN DAPL_PRIVATE * prd_ptr, IN int private_data_size,
+ IN DAPL_EVD * evd_ptr)
{
DAT_RETURN dat_status;
/* Private data size will be determined by the provider layer */
cr_ptr->param.private_data = cr_ptr->private_data;
- if (prd_ptr == NULL) {
- cr_ptr->param.private_data_size = 0;
- } else {
- cr_ptr->param.private_data_size =
- dapls_ib_private_data_size(prd_ptr, DAPL_PDATA_CONN_REQ,
- sp_ptr->header.owner_ia->
- hca_ptr);
- }
+ cr_ptr->param.private_data_size = private_data_size;
if (cr_ptr->param.private_data_size > 0) {
dapl_os_memcpy(cr_ptr->private_data,
prd_ptr->private_data,
dapls_cr_callback (
IN dp_ib_cm_handle_t ib_cm_handle,
IN const ib_cm_events_t ib_cm_event,
- IN const void *instant_data_p,
+ IN const void *private_data_ptr,
+ IN const int private_data_size,
IN const void *context);
#endif /* _DAPL_CR_UTIL_H_ */
DAPL_EP alloc_ep;
DAT_RETURN dat_status;
DAT_COUNT req_hdr_size;
- DAT_UINT32 max_req_pdata_size;
void *private_data_ptr;
dapl_dbg_log(DAPL_DBG_TYPE_API | DAPL_DBG_TYPE_CM,
*/
req_hdr_size = (sizeof(DAPL_PRIVATE) - DAPL_MAX_PRIVATE_DATA_SIZE);
- max_req_pdata_size =
- dapls_ib_private_data_size(NULL, DAPL_PDATA_CONN_REQ,
- ep_ptr->header.owner_ia->hca_ptr);
-
- if (private_data_size + req_hdr_size > (DAT_COUNT) max_req_pdata_size) {
- dapl_os_unlock(&ep_ptr->header.lock);
- dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG5);
- goto bail;
- }
-
/* transition the state before requesting a connection to avoid
* race conditions
*/
ep_ptr, cr_ptr->ib_cm_handle);
dapls_cr_callback(cr_ptr->ib_cm_handle,
- ib_cm_event, NULL, cr_ptr->sp_ptr);
+ ib_cm_event, NULL, 0, cr_ptr->sp_ptr);
} else {
dapl_evd_connection_callback(ep_ptr->cm_handle,
ib_cm_event,
- NULL, (void *)ep_ptr);
+ NULL, 0, (void *)ep_ptr);
}
} else {
dapl_os_unlock(&ep_ptr->header.lock);
dapl_evd_connection_callback(IN dp_ib_cm_handle_t ib_cm_handle,
IN const ib_cm_events_t ib_cm_event,
IN const void *private_data_ptr,
+ IN const int private_data_size,
IN const void *context)
{
DAPL_EP *ep_ptr;
DAPL_PRIVATE *prd_ptr;
DAT_EVENT_NUMBER dat_event_num;
DAT_RETURN dat_status;
- int private_data_size;
dapl_dbg_log(DAPL_DBG_TYPE_CM | DAPL_DBG_TYPE_CALLBACK,
"--> dapl_evd_connection_callback: ctxt: %p event: %x cm_handle %p\n",
DAPL_CNTR(evd_ptr, DCNT_EVD_CONN_CALLBACK);
prd_ptr = (DAPL_PRIVATE *) private_data_ptr;
- private_data_size = 0;
/*
* All operations effect the EP, so lock it once and unlock
* when necessary
}
ep_ptr->param.ep_state = DAT_EP_STATE_CONNECTED;
ep_ptr->cm_handle = ib_cm_handle;
- if (prd_ptr == NULL) {
- private_data_size = 0;
- } else {
- private_data_size =
- dapls_ib_private_data_size(prd_ptr,
- DAPL_PDATA_CONN_REP,
- ep_ptr->header.
- owner_ia->
- hca_ptr);
- }
if (private_data_size > 0) {
/* copy in the private data */
case DAT_CONNECTION_EVENT_PEER_REJECTED:
{
/* peer reject may include private data */
- if (prd_ptr != NULL)
- private_data_size =
- dapls_ib_private_data_size(prd_ptr,
- DAPL_PDATA_CONN_REJ,
- ep_ptr->header.
- owner_ia->
- hca_ptr);
if (private_data_size > 0)
dapl_os_memcpy(ep_ptr->private.private_data,
extern void dapl_evd_connection_callback (
IN dp_ib_cm_handle_t ib_cm_handle,
IN const ib_cm_events_t ib_cm_events,
- IN const void *instant_data_p,
+ IN const void *private_data_ptr,
+ IN const int private_data_size,
IN const void * context );
/* dto verb callback */
* to 0 unless IBHOSTS_NAMING is enabled.
*/
provider_attr->max_private_data_size =
- dapls_ib_private_data_size(NULL, DAPL_PDATA_CONN_REQ,
- ia_ptr->hca_ptr) -
+ dapls_ib_private_data_size(ia_ptr->hca_ptr) -
(sizeof(DAPL_PRIVATE) - DAPL_MAX_PRIVATE_DATA_SIZE);
provider_attr->supports_multipath = DAT_FALSE;
provider_attr->ep_creator = DAT_PSP_CREATES_EP_NEVER;
dapls_cr_callback ( ep_ptr->cm_handle,
IB_CME_DISCONNECTED,
(void * __ptr64) p_cm_dreq_rec->p_dreq_pdata,
+ IB_DREQ_PDATA_SIZE,
(void *) (((DAPL_CR *) ep_ptr->cr_ptr)->sp_ptr) );
}
else
IB_CME_DISCONNECTED,
(void * __ptr64)
p_cm_dreq_rec->p_dreq_pdata,
+ IB_DREQ_PDATA_SIZE,
p_cm_dreq_rec->qp_context );
}
}
dapls_cr_callback ( ep_ptr->cm_handle,
IB_CME_DISCONNECTED,
(void * __ptr64) p_cm_drep_rec->p_drep_pdata,
+ IB_DREP_PDATA_SIZE,
(void *) (((DAPL_CR *) ep_ptr->cr_ptr)->sp_ptr) );
}
else
ep_ptr->cm_handle,
IB_CME_DISCONNECTED,
(void * __ptr64) p_cm_drep_rec->p_drep_pdata,
+ IB_DREP_PDATA_SIZE,
p_cm_drep_rec->qp_context );
}
}
(dp_ib_cm_handle_t)&p_cm_rep_rec->h_cm_rep,
cm_cb_op,
(void *) prd_ptr,
+ IB_REP_PDATA_SIZE,
(void * __ptr64) p_cm_rep_rec->qp_context);
}
dapls_cr_callback ( ep_ptr->cm_handle,
cm_event,
(void * __ptr64) p_cm_rej_rec->p_rej_pdata,
+ IB_REJ_PDATA_SIZE,
(void *) ((DAPL_CR *) ep_ptr->cr_ptr)->sp_ptr);
}
else
ep_ptr->cm_handle,
cm_event,
(void * __ptr64) p_cm_rej_rec->p_rej_pdata,
+ IB_REJ_PDATA_SIZE,
(void * __ptr64) p_cm_rej_rec->qp_context );
}
dapls_cr_callback ( cm_handle,
IB_CME_CONNECTION_REQUEST_PENDING,
(void * __ptr64) p_cm_req_rec->p_req_pdata,
+ IB_REQ_PDATA_SIZE,
(void * __ptr64) sp_ptr );
}
dapls_cr_callback ( ep_ptr->cm_handle,
IB_CME_CONNECTED,
(void * __ptr64) p_cm_rtu_rec->p_rtu_pdata,
+ IB_RTU_PDATA_SIZE,
(void *) sp_ptr);
}
ep_ptr->cm_handle,
IB_CME_CONNECTED,
(void * __ptr64) p_cm_rtu_rec->p_rtu_pdata,
+ IB_RTU_PDATA_SIZE,
(void *) ep_ptr);
}
}
cm_rej.p_ari = (ib_ari_t *)&rej_table[reject_reason];
cm_rej.ari_length = (uint8_t)strlen (rej_table[reject_reason]);
- if (private_data_size >
- dapls_ib_private_data_size(NULL,DAPL_PDATA_CONN_REJ,NULL))
- {
- dapl_dbg_log ( DAPL_DBG_TYPE_ERR,
- "--> DsRjC: private_data size(%d) > Max(%d)\n",
- private_data_size, IB_MAX_REJ_PDATA_SIZE );
- return DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3);
- }
-
cm_rej.p_rej_pdata = private_data;
cm_rej.rej_length = private_data_size;
}
#endif
-/*
- * dapls_ib_private_data_size
- *
- * Return the size of private data given a connection op type
- *
- * Input:
- * prd_ptr private data pointer
- * conn_op connection operation type
- * hca_ptr hca pointer, needed for transport type
- *
- * If prd_ptr is NULL, this is a query for the max size supported by
- * the provider, otherwise it is the actual size of the private data
- * contained in prd_ptr.
- *
- * Infiniband has fixed size private data, so prd_ptr is ignored.
- *
- * Output:
- * None
- *
- * Returns:
- * length of private data
- *
- */
int
dapls_ib_private_data_size (
- IN DAPL_PRIVATE *prd_ptr,
- IN DAPL_PDATA_OP conn_op,
IN DAPL_HCA *hca_ptr)
{
- int size;
-
- UNUSED_PARAM( prd_ptr );
- UNUSED_PARAM( hca_ptr );
-
- switch (conn_op)
- {
- case DAPL_PDATA_CONN_REQ:
- {
- size = IB_MAX_REQ_PDATA_SIZE;
- break;
- }
- case DAPL_PDATA_CONN_REP:
- {
- size = IB_MAX_REP_PDATA_SIZE;
- break;
- }
- case DAPL_PDATA_CONN_REJ:
- {
- size = IB_MAX_REJ_PDATA_SIZE;
- break;
- }
- case DAPL_PDATA_CONN_DREQ:
- {
- size = IB_MAX_DREQ_PDATA_SIZE;
- break;
- }
- case DAPL_PDATA_CONN_DREP:
- {
- size = IB_MAX_DREP_PDATA_SIZE;
- break;
- }
- default:
- {
- size = 0;
- }
- } /* end case */
-
-#if defined(DAPL_DBG) && 0
- dapl_dbg_log (DAPL_DBG_TYPE_CM, "%s: returns %d\n", __FUNCTION__, size );
-#endif
-
- return size;
+ return IB_MAX_REQ_PDATA_SIZE;
}
ret, strerror(errno));
dapl_evd_connection_callback(conn,
IB_CME_LOCAL_FAILURE,
- NULL, conn->ep);
+ NULL, 0, conn->ep);
}
}
bail:
dapl_evd_connection_callback(conn,
- IB_CME_LOCAL_FAILURE, NULL, conn->ep);
+ IB_CME_LOCAL_FAILURE, NULL, 0, conn->ep);
}
dp_ib_cm_handle_t dapls_ib_cm_create(DAPL_EP *ep)
dapl_os_unlock(lock);
if (conn)
- dapl_evd_connection_callback(conn, ib_cm_event, pdata, conn->ep);
+ dapl_evd_connection_callback(conn, ib_cm_event, pdata,
+ event->param.conn.private_data_len, conn->ep);
}
static void dapli_cm_passive_cb(struct dapl_cm_id *conn,
dapl_os_unlock(&conn->lock);
if (conn_recv)
- dapls_cr_callback(conn_recv, ib_cm_event, pdata, conn_recv->sp);
+ dapls_cr_callback(conn_recv, ib_cm_event, pdata,
+ event->param.conn.private_data_len, conn_recv->sp);
}
/************************ DAPL provider entry points **********************/
return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR);
}
- if (private_data_size >
- dapls_ib_private_data_size(NULL, DAPL_PDATA_CONN_REJ,
- cm_handle->hca))
- return DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3);
-
/* setup pdata_hdr and users data, in CR pdata buffer */
dapl_os_memcpy(cm_handle->p_data, &pdata_hdr, offset);
if (private_data_size)
/*
* dapls_ib_private_data_size
*
- * Return the size of private data given a connection op type
+ * Return the size of max private data
*
* Input:
- * prd_ptr private data pointer
- * conn_op connection operation type
* hca_ptr hca pointer, needed for transport type
*
- * If prd_ptr is NULL, this is a query for the max size supported by
- * the provider, otherwise it is the actual size of the private data
- * contained in prd_ptr.
- *
- *
* Output:
* None
*
* Returns:
- * length of private data
+ * maximum private data rdma_cm will supply from transport.
*
*/
-int dapls_ib_private_data_size(IN DAPL_PRIVATE * prd_ptr,
- IN DAPL_PDATA_OP conn_op, IN DAPL_HCA * hca_ptr)
+int dapls_ib_private_data_size(IN DAPL_HCA * hca_ptr)
{
- int size;
-
- if (hca_ptr->ib_hca_handle->device->transport_type
- == IBV_TRANSPORT_IWARP)
- return (IWARP_MAX_PDATA_SIZE - sizeof(struct dapl_pdata_hdr));
-
- switch (conn_op) {
-
- case DAPL_PDATA_CONN_REQ:
- size = IB_MAX_REQ_PDATA_SIZE;
- break;
- case DAPL_PDATA_CONN_REP:
- size = IB_MAX_REP_PDATA_SIZE;
- break;
- case DAPL_PDATA_CONN_REJ:
- size = IB_MAX_REJ_PDATA_SIZE - sizeof(struct dapl_pdata_hdr);
- break;
- case DAPL_PDATA_CONN_DREQ:
- size = IB_MAX_DREQ_PDATA_SIZE;
- break;
- case DAPL_PDATA_CONN_DREP:
- size = IB_MAX_DREP_PDATA_SIZE;
- break;
- default:
- size = 0;
-
- } /* end case */
-
- return size;
+ return RDMA_MAX_PRIVATE_DATA;
}
/*
dapl_evd_connection_callback(conn,
IB_CME_DESTINATION_UNREACHABLE,
- NULL, conn->ep);
+ NULL, 0, conn->ep);
break;
case RDMA_CM_EVENT_ROUTE_ERROR:
dapl_evd_connection_callback(conn,
IB_CME_DESTINATION_UNREACHABLE,
- NULL, conn->ep);
+ NULL, 0, conn->ep);
}
break;
case RDMA_CM_EVENT_DEVICE_REMOVAL:
dapl_evd_connection_callback(conn,
IB_CME_LOCAL_FAILURE,
- NULL, conn->ep);
+ NULL, 0, conn->ep);
break;
case RDMA_CM_EVENT_CONNECT_REQUEST:
case RDMA_CM_EVENT_CONNECT_ERROR:
#include <infiniband/verbs.h>
#include <rdma/rdma_cma.h>
+#include <rdma/rdma_cma_abi.h>
#include "openib_osd.h"
#include "dapl_ib_common.h"
#define IB_ROUTE_RETRY_COUNT 15 /* 60 sec total */
#define IB_MAX_AT_RETRY 3
-/* CMA private data areas */
+/* CMA private data areas, use CMA max with known transport definitions */
#define CMA_PDATA_HDR 36
-#define IB_MAX_REQ_PDATA_SIZE (92-CMA_PDATA_HDR)
-#define IB_MAX_REP_PDATA_SIZE (196-CMA_PDATA_HDR)
-#define IB_MAX_REJ_PDATA_SIZE (148-CMA_PDATA_HDR)
-#define IB_MAX_DREQ_PDATA_SIZE (220-CMA_PDATA_HDR)
-#define IB_MAX_DREP_PDATA_SIZE (224-CMA_PDATA_HDR)
-#define IWARP_MAX_PDATA_SIZE (512-CMA_PDATA_HDR)
+#define IB_MAX_REQ_PDATA_SIZE DAPL_MIN((92-CMA_PDATA_HDR),RDMA_MAX_PRIVATE_DATA)
+#define IB_MAX_REP_PDATA_SIZE DAPL_MIN((196-CMA_PDATA_HDR),RDMA_MAX_PRIVATE_DATA)
+#define IB_MAX_REJ_PDATA_SIZE DAPL_MIN((148-CMA_PDATA_HDR),RDMA_MAX_PRIVATE_DATA)
+#define IB_MAX_DREQ_PDATA_SIZE DAPL_MIN((220-CMA_PDATA_HDR),RDMA_MAX_PRIVATE_DATA)
+#define IB_MAX_DREP_PDATA_SIZE DAPL_MIN((224-CMA_PDATA_HDR),RDMA_MAX_PRIVATE_DATA)
+#define IWARP_MAX_PDATA_SIZE DAPL_MIN((512-CMA_PDATA_HDR),RDMA_MAX_PRIVATE_DATA)
struct dapl_cm_id {
DAPL_OS_LOCK lock;
if (ep_ptr->cr_ptr) {
dapls_cr_callback(cm_ptr,
IB_CME_DISCONNECTED,
- NULL,
+ NULL, 0,
((DAPL_CR *) ep_ptr->cr_ptr)->sp_ptr);
} else {
dapl_evd_connection_callback(ep_ptr->cm_handle,
IB_CME_DISCONNECTED,
- NULL, ep_ptr);
+ NULL, 0, ep_ptr);
}
}
bail:
/* close socket, free cm structure and post error event */
dapls_ib_cm_free(cm_ptr, cm_ptr->ep);
- dapl_evd_connection_callback(NULL, IB_CME_LOCAL_FAILURE, NULL, ep_ptr);
+ dapl_evd_connection_callback(NULL, IB_CME_LOCAL_FAILURE, NULL, 0, ep_ptr);
}
/*
#endif
{
ep_ptr->cm_handle = cm_ptr; /* only RC, multi CR's on UD */
- dapl_evd_connection_callback(cm_ptr, event, cm_ptr->msg.p_data, ep_ptr);
+ dapl_evd_connection_callback(cm_ptr, event, cm_ptr->msg.p_data,
+ DCM_MAX_PDATA_SIZE, ep_ptr);
}
return;
dapls_modify_qp_state(ep_ptr->qp_handle, IBV_QPS_ERR, 0, 0, 0);
closesocket(cm_ptr->socket);
cm_ptr->socket = DAPL_INVALID_SOCKET;
- dapl_evd_connection_callback(NULL, event, cm_ptr->msg.p_data, ep_ptr);
+ dapl_evd_connection_callback(NULL, event, cm_ptr->msg.p_data,
+ DCM_MAX_PDATA_SIZE, ep_ptr);
}
/*
/* trigger CR event and return SUCCESS */
dapls_cr_callback(acm_ptr,
IB_CME_CONNECTION_REQUEST_PENDING,
- p_data, acm_ptr->sp);
+ p_data, exp, acm_ptr->sp);
return;
bail:
/* close socket, free cm structure, active will see close as rej */
#endif
{
cm_ptr->ep->cm_handle = cm_ptr; /* only RC, multi CR's on UD */
- dapls_cr_callback(cm_ptr, event, NULL, cm_ptr->sp);
+ dapls_cr_callback(cm_ptr, event, NULL, 0, cm_ptr->sp);
}
return;
#endif
dapls_modify_qp_state(cm_ptr->ep->qp_handle, IBV_QPS_ERR, 0, 0, 0);
dapls_ib_cm_free(cm_ptr, cm_ptr->ep);
- dapls_cr_callback(cm_ptr, event, NULL, cm_ptr->sp);
+ dapls_cr_callback(cm_ptr, event, NULL, 0, cm_ptr->sp);
}
/*
return DAT_SUCCESS;
}
-/*
- * dapls_ib_private_data_size
- *
- * Return the size of private data given a connection op type
- *
- * Input:
- * prd_ptr private data pointer
- * conn_op connection operation type
- *
- * If prd_ptr is NULL, this is a query for the max size supported by
- * the provider, otherwise it is the actual size of the private data
- * contained in prd_ptr.
- *
- *
- * Output:
- * None
- *
- * Returns:
- * length of private data
- *
- */
-int dapls_ib_private_data_size(IN DAPL_PRIVATE * prd_ptr,
- IN DAPL_PDATA_OP conn_op, IN DAPL_HCA * hca_ptr)
+int dapls_ib_private_data_size(
+ IN DAPL_HCA *hca_ptr)
{
- int size;
-
- switch (conn_op) {
- case DAPL_PDATA_CONN_REQ:
- case DAPL_PDATA_CONN_REP:
- case DAPL_PDATA_CONN_REJ:
- case DAPL_PDATA_CONN_DREQ:
- case DAPL_PDATA_CONN_DREP:
- size = DCM_MAX_PDATA_SIZE;
- break;
- default:
- size = 0;
- }
- return size;
+ return DCM_MAX_PDATA_SIZE;
}
/*
dapl_os_unlock(&cm->lock);
if (cm->sp)
- dapls_cr_callback(cm, IB_CME_DISCONNECTED, NULL, cm->sp);
+ dapls_cr_callback(cm, IB_CME_DISCONNECTED, NULL, 0, cm->sp);
else
- dapl_evd_connection_callback(cm, IB_CME_DISCONNECTED, NULL, cm->ep);
+ dapl_evd_connection_callback(cm, IB_CME_DISCONNECTED, NULL, 0, cm->ep);
}
/*
#endif
dapl_evd_connection_callback(cm,
IB_CME_DESTINATION_UNREACHABLE,
- NULL, ep);
+ NULL, 0, ep);
return DAT_ERROR(DAT_INVALID_ADDRESS,
DAT_INVALID_ADDRESS_UNREACHABLE);
cm->ep->cm_handle = cm; /* only RC, multi CR's on UD */
dapl_evd_connection_callback(cm,
IB_CME_CONNECTED,
- cm->msg.p_data, cm->ep);
+ cm->msg.p_data, ntohs(cm->msg.p_size), cm->ep);
}
return;
bail:
if (cm->msg.saddr.ib.qp_type != IBV_QPT_UD)
dapls_ib_reinit_ep(cm->ep); /* reset QP state */
- dapl_evd_connection_callback(NULL, event, cm->msg.p_data, cm->ep);
+ dapl_evd_connection_callback(NULL, event, cm->msg.p_data, ntohs(cm->msg.p_size), cm->ep);
dapls_ib_cm_free(cm, NULL);
}
/* trigger CR event and return SUCCESS */
dapls_cr_callback(acm,
IB_CME_CONNECTION_REQUEST_PENDING,
- acm->msg.p_data, acm->sp);
+ acm->msg.p_data, ntohs(msg->p_size), acm->sp);
return;
bail:
} else {
#endif
cm->ep->cm_handle = cm; /* only RC, multi CR's on UD */
- dapls_cr_callback(cm, IB_CME_CONNECTED, NULL, cm->sp);
+ dapls_cr_callback(cm, IB_CME_CONNECTED, NULL, 0, cm->sp);
}
return;
bail:
if (cm->msg.saddr.ib.qp_type != IBV_QPT_UD)
dapls_ib_reinit_ep(cm->ep); /* reset QP state */
dapls_ib_cm_free(cm, cm->ep);
- dapls_cr_callback(cm, IB_CME_LOCAL_FAILURE, NULL, cm->sp);
+ dapls_cr_callback(cm, IB_CME_LOCAL_FAILURE, NULL, 0, cm->sp);
}
/*
} else
#endif
dapls_cr_callback(cm, IB_CME_LOCAL_FAILURE,
- NULL, cm->sp);
+ NULL, 0, cm->sp);
return -1;
}
dapl_os_get_time(&cm->timer); /* RTU expected */
return DAT_SUCCESS;
}
-/*
- * dapls_ib_private_data_size
- *
- * Return the size of private data given a connection op type
- *
- * Input:
- * prd_ptr private data pointer
- * conn_op connection operation type
- *
- * If prd_ptr is NULL, this is a query for the max size supported by
- * the provider, otherwise it is the actual size of the private data
- * contained in prd_ptr.
- *
- *
- * Output:
- * None
- *
- * Returns:
- * length of private data
- *
- */
-int dapls_ib_private_data_size(IN DAPL_PRIVATE * prd_ptr,
- IN DAPL_PDATA_OP conn_op, IN DAPL_HCA * hca_ptr)
+int dapls_ib_private_data_size(
+ IN DAPL_HCA *hca_ptr)
{
- int size;
-
- switch (conn_op) {
- case DAPL_PDATA_CONN_REQ:
- case DAPL_PDATA_CONN_REP:
- case DAPL_PDATA_CONN_REJ:
- case DAPL_PDATA_CONN_DREQ:
- case DAPL_PDATA_CONN_DREP:
- size = DCM_MAX_PDATA_SIZE;
- break;
- default:
- size = 0;
- }
- return size;
+ return DCM_MAX_PDATA_SIZE;
}
/*
projects / ~ardavis / dapl.git / commitdiff