X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=server.c;h=89422e96781dae80cd0fad5ec2ed473691820376;hp=2e8682c999cc395f0af45ab67723d40459735484;hb=46bcd498f7b3fb55f7f048bf299f36bd8c8f7db1;hpb=5adc2447a8d52322981da4cd364a560bbd9d8351 diff --git a/server.c b/server.c index 2e8682c9..89422e96 100644 --- a/server.c +++ b/server.c @@ -51,7 +51,9 @@ static const char *fio_server_ops[FIO_NET_CMD_NR] = { "START", "STOP", "DISK_UTIL", - "RUN", + "SERVER_START", + "ADD_JOB", + "CMD_RUN" }; const char *fio_server_op(unsigned int op) @@ -67,7 +69,7 @@ const char *fio_server_op(unsigned int op) int fio_send_data(int sk, const void *p, unsigned int len) { - assert(len <= sizeof(struct fio_net_cmd) + FIO_SERVER_MAX_PDU); + assert(len <= sizeof(struct fio_net_cmd) + FIO_SERVER_MAX_FRAGMENT_PDU); do { int ret = send(sk, p, len, 0); @@ -89,6 +91,9 @@ int fio_send_data(int sk, const void *p, unsigned int len) if (!len) return 0; + if (errno) + return -errno; + return 1; } @@ -124,7 +129,7 @@ static int verify_convert_cmd(struct fio_net_cmd *cmd) cmd->cmd_crc16 = le16_to_cpu(cmd->cmd_crc16); cmd->pdu_crc16 = le16_to_cpu(cmd->pdu_crc16); - crc = crc16(cmd, FIO_NET_CMD_CRC_SZ); + crc = fio_crc16(cmd, FIO_NET_CMD_CRC_SZ); if (crc != cmd->cmd_crc16) { log_err("fio: server bad crc on command (got %x, wanted %x)\n", cmd->cmd_crc16, crc); @@ -145,7 +150,7 @@ static int verify_convert_cmd(struct fio_net_cmd *cmd) return 1; } - if (cmd->pdu_len > FIO_SERVER_MAX_PDU) { + if (cmd->pdu_len > FIO_SERVER_MAX_FRAGMENT_PDU) { log_err("fio: command payload too large: %u\n", cmd->pdu_len); return 1; } @@ -202,7 +207,7 @@ struct fio_net_cmd *fio_net_recv_cmd(int sk) break; /* Verify payload crc */ - crc = crc16(pdu, cmd.pdu_len); + crc = fio_crc16(pdu, cmd.pdu_len); if (crc != cmd.pdu_crc16) { log_err("fio: server bad crc on payload "); log_err("(got %x, wanted %x)\n", cmd.pdu_crc16, crc); @@ -221,12 +226,21 @@ struct fio_net_cmd *fio_net_recv_cmd(int sk) cmdret = NULL; } else if (cmdret) { /* zero-terminate text input */ - if (cmdret->pdu_len && (cmdret->opcode == FIO_NET_CMD_TEXT || - cmdret->opcode == FIO_NET_CMD_JOB)) { - char *buf = (char *) cmdret->payload; - - buf[cmdret->pdu_len ] = '\0'; + if (cmdret->pdu_len) { + if (cmdret->opcode == FIO_NET_CMD_TEXT) { + struct cmd_text_pdu *pdu = (struct cmd_text_pdu *) cmdret->payload; + char *buf = (char *) pdu->buf; + + buf[pdu->buf_len ] = '\0'; + } else if (cmdret->opcode == FIO_NET_CMD_JOB) { + struct cmd_job_pdu *pdu = (struct cmd_job_pdu *) cmdret->payload; + char *buf = (char *) pdu->buf; + int len = le32_to_cpu(pdu->buf_len); + + buf[len] = '\0'; + } } + /* frag flag is internal */ cmdret->flags &= ~FIO_NET_CMD_F_MORE; } @@ -238,11 +252,11 @@ void fio_net_cmd_crc(struct fio_net_cmd *cmd) { uint32_t pdu_len; - cmd->cmd_crc16 = __cpu_to_le16(crc16(cmd, FIO_NET_CMD_CRC_SZ)); + cmd->cmd_crc16 = __cpu_to_le16(fio_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(fio_crc16(cmd->payload, pdu_len)); } int fio_net_send_cmd(int fd, uint16_t opcode, const void *buf, off_t size, @@ -254,8 +268,8 @@ int fio_net_send_cmd(int fd, uint16_t opcode, const void *buf, off_t size, do { this_len = size; - if (this_len > FIO_SERVER_MAX_PDU) - this_len = FIO_SERVER_MAX_PDU; + if (this_len > FIO_SERVER_MAX_FRAGMENT_PDU) + this_len = FIO_SERVER_MAX_FRAGMENT_PDU; if (!cmd || cur_len < sizeof(*cmd) + this_len) { if (cmd) @@ -331,21 +345,11 @@ static int fio_server_send_quit_cmd(void) return fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_QUIT, 0, NULL); } -static int handle_job_cmd(struct fio_net_cmd *cmd) +static int handle_run_cmd(struct fio_net_cmd *cmd) { - char *buf = (char *) cmd->payload; - struct cmd_start_pdu spdu; struct cmd_end_pdu epdu; int ret; - if (parse_jobs_ini(buf, 1, 0)) { - fio_server_send_quit_cmd(); - return -1; - } - - spdu.jobs = cpu_to_le32(thread_number); - fio_net_send_cmd(server_fd, FIO_NET_CMD_START, &spdu, sizeof(spdu), 0); - ret = fio_backend(); epdu.error = ret; @@ -353,20 +357,42 @@ static int handle_job_cmd(struct fio_net_cmd *cmd) fio_server_send_quit_cmd(); reset_fio_state(); + first_cmd_check = 0; return ret; } +static int handle_job_cmd(struct fio_net_cmd *cmd) +{ + struct cmd_job_pdu *pdu = (struct cmd_job_pdu *) cmd->payload; + void *buf = pdu->buf; + struct cmd_start_pdu spdu; + + pdu->buf_len = le32_to_cpu(pdu->buf_len); + pdu->client_type = le32_to_cpu(pdu->client_type); + + if (parse_jobs_ini(buf, 1, 0, pdu->client_type)) { + fio_server_send_quit_cmd(); + return -1; + } + + spdu.jobs = cpu_to_le32(thread_number); + fio_net_send_cmd(server_fd, FIO_NET_CMD_START, &spdu, sizeof(spdu), 0); + return 0; +} + static int handle_jobline_cmd(struct fio_net_cmd *cmd) { void *pdu = cmd->payload; struct cmd_single_line_pdu *cslp; struct cmd_line_pdu *clp; unsigned long offset; + struct cmd_start_pdu spdu; char **argv; - int ret, i; + int i; clp = pdu; clp->lines = le16_to_cpu(clp->lines); + clp->client_type = le16_to_cpu(clp->client_type); argv = malloc(clp->lines * sizeof(char *)); offset = sizeof(*clp); @@ -380,7 +406,7 @@ static int handle_jobline_cmd(struct fio_net_cmd *cmd) dprint(FD_NET, "server: %d: %s\n", i, argv[i]); } - if (parse_cmd_line(clp->lines, argv)) { + if (parse_cmd_line(clp->lines, argv, clp->client_type)) { fio_server_send_quit_cmd(); free(argv); return -1; @@ -388,12 +414,9 @@ static int handle_jobline_cmd(struct fio_net_cmd *cmd) free(argv); - fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_START, 0, NULL); - - ret = fio_backend(); - fio_server_send_quit_cmd(); - reset_fio_state(); - return ret; + spdu.jobs = cpu_to_le32(thread_number); + fio_net_send_cmd(server_fd, FIO_NET_CMD_START, &spdu, sizeof(spdu), 0); + return 0; } static int handle_probe_cmd(struct fio_net_cmd *cmd) @@ -443,18 +466,19 @@ static int handle_send_eta_cmd(struct fio_net_cmd *cmd) 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->m_rate[i] = cpu_to_le32(je->m_rate[i]); + je->t_rate[i] = cpu_to_le32(je->t_rate[i]); + je->m_iops[i] = cpu_to_le32(je->m_iops[i]); + je->t_iops[i] = cpu_to_le32(je->t_iops[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->elapsed_sec = cpu_to_le64(je->elapsed_sec); je->eta_sec = cpu_to_le64(je->eta_sec); + je->nr_threads = cpu_to_le32(je->nr_threads); fio_net_send_cmd(server_fd, FIO_NET_CMD_ETA, je, size, cmd->tag); free(je); @@ -487,6 +511,9 @@ static int handle_command(struct fio_net_cmd *cmd) case FIO_NET_CMD_SEND_ETA: ret = handle_send_eta_cmd(cmd); break; + case FIO_NET_CMD_RUN: + ret = handle_run_cmd(cmd); + break; default: log_err("fio: unknown opcode: %s\n",fio_server_op(cmd->opcode)); ret = 1; @@ -554,8 +581,10 @@ static int handle_connection(int sk, int block) void fio_server_idle_loop(void) { - if (!first_cmd_check) - fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_RUN, 0, NULL); + if (!first_cmd_check) { + fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_SERVER_START, 0, NULL); + first_cmd_check = 1; + } if (server_fd != -1) handle_connection(server_fd, 0); } @@ -614,12 +643,30 @@ out: return exitval; } -int fio_server_text_output(const char *buf, size_t len) +int fio_server_text_output(int level, const char *buf, size_t len) { - if (server_fd != -1) - return fio_net_send_cmd(server_fd, FIO_NET_CMD_TEXT, buf, len, 0); + struct cmd_text_pdu *pdu; + unsigned int tlen; + struct timeval tv; + + if (server_fd == -1) + return log_local_buf(buf, len); + + tlen = sizeof(*pdu) + len; + pdu = malloc(tlen); - return log_local_buf(buf, len); + pdu->level = __cpu_to_le32(level); + pdu->buf_len = __cpu_to_le32(len); + + gettimeofday(&tv, NULL); + pdu->log_sec = __cpu_to_le64(tv.tv_sec); + pdu->log_usec = __cpu_to_le64(tv.tv_usec); + + memcpy(pdu->buf, buf, len); + + fio_net_send_cmd(server_fd, FIO_NET_CMD_TEXT, pdu, tlen, 0); + free(pdu); + return len; } static void convert_io_stat(struct io_stat *dst, struct io_stat *src) @@ -799,19 +846,13 @@ void fio_server_send_du(void) } } -int fio_server_log(const char *format, ...) +void fio_server_send_add_job(struct thread_options *o, const char *ioengine) { - char buffer[1024]; - va_list args; - size_t len; - - dprint(FD_NET, "server log\n"); + struct cmd_add_job_pdu pdu; - va_start(args, format); - len = vsnprintf(buffer, sizeof(buffer), format, args); - va_end(args); + convert_thread_options_to_net(&pdu.top, o); - return fio_server_text_output(buffer, len); + fio_net_send_cmd(server_fd, FIO_NET_CMD_ADD_JOB, &pdu, sizeof(pdu), 0); } static int fio_init_server_ip(void) @@ -943,6 +984,46 @@ static int fio_init_server_connection(void) return sk; } +int fio_server_parse_host(const char *host, int *ipv6, struct in_addr *inp, + struct in6_addr *inp6) + +{ + int ret = 0; + + if (*ipv6) + ret = inet_pton(AF_INET6, host, inp6); + else + ret = inet_pton(AF_INET, host, inp); + + if (ret != 1) { + struct hostent *hent; + + hent = gethostbyname(host); + if (!hent) { + log_err("fio: failed to resolve <%s>\n", host); + return 0; + } + + if (*ipv6) { + if (hent->h_addrtype != AF_INET6) { + log_info("fio: falling back to IPv4\n"); + *ipv6 = 0; + } else + memcpy(inp6, hent->h_addr_list[0], 16); + } + if (!*ipv6) { + if (hent->h_addrtype != AF_INET) { + log_err("fio: lookup type mismatch\n"); + return 0; + } + memcpy(inp, hent->h_addr_list[0], 4); + } + ret = 1; + } + + return !(ret == 1); +} + /* * Parse a host/ip/port string. Reads from 'str'. * @@ -961,7 +1042,7 @@ int fio_server_parse_string(const char *str, char **ptr, int *is_sock, { const char *host = str; char *portp; - int ret, lport = 0; + int lport = 0; *ptr = NULL; *is_sock = 0; @@ -1022,38 +1103,10 @@ int fio_server_parse_string(const char *str, char **ptr, int *is_sock, *ptr = strdup(host); - if (*ipv6) - ret = inet_pton(AF_INET6, host, inp6); - else - ret = inet_pton(AF_INET, host, inp); - - if (ret != 1) { - struct hostent *hent; - - hent = gethostbyname(host); - if (!hent) { - log_err("fio: failed to resolve <%s>\n", host); - free(*ptr); - *ptr = NULL; - return 1; - } - - if (*ipv6) { - if (hent->h_addrtype != AF_INET6) { - log_info("fio: falling back to IPv4\n"); - *ipv6 = 0; - } else - memcpy(inp6, hent->h_addr_list[0], 16); - } - if (!*ipv6) { - if (hent->h_addrtype != AF_INET) { - log_err("fio: lookup type mismatch\n"); - free(*ptr); - *ptr = NULL; - return 1; - } - memcpy(inp, hent->h_addr_list[0], 4); - } + if (fio_server_parse_host(*ptr, ipv6, inp, inp6)) { + free(*ptr); + *ptr = NULL; + return 1; } if (*port == 0) @@ -1188,8 +1241,8 @@ int fio_start_server(char *pidfile) int ret; #if defined(WIN32) - WSADATA wsd; - WSAStartup(MAKEWORD(2,2), &wsd); + WSADATA wsd; + WSAStartup(MAKEWORD(2,2), &wsd); #endif if (!pidfile)