/*
* Measure RDS bandwidth (client side).
*/
void
run_client_rds_bw(void)
{
char *buf;
int sockfd;
par_use(L_ACCESS_RECV);
par_use(R_ACCESS_RECV);
set_parameters(8*1024);
client_send_request();
sockfd = init();
buf = qmalloc(Req.msg_size);
sync_test();
while (!Finished) {
int n = sendto(sockfd, buf, Req.msg_size, 0, (SA *)&RAddr, RLen);
if (Finished)
break;
if (n != Req.msg_size) {
LStat.s.no_errs++;
continue;
}
LStat.s.no_bytes += n;
LStat.s.no_msgs++;
}
stop_test_timer();
exchange_results();
free(buf);
close(sockfd);
show_results(BANDWIDTH);
}
boolean BSD_TCP_client_request(void* user_data)
{
char *buf = (char *)user_data;
if(strlen(buf) > MAX_REQU_LEN)return true;
memset(request, 0, MAX_REQU_LEN);
memcpy(request, buf, strlen(buf));
client_send_request();
return true;
}
/*
* Measure RDS latency (client side).
*/
void
run_client_rds_lat(void)
{
char *buf;
int sockfd;
set_parameters(1);
client_send_request();
sockfd = init();
buf = qmalloc(Req.msg_size);
sync_test();
while (!Finished) {
int n = sendto(sockfd, buf, Req.msg_size, 0, (SA *)&RAddr, RLen);
if (Finished)
break;
if (n != Req.msg_size) {
LStat.s.no_errs++;
continue;
}
LStat.s.no_bytes += n;
LStat.s.no_msgs++;
n = read(sockfd, buf, Req.msg_size);
if (Finished)
break;
if (n != Req.msg_size) {
LStat.r.no_errs++;
continue;
}
LStat.r.no_bytes += n;
LStat.r.no_msgs++;
}
stop_test_timer();
exchange_results();
free(buf);
close(sockfd);
show_results(LATENCY);
}
/*
* Open a RDMA device.
*/
int
rd_open(DEVICE *dev, int trans, int max_send_wr, int max_recv_wr)
{
#if 0
/* Send request to client */
if (is_client())
client_send_request();
#endif
/* Clear structure */
memset(dev, 0, sizeof(*dev));
/* Set transport type and maximum work request parameters */
#if 0
dev->trans = trans;
#endif
dev->max_send_wr = max_send_wr;
dev->max_recv_wr = max_recv_wr;
/* Open device */
#if 0
if (Req.use_cm)
cm_open(dev);
else
#endif
int r = ib_open(dev);
if (r != 0) {
return r;
}
/* Request CQ notification if not polling */
if (!Req.poll_mode) {
if (ibv_req_notify_cq(dev->cq, 0) != 0)
return error(SYS, "failed to request CQ notification");
}
return r;
}
static int client_timeout_resend(sd_event_source *s, uint64_t usec,
void *userdata) {
sd_dhcp_client *client = userdata;
usec_t next_timeout = 0;
uint64_t time_now;
uint32_t time_left;
int r;
assert(s);
assert(client);
assert(client->event);
r = sd_event_now(client->event, CLOCK_MONOTONIC, &time_now);
if (r < 0)
goto error;
switch (client->state) {
case DHCP_STATE_RENEWING:
time_left = (client->lease->t2 - client->lease->t1) / 2;
if (time_left < 60)
time_left = 60;
next_timeout = time_now + time_left * USEC_PER_SEC;
break;
case DHCP_STATE_REBINDING:
time_left = (client->lease->lifetime - client->lease->t2) / 2;
if (time_left < 60)
time_left = 60;
next_timeout = time_now + time_left * USEC_PER_SEC;
break;
case DHCP_STATE_REBOOTING:
/* start over as we did not receive a timely ack or nak */
r = client_initialize(client);
if (r < 0)
goto error;
r = client_start(client);
if (r < 0)
goto error;
else {
log_dhcp_client(client, "REBOOTED");
return 0;
}
case DHCP_STATE_INIT:
case DHCP_STATE_INIT_REBOOT:
case DHCP_STATE_SELECTING:
case DHCP_STATE_REQUESTING:
case DHCP_STATE_BOUND:
if (client->attempt < 64)
client->attempt *= 2;
next_timeout = time_now + (client->attempt - 1) * USEC_PER_SEC;
break;
case DHCP_STATE_STOPPED:
r = -EINVAL;
goto error;
}
next_timeout += (random_u32() & 0x1fffff);
client->timeout_resend = sd_event_source_unref(client->timeout_resend);
r = sd_event_add_time(client->event,
&client->timeout_resend,
CLOCK_MONOTONIC,
next_timeout, 10 * USEC_PER_MSEC,
client_timeout_resend, client);
if (r < 0)
goto error;
r = sd_event_source_set_priority(client->timeout_resend,
client->event_priority);
if (r < 0)
goto error;
switch (client->state) {
case DHCP_STATE_INIT:
r = client_send_discover(client);
if (r >= 0) {
client->state = DHCP_STATE_SELECTING;
client->attempt = 1;
} else {
if (client->attempt >= 64)
goto error;
}
break;
case DHCP_STATE_SELECTING:
r = client_send_discover(client);
if (r < 0 && client->attempt >= 64)
goto error;
break;
case DHCP_STATE_INIT_REBOOT:
case DHCP_STATE_REQUESTING:
case DHCP_STATE_RENEWING:
case DHCP_STATE_REBINDING:
r = client_send_request(client);
if (r < 0 && client->attempt >= 64)
goto error;
if (client->state == DHCP_STATE_INIT_REBOOT)
client->state = DHCP_STATE_REBOOTING;
client->request_sent = time_now;
break;
case DHCP_STATE_REBOOTING:
case DHCP_STATE_BOUND:
break;
case DHCP_STATE_STOPPED:
r = -EINVAL;
goto error;
}
return 0;
error:
client_stop(client, r);
/* Errors were dealt with when stopping the client, don't spill
errors into the event loop handler */
return 0;
}
