/* RC - Server only, UD - Server and Client, one per EP */
void process_cr(int idx)
{
DAT_EVENT event;
DAT_COUNT nmore;
DAT_RETURN status;
int pdata;
DAT_CR_HANDLE cr = DAT_HANDLE_NULL;
DAT_CONN_QUAL exp_qual = server ? SERVER_ID : CLIENT_ID;
DAT_CR_PARAM cr_param;
DAT_CR_ARRIVAL_EVENT_DATA *cr_event =
&event.event_data.cr_arrival_event_data;
LOGPRINTF("%s waiting for connect[%d] request\n",
server ? "Server" : "Client", idx);
status = dat_evd_wait(cr_evd, SERVER_TIMEOUT, 1, &event, &nmore);
_OK(status, "CR dat_evd_wait");
if (event.event_number != DAT_CONNECTION_REQUEST_EVENT &&
(ud_test && event.event_number !=
DAT_IB_UD_CONNECTION_REQUEST_EVENT)) {
printf("unexpected event,!conn req: 0x%x\n",
event.event_number);
exit(1);
}
if ((cr_event->conn_qual != exp_qual) ||
(cr_event->sp_handle.psp_handle != psp)) {
printf("wrong cr event data\n");
exit(1);
}
cr = cr_event->cr_handle;
status = dat_cr_query(cr, DAT_CSP_FIELD_ALL, &cr_param);
_OK(status, "dat_cr_query");
/* use private data to select EP */
pdata = ntoh32(*((int *)cr_param.private_data));
LOGPRINTF("%s recvd pdata=0x%x, send pdata=0x%x\n",
server ? "Server" : "Client", pdata,
*(int *)cr_param.private_data);
status = dat_cr_accept(cr, ep[pdata], 4, cr_param.private_data);
_OK(status, "dat_cr_accept");
printf("%s accepted CR on EP[%d]=%p\n",
server ? "Server" : "Client", pdata, ep[pdata]);
}
static int mca_btl_udapl_accept_connect(mca_btl_udapl_module_t* btl,
DAT_CR_HANDLE cr_handle)
{
DAT_EP_HANDLE ep;
int rc;
mca_btl_base_endpoint_t* proc_ep;
mca_btl_udapl_addr_t priv_data_in_addr;
int32_t priv_data_in_conn_type; /* incoming endpoint type */
if (mca_btl_udapl_component.udapl_conn_priv_data) {
DAT_CR_PARAM cr_param;
/* query the connection request for incoming private data */
rc = dat_cr_query(cr_handle,
DAT_CR_FIELD_ALL,
&cr_param);
if (rc != DAT_SUCCESS) {
char* major;
char* minor;
dat_strerror(rc, (const char**)&major,
(const char**)&minor);
BTL_ERROR(("ERROR: %s %s %s\n", "dat_cr_query",
major, minor));
return OMPI_ERROR;
}
/* retrieve data from connection request event;
* cr_param contains remote_port_qual but we need to
* match on the psp port and address of remote
* so we get this from the private data.
*/
memcpy(&priv_data_in_addr,
(mca_btl_udapl_addr_t *)cr_param.private_data,
sizeof(mca_btl_udapl_addr_t));
priv_data_in_conn_type = *(int32_t *)
((char *)cr_param.private_data + sizeof(mca_btl_udapl_addr_t));
}
/* create the endpoint for the incoming connection */
rc = mca_btl_udapl_endpoint_create(btl, &ep);
if(OMPI_SUCCESS != rc) {
BTL_ERROR(("ERROR: mca_btl_udapl_endpoint_create"));
return OMPI_ERROR;
}
/* cr_param no longer valid once dat_cr_accept called */
rc = dat_cr_accept(cr_handle, ep, 0, NULL);
if(DAT_SUCCESS != rc) {
char* major;
char* minor;
dat_strerror(rc, (const char**)&major,
(const char**)&minor);
BTL_ERROR(("ERROR: %s %s %s\n", "dat_cr_accept",
major, minor));
return OMPI_ERROR;
}
if (mca_btl_udapl_component.udapl_conn_priv_data) {
/* With accept now in process find a home for the DAT ep by
* matching against the private data that came in on the
* connection request event
*/
/* find the endpoint which matches the address in data received */
proc_ep =
mca_btl_udapl_find_endpoint_address_match(btl, priv_data_in_addr);
if (proc_ep == NULL) {
return OMPI_ERROR;
}
if (BTL_UDAPL_EAGER_CONNECTION == priv_data_in_conn_type) {
proc_ep->endpoint_eager = ep;
} else {
assert(BTL_UDAPL_MAX_CONNECTION == priv_data_in_conn_type);
proc_ep->endpoint_max = ep;
}
}
return OMPI_SUCCESS;
}
/* Wait for a new connection on the PSP (psdapl_listen()).
*
* return -1 on error */
int psdapl_accept_wait(psdapl_con_info_t *ci)
{
DAT_EVENT event;
DAT_COUNT nmore;
DAT_RETURN dat_rc;
dat_rc = dat_evd_wait(ci->socket->evd_handle,
DAT_TIMEOUT_INFINITE /* 5*1000*1000 timeout in usec*/,
1 /* threshold */,
&event, &nmore);
switch (DAT_GET_TYPE(dat_rc)) {
/*
case DAT_TIMEOUT_EXPIRED:
fprintf(stderr, "<mark (timeout)>\n");
break;
*/
case DAT_SUCCESS:
switch (event.event_number) {
case DAT_CONNECTION_EVENT_TIMED_OUT:
psdapl_dprint(2, "psdapl_accept_wait: event DAT_CONNECTION_EVENT_TIMED_OUT");
break;
case DAT_CONNECTION_REQUEST_EVENT:
psdapl_dprint(3, "psdapl_accept_wait: event DAT_CONNECTION_REQUEST_EVENT");
DAT_CR_ARRIVAL_EVENT_DATA *cr = &event.event_data.cr_arrival_event_data;
DAT_CR_PARAM cr_param;
dat_rc = dat_cr_query(cr->cr_handle, DAT_CR_FIELD_ALL, &cr_param);
assert(dat_rc == DAT_SUCCESS);
psdapl_init_msg_t *imsg = (psdapl_init_msg_t *)(cr_param.private_data);
return _psdapl_get_con_accept(ci, cr->cr_handle, imsg);
break;
/*
DAT_DTO_COMPLETION_EVENT = 0x00001,
DAT_RMR_BIND_COMPLETION_EVENT = 0x01001,
DAT_CONNECTION_REQUEST_EVENT = 0x02001,
DAT_CONNECTION_EVENT_ESTABLISHED = 0x04001,
DAT_CONNECTION_EVENT_PEER_REJECTED = 0x04002,
DAT_CONNECTION_EVENT_NON_PEER_REJECTED = 0x04003,
DAT_CONNECTION_EVENT_ACCEPT_COMPLETION_ERROR = 0x04004,
DAT_CONNECTION_EVENT_DISCONNECTED = 0x04005,
DAT_CONNECTION_EVENT_BROKEN = 0x04006,
DAT_CONNECTION_EVENT_TIMED_OUT = 0x04007,
DAT_CONNECTION_EVENT_UNREACHABLE = 0x04008,
DAT_ASYNC_ERROR_EVD_OVERFLOW = 0x08001,
DAT_ASYNC_ERROR_IA_CATASTROPHIC = 0x08002,
DAT_ASYNC_ERROR_EP_BROKEN = 0x08003,
DAT_ASYNC_ERROR_TIMED_OUT = 0x08004,
DAT_ASYNC_ERROR_PROVIDER_INTERNAL_ERROR = 0x08005,
DAT_SOFTWARE_EVENT = 0x10001
*/
default:
psdapl_dprint(2, "psdapl_accept_wait: unexpected event 0x%x",
(unsigned)event.event_number);
break;
}
break;
default:
psdapl_dprint_dat_err(1, dat_rc, "psdapl_accept_wait: dat_evd_wait()");
}
return -1;
}
