void *pdu = NULL;
do {
+ struct pollfd pfd;
+
+ pfd.fd = sk;
+ pfd.events = POLLIN;
+ ret = 0;
+ do {
+ ret = poll(&pfd, 1, 100);
+ if (ret < 0) {
+ log_err("fio: poll: %s\n", strerror(errno));
+ break;
+ } else if (!ret)
+ continue;
+
+ if (pfd.revents & POLLIN)
+ break;
+ if (pfd.revents & (POLLERR|POLLHUP)) {
+ ret = 1;
+ break;
+ }
+ } while (ret >= 0);
+
+ if (ret < 0)
+ break;
+
ret = fio_recv_data(sk, &cmd, sizeof(cmd));
if (ret)
break;
cmd_size += cmd.pdu_len;
cmdret = realloc(cmdret, cmd_size);
- pdu = (void *) cmdret->payload;
if (first)
memcpy(cmdret, &cmd, sizeof(cmd));
}
pdu_offset += cmd.pdu_len;
- cmdret->pdu_len += cmd.pdu_len;
+ if (!first)
+ cmdret->pdu_len += cmd.pdu_len;
first = 0;
} while (cmd.flags & FIO_NET_CMD_F_MORE);
if (ret) {
free(cmdret);
cmdret = NULL;
- }
-
- if (cmdret)
+ } else if (cmdret)
cmdret->flags &= ~FIO_NET_CMD_F_MORE;
return cmdret;
{
uint32_t pdu_len;
- cmd->cmd_crc16 = cpu_to_le16(crc16(cmd, FIO_NET_CMD_CRC_SZ));
+ cmd->cmd_crc16 = __cpu_to_le16(crc16(cmd, FIO_NET_CMD_CRC_SZ));
pdu_len = le32_to_cpu(cmd->pdu_len);
if (pdu_len)
- cmd->pdu_crc16 = cpu_to_le16(crc16(cmd->payload, pdu_len));
+ cmd->pdu_crc16 = __cpu_to_le16(crc16(cmd->payload, pdu_len));
}
int fio_net_send_cmd(int fd, uint16_t opcode, const void *buf, off_t size)
fio_init_net_cmd(cmd, opcode, buf, this_len);
if (this_len < size)
- cmd->flags = cpu_to_le32(FIO_NET_CMD_F_MORE);
+ cmd->flags = __cpu_to_le32(FIO_NET_CMD_F_MORE);
fio_net_cmd_crc(cmd);
return ret;
}
-static int send_simple_command(int sk, uint16_t opcode, uint64_t serial)
+int fio_net_send_simple_cmd(int sk, uint16_t opcode, uint64_t serial)
{
struct fio_net_cmd cmd = {
- .version = cpu_to_le16(FIO_SERVER_VER1),
+ .version = __cpu_to_le16(FIO_SERVER_VER1),
.opcode = cpu_to_le16(opcode),
.serial = cpu_to_le64(serial),
};
return fio_send_data(sk, &cmd, sizeof(cmd));
}
-/*
- * Send an ack for this command
- */
-static int ack_command(int sk, struct fio_net_cmd *cmd)
-{
-#if 0
- return send_simple_command(sk, FIO_NET_CMD_ACK, cmd->serial);
-#else
- return 0;
-#endif
-}
-
-#if 0
-static int nak_command(int sk, struct fio_net_cmd *cmd)
-{
- return send_simple_command(sk, FIO_NET_CMD_NAK, cmd->serial);
-}
-#endif
-
static int send_quit_command(void)
{
dprint(FD_NET, "server: sending quit\n");
- return send_simple_command(server_fd, FIO_NET_CMD_QUIT, 0);
+ return fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_QUIT, 0);
}
static int handle_cur_job(struct fio_net_cmd *cmd)
switch (cmd->opcode) {
case FIO_NET_CMD_QUIT:
+ fio_terminate_threads(TERMINATE_ALL);
return 1;
case FIO_NET_CMD_EXIT:
exit_backend = 1;
break;
}
- ret = ack_command(sk, cmd);
- if (ret)
- break;
-
ret = handle_command(cmd);
if (ret)
break;
return ret;
}
+void fio_server_idle_loop(void)
+{
+ if (server_fd != -1)
+ handle_connection(server_fd);
+}
+
static int accept_loop(int listen_sk)
{
struct sockaddr addr;
server_fd = sk;
+ printf("handle\n");
+
exitval = handle_connection(sk);
+ printf("out, exit %d\n", exitval);
+
server_fd = -1;
close(sk);
dst->min_val = cpu_to_le64(src->min_val);
dst->samples = cpu_to_le64(src->samples);
/* FIXME */
- dst->mean = cpu_to_le64(src->mean);
- dst->S = cpu_to_le64(src->S);
+ dst->mean = __cpu_to_le64(src->mean);
+ dst->S = __cpu_to_le64(src->S);
}
static void convert_gs(struct group_run_stats *dst, struct group_run_stats *src)
strcpy(p.ts.verror, ts->verror);
strcpy(p.ts.description, ts->description);
- p.ts.error = cpu_to_le32(ts->error);
+ p.ts.error = cpu_to_le32(ts->error);
p.ts.groupid = cpu_to_le32(ts->groupid);
- p.ts.pid = cpu_to_le32(ts->pid);
+ p.ts.pid = cpu_to_le32(ts->pid);
p.ts.members = cpu_to_le32(ts->members);
for (i = 0; i < 2; i++) {
for (i = 0; i < 3; i++) {
p.ts.total_io_u[i] = cpu_to_le64(ts->total_io_u[i]);
- p.ts.short_io_u[i] = cpu_to_le64(ts->total_io_u[i]);
+ p.ts.short_io_u[i] = cpu_to_le64(ts->short_io_u[i]);
}
- p.ts.total_submit = cpu_to_le64(ts->total_submit);
+ p.ts.total_submit = cpu_to_le64(ts->total_submit);
p.ts.total_complete = cpu_to_le64(ts->total_complete);
for (i = 0; i < 2; i++) {
p.ts.total_run_time = cpu_to_le64(ts->total_run_time);
p.ts.continue_on_error = cpu_to_le16(ts->continue_on_error);
p.ts.total_err_count = cpu_to_le64(ts->total_err_count);
- p.ts.first_error = cpu_to_le64(ts->first_error);
- p.ts.kb_base = cpu_to_le64(ts->kb_base);
+ p.ts.first_error = cpu_to_le32(ts->first_error);
+ p.ts.kb_base = cpu_to_le32(ts->kb_base);
convert_gs(&p.rs, rs);
fio_net_send_cmd(server_fd, FIO_NET_CMD_GS, &gs, sizeof(gs));
}
+void fio_server_send_status(void)
+{
+ struct jobs_eta *je;
+ size_t size;
+ void *buf;
+ int i;
+
+ size = sizeof(*je) + thread_number * sizeof(char);
+ buf = malloc(size);
+ memset(buf, 0, size);
+ je = buf;
+
+ if (!calc_thread_status(je)) {
+ free(je);
+ return;
+ }
+
+ je->nr_running = cpu_to_le32(je->nr_running);
+ je->nr_ramp = cpu_to_le32(je->nr_ramp);
+ je->nr_pending = cpu_to_le32(je->nr_pending);
+ je->files_open = cpu_to_le32(je->files_open);
+ je->m_rate = cpu_to_le32(je->m_rate);
+ je->t_rate = cpu_to_le32(je->t_rate);
+ je->m_iops = cpu_to_le32(je->m_iops);
+ je->t_iops = cpu_to_le32(je->t_iops);
+
+ for (i = 0; i < 2; i++) {
+ je->rate[i] = cpu_to_le32(je->rate[i]);
+ je->iops[i] = cpu_to_le32(je->iops[i]);
+ }
+
+ je->elapsed_sec = cpu_to_le32(je->nr_running);
+ je->eta_sec = cpu_to_le64(je->eta_sec);
+
+ fio_net_send_cmd(server_fd, FIO_NET_CMD_ETA, buf, size);
+ free(je);
+}
+
int fio_server_log(const char *format, ...)
{
char buffer[1024];
projects / fio.git / blobdiff