ssize_t
crm_ipcs_send(qb_ipcs_connection_t *c, uint32_t request, xmlNode *message, enum crm_ipc_server_flags flags)
{
int rc;
int lpc = 0;
int retries = 40;
int level = LOG_CRIT;
struct iovec iov[2];
static uint32_t id = 1;
const char *type = "Response";
struct qb_ipc_response_header header;
char *buffer = dump_xml_unformatted(message);
struct timespec delay = { 0, 250000000 }; /* 250ms */
memset(&iov, 0, 2 * sizeof(struct iovec));
iov[0].iov_len = sizeof(struct qb_ipc_response_header);
iov[0].iov_base = &header;
iov[1].iov_len = 1 + strlen(buffer);
iov[1].iov_base = buffer;
if(flags & crm_ipc_server_event) {
header.id = id++; /* We don't really use it, but doesn't hurt to set one */
} else {
CRM_LOG_ASSERT (request != 0);
header.id = request; /* Replying to a specific request */
}
header.error = 0; /* unused */
header.size = iov[0].iov_len + iov[1].iov_len;
if(flags & crm_ipc_server_error) {
retries = 20;
level = LOG_ERR;
} else if(flags & crm_ipc_server_info) {
retries = 10;
level = LOG_INFO;
}
while(lpc < retries) {
if(flags & crm_ipc_server_event) {
type = "Event";
rc = qb_ipcs_event_sendv(c, iov, 2);
if(rc == -EPIPE || rc == -ENOTCONN) {
crm_trace("Client %p disconnected", c);
level = LOG_INFO;
}
} else {
rc = qb_ipcs_response_sendv(c, iov, 2);
}
if(rc != -EAGAIN) {
break;
}
lpc++;
crm_debug("Attempting resend %d of %s %d (%d bytes) to %p[%d]: %.120s",
lpc, type, header.id, header.size, c, crm_ipcs_client_pid(c), buffer);
nanosleep(&delay, NULL);
}
if(rc < header.size) {
struct qb_ipcs_connection_stats_2 *stats = qb_ipcs_connection_stats_get_2(c, 0);
do_crm_log(level,
"%s %d failed, size=%d, to=%p[%d], queue=%d, rc=%d: %.120s",
type, header.id, header.size, c, stats->client_pid, stats->event_q_length, rc, buffer);
free(stats);
} else {
crm_trace("%s %d sent, %d bytes to %p[%d]: %.120s", type, header.id, rc,
c, crm_ipcs_client_pid(c), buffer);
}
free(buffer);
return rc;
}
static int32_t
s1_msg_process_fn(qb_ipcs_connection_t *c,
void *data, size_t size)
{
struct qb_ipc_request_header *req_pt = (struct qb_ipc_request_header *)data;
struct qb_ipc_response_header response = { 0, };
ssize_t res;
if (req_pt->id == IPC_MSG_REQ_TX_RX) {
response.size = sizeof(struct qb_ipc_response_header);
response.id = IPC_MSG_RES_TX_RX;
response.error = 0;
res = qb_ipcs_response_send(c, &response, response.size);
if (res < 0) {
qb_perror(LOG_INFO, "qb_ipcs_response_send");
} else if (res != response.size) {
qb_log(LOG_DEBUG, "qb_ipcs_response_send %zd != %d",
res, response.size);
}
if (turn_on_fc) {
qb_ipcs_request_rate_limit(s1, QB_IPCS_RATE_OFF);
}
} else if (req_pt->id == IPC_MSG_REQ_DISPATCH) {
response.size = sizeof(struct qb_ipc_response_header);
response.id = IPC_MSG_RES_DISPATCH;
response.error = 0;
res = qb_ipcs_event_send(c, &response,
sizeof(response));
if (res < 0) {
qb_perror(LOG_INFO, "qb_ipcs_event_send");
}
} else if (req_pt->id == IPC_MSG_REQ_BULK_EVENTS) {
int32_t m;
int32_t num;
struct qb_ipcs_connection_stats_2 *stats;
uint32_t max_size = MAX_MSG_SIZE;
response.size = sizeof(struct qb_ipc_response_header);
response.error = 0;
stats = qb_ipcs_connection_stats_get_2(c, QB_FALSE);
num = stats->event_q_length;
free(stats);
/* crazy large message */
res = qb_ipcs_event_send(c, &response, max_size*10);
ck_assert_int_eq(res, -EMSGSIZE);
/* send one event before responding */
res = qb_ipcs_event_send(c, &response, sizeof(response));
ck_assert_int_eq(res, sizeof(response));
response.id++;
/* There should be one more item in the event queue now. */
stats = qb_ipcs_connection_stats_get_2(c, QB_FALSE);
ck_assert_int_eq(stats->event_q_length - num, 1);
free(stats);
/* send response */
response.id = IPC_MSG_RES_BULK_EVENTS;
res = qb_ipcs_response_send(c, &response, response.size);
ck_assert_int_eq(res, sizeof(response));
/* send the rest of the events after the response */
for (m = 1; m < num_bulk_events; m++) {
res = qb_ipcs_event_send(c, &response, sizeof(response));
if (res == -EAGAIN || res == -ENOBUFS) {
/* retry */
usleep(1000);
m--;
continue;
}
ck_assert_int_eq(res, sizeof(response));
response.id++;
}
} else if (req_pt->id == IPC_MSG_REQ_STRESS_EVENT) {
struct {
struct qb_ipc_response_header hdr __attribute__ ((aligned(8)));
char data[GIANT_MSG_DATA_SIZE] __attribute__ ((aligned(8)));
uint32_t sent_msgs __attribute__ ((aligned(8)));
} __attribute__ ((aligned(8))) giant_event_send;
int32_t m;
response.size = sizeof(struct qb_ipc_response_header);
response.error = 0;
response.id = IPC_MSG_RES_STRESS_EVENT;
res = qb_ipcs_response_send(c, &response, response.size);
ck_assert_int_eq(res, sizeof(response));
giant_event_send.hdr.error = 0;
giant_event_send.hdr.id = IPC_MSG_RES_STRESS_EVENT;
for (m = 0; m < num_stress_events; m++) {
size_t sent_len = sizeof(struct qb_ipc_response_header);
if (((m+1) % 1000) == 0) {
sent_len = sizeof(giant_event_send);
giant_event_send.sent_msgs = m + 1;
}
giant_event_send.hdr.size = sent_len;
res = qb_ipcs_event_send(c, &giant_event_send, sent_len);
if (res < 0) {
if (res == -EAGAIN || res == -ENOBUFS) {
/* yield to the receive process */
usleep(1000);
m--;
continue;
} else {
qb_perror(LOG_DEBUG, "sending stress events");
ck_assert_int_eq(res, sent_len);
}
} else if (((m+1) % 1000) == 0) {
qb_log(LOG_DEBUG, "SENT: %d stress events sent", m+1);
}
giant_event_send.hdr.id++;
}
} else if (req_pt->id == IPC_MSG_REQ_SERVER_FAIL) {
