static CMPIStatus TCPCOMM_IndicationMI_deActivateFilter(provider_address * addr,
RemoteCMPIIndicationMI * cThis,
CMPIContext * context,
CMPIResult * result,
CMPIObjectPath * cop,
CMPISelectExp * filter,
const char *indType,
CMPIBoolean lastActivation)
#endif
{
int socket;
unsigned long int ctxid = save_context(context);
TRACE_NORMAL(("Executing remote MI call."));
CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
__FUNCTION__, context, cop);
if (socket < 0)
CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
(__sft)->serialize_CMPISelectExp(socket, filter);
(__sft)->serialize_string(socket, indType);
(__sft)->serialize_UINT8(socket, lastActivation);
{
CMPIStatus rc;
CMPIArray *r;
rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
close(socket);
remove_context(ctxid);
#ifndef CMPI_VER_100
socketcomm_array2result(r, result);
#endif
return rc;
};
};
static CMPIStatus TCPCOMM_InstanceMI_deleteInstance(provider_address * addr,
RemoteCMPIInstanceMI * cThis,
CONST CMPIContext * context,
CONST CMPIResult * result,
CONST CMPIObjectPath * cop)
{
int socket;
unsigned long int ctxid = save_context(context);
TRACE_NORMAL(("Executing remote MI call."));
CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
__FUNCTION__, context, cop);
if (socket < 0)
CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
{
CMPIStatus rc;
CMPIArray *r;
rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
close(socket);
remove_context(ctxid);
socketcomm_array2result(r, result);
return rc;
};
}
static int route_handler(struct cmatest_node *node)
{
struct rdma_conn_param conn_param;
int ret;
ret = verify_test_params(node);
if (ret)
goto err;
ret = init_node(node);
if (ret)
goto err;
ret = post_recvs(node);
if (ret)
goto err;
memset(&conn_param, 0, sizeof conn_param);
ret = rdma_connect(node->cma_id, &conn_param);
if (ret) {
perror("udaddy: failure connecting");
goto err;
}
return 0;
err:
connect_error();
return ret;
}
static CMPIStatus TCPCOMM_AssociationMI_references(provider_address * addr,
RemoteCMPIAssociationMI * cThis,
CONST CMPIContext * context,
CONST CMPIResult * result,
CONST CMPIObjectPath * cop,
const char *assocclass,
const char *role,
CONST char **props)
{
int socket;
unsigned long int ctxid = save_context(context);
TRACE_NORMAL(("Executing remote MI call."));
CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
__FUNCTION__, context, cop);
if (socket < 0)
CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
(__sft)->serialize_string(socket, assocclass);
(__sft)->serialize_string(socket, role);
socketcomm_serialize_props(socket, (__sft), (char **)props);
{
CMPIStatus rc;
CMPIArray *r;
rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
close(socket);
remove_context(ctxid);
socketcomm_array2result(r, result);
return rc;
};
}
static int cma_handler(struct rdma_cm_id *cma_id, struct rdma_cm_event *event)
{
int ret = 0;
switch (event->event) {
case RDMA_CM_EVENT_ADDR_RESOLVED:
ret = addr_handler(cma_id->context);
break;
case RDMA_CM_EVENT_MULTICAST_JOIN:
ret = join_handler(cma_id->context, &event->param.ud);
break;
case RDMA_CM_EVENT_ADDR_ERROR:
case RDMA_CM_EVENT_ROUTE_ERROR:
case RDMA_CM_EVENT_MULTICAST_ERROR:
printf("mckey: event: %s, error: %d\n",
rdma_event_str(event->event), event->status);
connect_error();
ret = event->status;
break;
case RDMA_CM_EVENT_DEVICE_REMOVAL:
/* Cleanup will occur after test completes. */
break;
default:
break;
}
return ret;
}
static int cma_handler(struct rdma_cm_id *cma_id, struct rdma_cm_event *event)
{
int ret = 0;
switch (event->event) {
case RDMA_CM_EVENT_ADDR_RESOLVED:
ret = addr_handler(cma_id->context);
break;
case RDMA_CM_EVENT_ROUTE_RESOLVED:
ret = route_handler(cma_id->context);
break;
case RDMA_CM_EVENT_CONNECT_REQUEST:
ret = connect_handler(cma_id);
break;
case RDMA_CM_EVENT_ESTABLISHED:
ret = resolved_handler(cma_id->context, event);
break;
case RDMA_CM_EVENT_ADDR_ERROR:
case RDMA_CM_EVENT_ROUTE_ERROR:
case RDMA_CM_EVENT_CONNECT_ERROR:
case RDMA_CM_EVENT_UNREACHABLE:
case RDMA_CM_EVENT_REJECTED:
printf("udaddy: event: %s, error: %d\n",
rdma_event_str(event->event), event->status);
connect_error();
ret = event->status;
break;
case RDMA_CM_EVENT_DEVICE_REMOVAL:
/* Cleanup will occur after test completes. */
break;
default:
break;
}
return ret;
}
static int addr_handler(struct cmatest_node *node)
{
int ret;
ret = verify_test_params(node);
if (ret)
goto err;
ret = init_node(node);
if (ret)
goto err;
if (!is_sender) {
ret = post_recvs(node);
if (ret)
goto err;
}
ret = rdma_join_multicast(node->cma_id, test.dst_addr, node);
if (ret) {
perror("mckey: failure joining");
goto err;
}
return 0;
err:
connect_error();
return ret;
}
static int route_handler(struct cmatest_node *node)
{
struct rdma_conn_param conn_param;
int ret;
ret = init_node(node);
if (ret)
goto err;
ret = post_recvs(node);
if (ret)
goto err;
memset(&conn_param, 0, sizeof conn_param);
conn_param.responder_resources = 1;
conn_param.initiator_depth = 1;
conn_param.retry_count = 5;
conn_param.private_data = test.rai->ai_connect;
conn_param.private_data_len = test.rai->ai_connect_len;
ret = rdma_connect(node->cma_id, &conn_param);
if (ret) {
perror("cmatose: failure connecting");
goto err;
}
return 0;
err:
connect_error();
return ret;
}
static int run_client(void)
{
struct rdma_addrinfo hints;
int i, ret, ret2;
printf("cmatose: starting client\n");
memset(&hints, 0, sizeof hints);
hints.ai_port_space = RDMA_PS_TCP;
ret = get_rdma_addr(src_addr, dst_addr, port, &hints, &test.rai);
if (ret) {
perror("cmatose: getaddrinfo error");
return ret;
}
printf("cmatose: connecting\n");
for (i = 0; i < connections; i++) {
ret = rdma_resolve_addr(test.nodes[i].cma_id, test.rai->ai_src_addr,
test.rai->ai_dst_addr, 2000);
if (ret) {
perror("cmatose: failure getting addr");
connect_error();
return ret;
}
}
ret = connect_events();
if (ret)
goto disc;
if (message_count) {
printf("receiving data transfers\n");
ret = poll_cqs(RECV_CQ_INDEX);
if (ret)
goto disc;
printf("sending replies\n");
for (i = 0; i < connections; i++) {
ret = post_sends(&test.nodes[i]);
if (ret)
goto disc;
}
printf("data transfers complete\n");
}
ret = 0;
if (migrate) {
ret = migrate_channel(NULL);
if (ret)
goto out;
}
disc:
ret2 = disconnect_events();
if (ret2)
ret = ret2;
out:
return ret;
}
static int run_client(void)
{
int i, ret;
printf("udaddy: starting client\n");
if (src_addr) {
ret = get_addr(src_addr, &test.src_in);
if (ret)
return ret;
}
ret = get_addr(dst_addr, &test.dst_in);
if (ret)
return ret;
test.dst_in.sin_port = port;
printf("udaddy: connecting\n");
for (i = 0; i < connections; i++) {
ret = rdma_resolve_addr(test.nodes[i].cma_id,
src_addr ? test.src_addr : NULL,
test.dst_addr, 2000);
if (ret) {
perror("udaddy: failure getting addr");
connect_error();
return ret;
}
}
ret = connect_events();
if (ret)
goto out;
if (message_count) {
printf("initiating data transfers\n");
for (i = 0; i < connections; i++) {
ret = post_sends(&test.nodes[i], 0);
if (ret)
goto out;
}
printf("receiving data transfers\n");
ret = poll_cqs();
if (ret)
goto out;
printf("data transfers complete\n");
}
out:
return ret;
}
MODULE open_listen_socket (THREAD *thread)
{
static char
port [10];
Bool
next_port = FALSE;
int
index = 0;
tcb = thread-> tcb; /* Point to thread's context */
tcb-> transfer_type = 0;
if (tcb-> data_port > ip_portbase)
tcb-> data_port -= ip_portbase;
sprintf (port, "%d", tcb-> data_port);
if (sym_lookup_symbol (pasv_port, port) == NULL)
{
next_port = FALSE;
tcb-> handle = passive_TCP (port, 5);
index++;
}
else
next_port = TRUE;
while (index < 200
&& (next_port == TRUE || connect_error () == IP_BINDERROR))
{
tcb-> data_port++; /* Port in use - try next one */
sprintf (port, "%d", tcb-> data_port);
if (sym_lookup_symbol (pasv_port, port) == NULL)
{
next_port = FALSE;
tcb-> handle = passive_TCP (port, 5);
index++;
}
else
next_port = TRUE;
}
if (tcb-> handle == INVALID_SOCKET || index >= 200)
tcb-> handle = 0; /* 0 means 'not open' */
else
{
tcb-> data_port += ip_portbase;
sym_assume_symbol (pasv_port, port, port);
}
the_next_event = tcb-> handle? ok_event: error_event;
}
static int connect_handler(struct rdma_cm_id *cma_id)
{
struct cmatest_node *node;
struct rdma_conn_param conn_param;
int ret;
if (test.conn_index == connections) {
ret = -ENOMEM;
goto err1;
}
node = &test.nodes[test.conn_index++];
node->cma_id = cma_id;
cma_id->context = node;
ret = verify_test_params(node);
if (ret)
goto err2;
ret = init_node(node);
if (ret)
goto err2;
ret = post_recvs(node);
if (ret)
goto err2;
memset(&conn_param, 0, sizeof conn_param);
conn_param.qp_num = node->cma_id->qp->qp_num;
ret = rdma_accept(node->cma_id, &conn_param);
if (ret) {
perror("udaddy: failure accepting");
goto err2;
}
node->connected = 1;
test.connects_left--;
return 0;
err2:
node->cma_id = NULL;
connect_error();
err1:
printf("udaddy: failing connection request\n");
rdma_reject(cma_id, NULL, 0);
return ret;
}
static int addr_handler(struct cmatest_node *node)
{
int ret;
if (set_tos) {
ret = rdma_set_option(node->cma_id, RDMA_OPTION_ID,
RDMA_OPTION_ID_TOS, &tos, sizeof tos);
if (ret)
perror("cmatose: set TOS option failed");
}
ret = rdma_resolve_route(node->cma_id, 2000);
if (ret) {
perror("cmatose: resolve route failed");
connect_error();
}
return ret;
}
static int resolved_handler(struct cmatest_node *node,
struct rdma_cm_event *event)
{
node->remote_qpn = event->param.ud.qp_num;
node->remote_qkey = event->param.ud.qkey;
node->ah = ibv_create_ah(node->pd, &event->param.ud.ah_attr);
if (!node->ah) {
printf("udaddy: failure creating address handle\n");
goto err;
}
node->connected = 1;
test.connects_left--;
return 0;
err:
connect_error();
return -1;
}
static int run_client(void)
{
int i, ret;
printf("udaddy: starting client\n");
ret = get_rdma_addr(src_addr, dst_addr, port, &hints, &test.rai);
if (ret) {
perror("udaddy: getaddrinfo error");
return ret;
}
printf("udaddy: connecting\n");
for (i = 0; i < connections; i++) {
ret = rdma_resolve_addr(test.nodes[i].cma_id, test.rai->ai_src_addr,
test.rai->ai_dst_addr, 2000);
if (ret) {
perror("udaddy: failure getting addr");
connect_error();
return ret;
}
}
ret = connect_events();
if (ret)
goto out;
if (message_count) {
printf("initiating data transfers\n");
for (i = 0; i < connections; i++) {
ret = post_sends(&test.nodes[i], 0);
if (ret)
goto out;
}
printf("receiving data transfers\n");
ret = poll_cqs();
if (ret)
goto out;
printf("data transfers complete\n");
}
out:
return ret;
}
void
wtp_open (
const char *version, /* WTP version */
const char *protocol, /* Protocol from command-line */
const char *port) /* Port from command-line */
{
ASSERT (streq (version, "WTP/1.0"));
ASSERT (streq (protocol, "tcp"));
sock_init ();
ip_nonblock = FALSE; /* Use blocking socket i/o */
wtp_socket = connect_TCP (NULL, port);
if (wtp_socket == INVALID_SOCKET)
{
coprintf ("Cannot connect to port %s: %s (%s)\n",
port, connect_errlist [connect_error ()], sockmsg ());
exit (EXIT_FAILURE);
}
socket_nodelay (wtp_socket); /* Disable Nagle's Algorithm */
}
static int connect_handler(struct rdma_cm_id *cma_id)
{
struct cmatest_node *node;
int ret;
if (test.conn_index == connections) {
ret = -ENOMEM;
goto err1;
}
node = &test.nodes[test.conn_index++];
node->cma_id = cma_id;
cma_id->context = node;
ret = init_node(node);
if (ret)
goto err2;
ret = post_recvs(node);
if (ret)
goto err2;
ret = rdma_accept(node->cma_id, NULL);
if (ret) {
perror("cmatose: failure accepting");
goto err2;
}
return 0;
err2:
node->cma_id = NULL;
connect_error();
err1:
printf("cmatose: failing connection request\n");
rdma_reject(cma_id, NULL, 0);
return ret;
}
static int join_handler(struct cmatest_node *node,
struct rdma_ud_param *param)
{
char buf[40];
inet_ntop(AF_INET6, param->ah_attr.grh.dgid.raw, buf, 40);
printf("mckey: joined dgid: %s mlid 0x%x sl %d\n", buf,
param->ah_attr.dlid, param->ah_attr.sl);
node->remote_qpn = param->qp_num;
node->remote_qkey = param->qkey;
node->ah = ibv_create_ah(node->pd, ¶m->ah_attr);
if (!node->ah) {
printf("mckey: failure creating address handle\n");
goto err;
}
node->connected = 1;
test.connects_left--;
return 0;
err:
connect_error();
return -1;
}
static int
sock_passive (int argc, RESULT_NODE **argv, void *item, RESULT_NODE *result, THREAD *gsl_thread)
{
RESULT_NODE *service = argc > 0 ? argv [0] : NULL;
RESULT_NODE *error = argc > 1 ? argv [1] : NULL;
if (! service)
{
strcpy (object_error, "Missing argument: service");
return -1;
}
if (service-> value. type == TYPE_UNDEFINED)
{
result-> culprit = service-> culprit;
service-> culprit = NULL;
return 0;
}
{
SOCK_HANDLE_ITEM
*socket;
sock_t
handle;
SOCK_CONTEXT
*context = item;
const char
*error_msg;
char
*error_text;
if (start_socket_agent ())
return -1;
handle = passive_TCP (string_value (& service-> value),
QUEUE_LENGTH);
if (handle != INVALID_SOCKET) /* Success */
{
socket = memt_alloc (NULL, sizeof (SOCK_HANDLE_ITEM));
socket-> links = 0;
socket-> handle = handle;
socket-> error_msg = NULL;
assign_pointer (& result-> value, & sock_handle_class, socket);
error_msg = NULL;
}
else
error_msg = connect_errlist [connect_error ()];
if (store_module_error (gsl_thread,
context,
error,
error_msg,
&error_text))
{
strncpy (object_error, error_text, LINE_MAX);
return -1;
}
else
return 0;
}
return 0; /* Just in case */
}
static int run(void)
{
int i, ret;
printf("mckey: starting %s\n", is_sender ? "client" : "server");
if (src_addr) {
ret = get_addr(src_addr, (struct sockaddr *) &test.src_in);
if (ret)
return ret;
}
ret = get_addr(dst_addr, (struct sockaddr *) &test.dst_in);
if (ret)
return ret;
printf("mckey: joining\n");
for (i = 0; i < connections; i++) {
if (src_addr) {
ret = rdma_bind_addr(test.nodes[i].cma_id,
test.src_addr);
if (ret) {
perror("mckey: addr bind failure");
connect_error();
return ret;
}
}
if (unmapped_addr)
ret = addr_handler(&test.nodes[i]);
else
ret = rdma_resolve_addr(test.nodes[i].cma_id,
test.src_addr, test.dst_addr,
2000);
if (ret) {
perror("mckey: resolve addr failure");
connect_error();
return ret;
}
}
ret = connect_events();
if (ret)
goto out;
pthread_create(&test.cmathread, NULL, cma_thread, NULL);
/*
* Pause to give SM chance to configure switches. We don't want to
* handle reliability issue in this simple test program.
*/
sleep(3);
if (message_count) {
if (is_sender) {
printf("initiating data transfers\n");
for (i = 0; i < connections; i++) {
ret = post_sends(&test.nodes[i], 0);
if (ret)
goto out;
}
} else {
printf("receiving data transfers\n");
ret = poll_cqs();
if (ret)
goto out;
}
printf("data transfers complete\n");
}
out:
for (i = 0; i < connections; i++) {
ret = rdma_leave_multicast(test.nodes[i].cma_id,
test.dst_addr);
if (ret)
perror("mckey: failure leaving");
}
return ret;
}
