X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=server.c;h=e7a905722f30f4d3b3177aafdbd63c735e7a1376;hp=5afd8d455f72c3178f9b9560719bd8e982cfca31;hb=7e356b2dee2e86f3684424fc6e903f1ef9f00ef4;hpb=af9c9fb34e420fc4d9cf317aa0f3cf6795a5a07f diff --git a/server.c b/server.c index 5afd8d45..e7a90572 100644 --- a/server.c +++ b/server.c @@ -20,7 +20,7 @@ #include "fio.h" #include "server.h" #include "crc/crc16.h" -#include "ieee754.h" +#include "lib/ieee754.h" #include "fio_version.h" @@ -33,6 +33,34 @@ static char *fio_server_arg; static char *bind_sock; static struct sockaddr_in saddr_in; +static const char *fio_server_ops[FIO_NET_CMD_NR] = { + "", + "QUIT", + "EXIT", + "JOB", + "JOBLINE", + "TEXT", + "TS", + "GS", + "SEND_ETA", + "ETA", + "PROBE", + "START", + "STOP", + "DISK_UTIL", +}; + +const char *fio_server_op(unsigned int op) +{ + static char buf[32]; + + if (op < FIO_NET_CMD_NR) + return fio_server_ops[op]; + + sprintf(buf, "UNKNOWN/%d", op); + return buf; +} + int fio_send_data(int sk, const void *p, unsigned int len) { assert(len <= sizeof(struct fio_net_cmd) + FIO_SERVER_MAX_PDU); @@ -50,6 +78,8 @@ int fio_send_data(int sk, const void *p, unsigned int len) break; else if (errno == EAGAIN || errno == EINTR) continue; + else + break; } while (!exit_backend); if (!len) @@ -73,6 +103,8 @@ int fio_recv_data(int sk, void *p, unsigned int len) break; else if (errno == EAGAIN || errno == EINTR) continue; + else + break; } while (!exit_backend); if (!len) @@ -208,8 +240,8 @@ void fio_net_cmd_crc(struct fio_net_cmd *cmd) int fio_net_send_cmd(int fd, uint16_t opcode, const void *buf, off_t size, uint64_t tag) { - struct fio_net_cmd *cmd; - size_t this_len; + struct fio_net_cmd *cmd = NULL; + size_t this_len, cur_len = 0; int ret; do { @@ -217,7 +249,13 @@ int fio_net_send_cmd(int fd, uint16_t opcode, const void *buf, off_t size, if (this_len > FIO_SERVER_MAX_PDU) this_len = FIO_SERVER_MAX_PDU; - cmd = malloc(sizeof(*cmd) + this_len); + if (!cmd || cur_len < sizeof(*cmd) + this_len) { + if (cmd) + free(cmd); + + cur_len = sizeof(*cmd) + this_len; + cmd = malloc(cur_len); + } fio_init_net_cmd(cmd, opcode, buf, this_len, tag); @@ -227,15 +265,17 @@ int fio_net_send_cmd(int fd, uint16_t opcode, const void *buf, off_t size, fio_net_cmd_crc(cmd); ret = fio_send_data(fd, cmd, sizeof(*cmd) + this_len); - free(cmd); size -= this_len; buf += this_len; } while (!ret && size); + if (cmd) + free(cmd); + return ret; } -int fio_net_send_simple_cmd(int sk, uint16_t opcode, uint64_t tag) +static int fio_net_send_simple_stack_cmd(int sk, uint16_t opcode, uint64_t tag) { struct fio_net_cmd cmd; @@ -245,10 +285,42 @@ int fio_net_send_simple_cmd(int sk, uint16_t opcode, uint64_t tag) return fio_send_data(sk, &cmd, sizeof(cmd)); } +/* + * If 'list' is non-NULL, then allocate and store the sent command for + * later verification. + */ +int fio_net_send_simple_cmd(int sk, uint16_t opcode, uint64_t tag, + struct flist_head *list) +{ + struct fio_net_int_cmd *cmd; + int ret; + + if (!list) + return fio_net_send_simple_stack_cmd(sk, opcode, tag); + + cmd = malloc(sizeof(*cmd)); + + fio_init_net_cmd(&cmd->cmd, opcode, NULL, 0, (uintptr_t) cmd); + fio_net_cmd_crc(&cmd->cmd); + + INIT_FLIST_HEAD(&cmd->list); + gettimeofday(&cmd->tv, NULL); + cmd->saved_tag = tag; + + ret = fio_send_data(sk, &cmd->cmd, sizeof(cmd->cmd)); + if (ret) { + free(cmd); + return ret; + } + + flist_add_tail(&cmd->list, list); + return 0; +} + static int fio_server_send_quit_cmd(void) { dprint(FD_NET, "server: sending quit\n"); - return fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_QUIT, 0); + return fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_QUIT, 0, NULL); } static int handle_job_cmd(struct fio_net_cmd *cmd) @@ -261,7 +333,7 @@ static int handle_job_cmd(struct fio_net_cmd *cmd) return -1; } - fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_START, 0); + fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_START, 0, NULL); ret = exec_run(); fio_server_send_quit_cmd(); @@ -301,7 +373,7 @@ static int handle_jobline_cmd(struct fio_net_cmd *cmd) free(argv); - fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_START, 0); + fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_START, 0, NULL); ret = exec_run(); fio_server_send_quit_cmd(); @@ -313,6 +385,8 @@ static int handle_probe_cmd(struct fio_net_cmd *cmd) { struct cmd_probe_pdu probe; + dprint(FD_NET, "server: sending probe reply\n"); + memset(&probe, 0, sizeof(probe)); gethostname((char *) probe.hostname, sizeof(probe.hostname)); #ifdef FIO_BIG_ENDIAN @@ -325,20 +399,23 @@ static int handle_probe_cmd(struct fio_net_cmd *cmd) probe.os = FIO_OS; probe.arch = FIO_ARCH; - return fio_net_send_cmd(server_fd, FIO_NET_CMD_PROBE, &probe, sizeof(probe), 0); + probe.bpp = sizeof(void *); + + return fio_net_send_cmd(server_fd, FIO_NET_CMD_PROBE, &probe, sizeof(probe), cmd->tag); } static int handle_send_eta_cmd(struct fio_net_cmd *cmd) { 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 (!thread_number) + return 0; + + size = sizeof(*je) + thread_number * sizeof(char) + 1; + je = malloc(size); + memset(je, 0, size); if (!calc_thread_status(je, 1)) { free(je); @@ -364,7 +441,7 @@ static int handle_send_eta_cmd(struct fio_net_cmd *cmd) 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, cmd->tag); + fio_net_send_cmd(server_fd, FIO_NET_CMD_ETA, je, size, cmd->tag); free(je); return 0; } @@ -373,7 +450,8 @@ static int handle_command(struct fio_net_cmd *cmd) { int ret; - dprint(FD_NET, "server: got opcode %d\n", cmd->opcode); + dprint(FD_NET, "server: got op [%s], pdu=%u, tag=%lx\n", + fio_server_op(cmd->opcode), cmd->pdu_len, cmd->tag); switch (cmd->opcode) { case FIO_NET_CMD_QUIT: @@ -395,7 +473,7 @@ static int handle_command(struct fio_net_cmd *cmd) ret = handle_send_eta_cmd(cmd); break; default: - log_err("fio: unknown opcode: %d\n", cmd->opcode); + log_err("fio: unknown opcode: %s\n",fio_server_op(cmd->opcode)); ret = 1; } @@ -519,12 +597,12 @@ out: return exitval; } -int fio_server_text_output(const char *buf, unsigned int len) +int fio_server_text_output(const char *buf, size_t len) { if (server_fd != -1) return fio_net_send_cmd(server_fd, FIO_NET_CMD_TEXT, buf, len, 0); - return fwrite(buf, len, 1, f_err); + return log_local_buf(buf, len); } static void convert_io_stat(struct io_stat *dst, struct io_stat *src) @@ -594,9 +672,10 @@ void fio_server_send_ts(struct thread_stat *ts, struct group_run_stats *rs) p.ts.clat_percentiles = cpu_to_le64(ts->clat_percentiles); for (i = 0; i < FIO_IO_U_LIST_MAX_LEN; i++) { - fio_fp64_t *fp = &p.ts.percentile_list[i]; + fio_fp64_t *src = &ts->percentile_list[i]; + fio_fp64_t *dst = &p.ts.percentile_list[i]; - fp->u.i = __cpu_to_le64(fio_double_to_uint64(fp->u.f)); + dst->u.i = __cpu_to_le64(fio_double_to_uint64(src->u.f)); } for (i = 0; i < FIO_IO_U_MAP_NR; i++) { @@ -648,6 +727,61 @@ void fio_server_send_gs(struct group_run_stats *rs) fio_net_send_cmd(server_fd, FIO_NET_CMD_GS, &gs, sizeof(gs), 0); } +static void convert_agg(struct disk_util_agg *dst, struct disk_util_agg *src) +{ + int i; + + for (i = 0; i < 2; i++) { + dst->ios[i] = cpu_to_le32(src->ios[i]); + dst->merges[i] = cpu_to_le32(src->merges[i]); + dst->sectors[i] = cpu_to_le64(src->sectors[i]); + dst->ticks[i] = cpu_to_le32(src->ticks[i]); + } + + dst->io_ticks = cpu_to_le32(src->io_ticks); + dst->time_in_queue = cpu_to_le32(src->time_in_queue); + dst->slavecount = cpu_to_le32(src->slavecount); + dst->max_util.u.i = __cpu_to_le64(fio_double_to_uint64(src->max_util.u.f)); +} + +static void convert_dus(struct disk_util_stat *dst, struct disk_util_stat *src) +{ + int i; + + strcpy((char *) dst->name, (char *) src->name); + + for (i = 0; i < 2; i++) { + dst->ios[i] = cpu_to_le32(src->ios[i]); + dst->merges[i] = cpu_to_le32(src->merges[i]); + dst->sectors[i] = cpu_to_le64(src->sectors[i]); + dst->ticks[i] = cpu_to_le32(src->ticks[i]); + } + + dst->io_ticks = cpu_to_le32(src->io_ticks); + dst->time_in_queue = cpu_to_le32(src->time_in_queue); + dst->msec = cpu_to_le64(src->msec); +} + +void fio_server_send_du(void) +{ + struct disk_util *du; + struct flist_head *entry; + struct cmd_du_pdu pdu; + + dprint(FD_NET, "server: sending disk_util %d\n", !flist_empty(&disk_list)); + + memset(&pdu, 0, sizeof(pdu)); + + flist_for_each(entry, &disk_list) { + du = flist_entry(entry, struct disk_util, list); + + convert_dus(&pdu.dus, &du->dus); + convert_agg(&pdu.agg, &du->agg); + + fio_net_send_cmd(server_fd, FIO_NET_CMD_DU, &pdu, sizeof(pdu), 0); + } +} + int fio_server_log(const char *format, ...) { char buffer[1024]; @@ -752,7 +886,7 @@ static int fio_init_server_connection(void) log_info("fio: server listening on %s\n", bind_str); - if (listen(sk, 1) < 0) { + if (listen(sk, 0) < 0) { log_err("fio: listen: %s\n", strerror(errno)); return -1; } @@ -897,52 +1031,101 @@ static int fio_server(void) return ret; } -static void sig_int(int sig) +void fio_server_got_signal(int signal) +{ + if (signal == SIGPIPE) + server_fd = -1; + else { + log_info("\nfio: terminating on signal %d\n", signal); + exit_backend = 1; + } +} + +static int check_existing_pidfile(const char *pidfile) { - fio_terminate_threads(TERMINATE_ALL); - exit_backend = 1; + struct stat sb; + char buf[16]; + pid_t pid; + FILE *f; + + if (stat(pidfile, &sb)) + return 0; + + f = fopen(pidfile, "r"); + if (!f) + return 0; + + if (fread(buf, sb.st_size, 1, f) <= 0) { + fclose(f); + return 1; + } + fclose(f); + + pid = atoi(buf); + if (kill(pid, SIGCONT) < 0) + return errno != ESRCH; + + return 1; } -static void server_signal_handler(void) +static int write_pid(pid_t pid, const char *pidfile) { - struct sigaction act; + FILE *fpid; - memset(&act, 0, sizeof(act)); - act.sa_handler = sig_int; - act.sa_flags = SA_RESTART; - sigaction(SIGINT, &act, NULL); + fpid = fopen(pidfile, "w"); + if (!fpid) { + log_err("fio: failed opening pid file %s\n", pidfile); + return 1; + } - memset(&act, 0, sizeof(act)); - act.sa_handler = sig_int; - act.sa_flags = SA_RESTART; - sigaction(SIGTERM, &act, NULL); + fprintf(fpid, "%u\n", (unsigned int) pid); + fclose(fpid); + return 0; } -int fio_start_server(int daemonize) +/* + * If pidfile is specified, background us. + */ +int fio_start_server(char *pidfile) { pid_t pid; + int ret; - server_signal_handler(); - - if (!daemonize) + if (!pidfile) return fio_server(); - openlog("fio", LOG_NDELAY|LOG_NOWAIT|LOG_PID, LOG_USER); + if (check_existing_pidfile(pidfile)) { + log_err("fio: pidfile %s exists and server appears alive\n", + pidfile); + return -1; + } + pid = fork(); if (pid < 0) { - syslog(LOG_ERR, "failed server fork"); + log_err("fio: failed server fork: %s", strerror(errno)); + free(pidfile); return -1; - } else if (pid) - exit(0); + } else if (pid) { + int ret = write_pid(pid, pidfile); + + exit(ret); + } setsid(); + openlog("fio", LOG_NDELAY|LOG_NOWAIT|LOG_PID, LOG_USER); + log_syslog = 1; close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO); f_out = NULL; f_err = NULL; - log_syslog = 1; - return fio_server(); + + ret = fio_server(); + + closelog(); + unlink(pidfile); + free(pidfile); + return ret; } void fio_server_set_arg(const char *arg)