X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=client.c;h=7975ce606c4c978a48ecbe304c1317213e6725f6;hp=a9b63e2a66e38b4dc6e313c80ad8a89c3c428ca0;hb=3e260a46ea9a8de224c3d0a29a608da3440f284a;hpb=14ea90edf265aae2b82f25418fde179c452909f9 diff --git a/client.c b/client.c index a9b63e2a..7975ce60 100644 --- a/client.c +++ b/client.c @@ -14,7 +14,9 @@ #include #include #include +#ifdef CONFIG_ZLIB #include +#endif #include "fio.h" #include "client.h" @@ -55,6 +57,10 @@ struct group_run_stats client_gs; int sum_stat_clients; static int sum_stat_nr; +static struct json_object *root = NULL; +static struct json_array *clients_array = NULL; +static struct json_array *du_array = NULL; +static int do_output_all_clients; #define FIO_CLIENT_HASH_BITS 7 #define FIO_CLIENT_HASH_SZ (1 << FIO_CLIENT_HASH_BITS) @@ -83,6 +89,30 @@ static void fio_init fio_client_hash_init(void) INIT_FLIST_HEAD(&client_hash[i]); } +static void fio_client_json_init(void) +{ + if (output_format != FIO_OUTPUT_JSON) + return; + root = json_create_object(); + json_object_add_value_string(root, "fio version", fio_version_string); + clients_array = json_create_array(); + json_object_add_value_array(root, "client_stats", clients_array); + du_array = json_create_array(); + json_object_add_value_array(root, "disk_util", du_array); +} + +static void fio_client_json_fini(void) +{ + if (output_format != FIO_OUTPUT_JSON) + return; + json_print_object(root); + log_info("\n"); + json_free_object(root); + root = NULL; + clients_array = NULL; + du_array = NULL; +} + static struct fio_client *find_client_by_fd(int fd) { int bucket = hash_long(fd, FIO_CLIENT_HASH_BITS) & FIO_CLIENT_HASH_MASK; @@ -116,6 +146,9 @@ void fio_put_client(struct fio_client *client) if (client->ini_file) free(client->ini_file); + if (!client->did_stat) + sum_stat_clients -= client->nr_stat; + free(client); } @@ -142,8 +175,6 @@ static void remove_client(struct fio_client *client) client->ops->removed(client); nr_clients--; - sum_stat_clients--; - fio_put_client(client); } @@ -294,15 +325,24 @@ int fio_client_add(struct client_ops *ops, const char *hostname, void **cookie) static void probe_client(struct fio_client *client) { + struct cmd_client_probe_pdu pdu; + uint64_t tag; + dprint(FD_NET, "client: send probe\n"); - fio_net_send_simple_cmd(client->fd, FIO_NET_CMD_PROBE, 0, &client->cmd_list); +#ifdef CONFIG_ZLIB + pdu.flags = __le64_to_cpu(FIO_PROBE_FLAG_ZLIB); +#else + pdu.flags = 0; +#endif + + fio_net_send_cmd(client->fd, FIO_NET_CMD_PROBE, &pdu, sizeof(pdu), &tag, &client->cmd_list); } static int fio_client_connect_ip(struct fio_client *client) { struct sockaddr *addr; - fio_socklen_t socklen; + socklen_t socklen; int fd, domain; if (client->ipv6) { @@ -343,7 +383,7 @@ static int fio_client_connect_ip(struct fio_client *client) static int fio_client_connect_sock(struct fio_client *client) { struct sockaddr_un *addr = &client->addr_un; - fio_socklen_t len; + socklen_t len; int fd; memset(addr, 0, sizeof(*addr)); @@ -437,6 +477,14 @@ static void client_signal_handler(void) act.sa_flags = SA_RESTART; sigaction(SIGTERM, &act, NULL); +/* Windows uses SIGBREAK as a quit signal from other applications */ +#ifdef WIN32 + memset(&act, 0, sizeof(act)); + act.sa_handler = sig_int; + act.sa_flags = SA_RESTART; + sigaction(SIGBREAK, &act, NULL); +#endif + memset(&act, 0, sizeof(act)); act.sa_handler = sig_show_status; act.sa_flags = SA_RESTART; @@ -536,6 +584,8 @@ int fio_start_all_clients(void) dprint(FD_NET, "client: start all\n"); + fio_client_json_init(); + flist_for_each_safe(entry, tmp, &client_list) { client = flist_entry(entry, struct fio_client, list); @@ -604,7 +654,7 @@ static int __fio_client_send_ini(struct fio_client *client, const char *filename if (len) { log_err("fio: failed reading job file %s\n", filename); close(fd); - free(buf); + free(pdu); return 1; } @@ -663,7 +713,7 @@ int fio_client_update_options(struct fio_client *client, pdu.thread_number = cpu_to_le32(client->thread_number); pdu.groupid = cpu_to_le32(client->groupid); convert_thread_options_to_net(&pdu.top, o); - + return fio_net_send_cmd(client->fd, FIO_NET_CMD_UPDATE_JOB, &pdu, sizeof(pdu), tag, &client->cmd_list); } @@ -689,8 +739,9 @@ static void convert_ts(struct thread_stat *dst, struct thread_stat *src) dst->groupid = le32_to_cpu(src->groupid); dst->pid = le32_to_cpu(src->pid); dst->members = le32_to_cpu(src->members); + dst->unified_rw_rep = le32_to_cpu(src->unified_rw_rep); - for (i = 0; i < 2; i++) { + for (i = 0; i < DDIR_RWDIR_CNT; i++) { convert_io_stat(&dst->clat_stat[i], &src->clat_stat[i]); convert_io_stat(&dst->slat_stat[i], &src->slat_stat[i]); convert_io_stat(&dst->lat_stat[i], &src->lat_stat[i]); @@ -722,11 +773,11 @@ static void convert_ts(struct thread_stat *dst, struct thread_stat *src) dst->io_u_lat_m[i] = le32_to_cpu(src->io_u_lat_m[i]); } - for (i = 0; i < 2; i++) + for (i = 0; i < DDIR_RWDIR_CNT; i++) for (j = 0; j < FIO_IO_U_PLAT_NR; j++) dst->io_u_plat[i][j] = le32_to_cpu(src->io_u_plat[i][j]); - for (i = 0; i < 3; i++) { + for (i = 0; i < DDIR_RWDIR_CNT; i++) { dst->total_io_u[i] = le64_to_cpu(src->total_io_u[i]); dst->short_io_u[i] = le64_to_cpu(src->short_io_u[i]); } @@ -734,7 +785,7 @@ static void convert_ts(struct thread_stat *dst, struct thread_stat *src) dst->total_submit = le64_to_cpu(src->total_submit); dst->total_complete = le64_to_cpu(src->total_complete); - for (i = 0; i < 2; i++) { + for (i = 0; i < DDIR_RWDIR_CNT; i++) { dst->io_bytes[i] = le64_to_cpu(src->io_bytes[i]); dst->runtime[i] = le64_to_cpu(src->runtime[i]); } @@ -744,13 +795,19 @@ static void convert_ts(struct thread_stat *dst, struct thread_stat *src) dst->total_err_count = le64_to_cpu(src->total_err_count); dst->first_error = le32_to_cpu(src->first_error); dst->kb_base = le32_to_cpu(src->kb_base); + dst->unit_base = le32_to_cpu(src->unit_base); + + dst->latency_depth = le32_to_cpu(src->latency_depth); + dst->latency_target = le64_to_cpu(src->latency_target); + dst->latency_window = le64_to_cpu(src->latency_window); + dst->latency_percentile.u.f = fio_uint64_to_double(le64_to_cpu(src->latency_percentile.u.i)); } static void convert_gs(struct group_run_stats *dst, struct group_run_stats *src) { int i; - for (i = 0; i < 2; i++) { + for (i = 0; i < DDIR_RWDIR_CNT; i++) { dst->max_run[i] = le64_to_cpu(src->max_run[i]); dst->min_run[i] = le64_to_cpu(src->min_run[i]); dst->max_bw[i] = le64_to_cpu(src->max_bw[i]); @@ -760,16 +817,31 @@ static void convert_gs(struct group_run_stats *dst, struct group_run_stats *src) } dst->kb_base = le32_to_cpu(src->kb_base); + dst->unit_base = le32_to_cpu(src->unit_base); dst->groupid = le32_to_cpu(src->groupid); + dst->unified_rw_rep = le32_to_cpu(src->unified_rw_rep); +} + +static void json_object_add_client_info(struct json_object *obj, +struct fio_client *client) +{ + json_object_add_value_string(obj, "hostname", client->hostname); + json_object_add_value_int(obj, "port", client->port); } static void handle_ts(struct fio_client *client, struct fio_net_cmd *cmd) { struct cmd_ts_pdu *p = (struct cmd_ts_pdu *) cmd->payload; + struct json_object *tsobj; - show_thread_status(&p->ts, &p->rs); + tsobj = show_thread_status(&p->ts, &p->rs); + client->did_stat = 1; + if (tsobj) { + json_object_add_client_info(tsobj, client); + json_array_add_value_object(clients_array, tsobj); + } - if (sum_stat_clients == 1) + if (!do_output_all_clients) return; sum_thread_stats(&client_ts, &p->ts, sum_stat_nr); @@ -778,10 +850,15 @@ static void handle_ts(struct fio_client *client, struct fio_net_cmd *cmd) client_ts.members++; client_ts.thread_number = p->ts.thread_number; client_ts.groupid = p->ts.groupid; + client_ts.unified_rw_rep = p->ts.unified_rw_rep; if (++sum_stat_nr == sum_stat_clients) { strcpy(client_ts.name, "All clients"); - show_thread_status(&client_ts, &client_gs); + tsobj = show_thread_status(&client_ts, &client_gs); + if (tsobj) { + json_object_add_client_info(tsobj, client); + json_array_add_value_object(clients_array, tsobj); + } } } @@ -850,7 +927,13 @@ static void handle_du(struct fio_client *client, struct fio_net_cmd *cmd) log_info("\nDisk stats (read/write):\n"); } - print_disk_util(&du->dus, &du->agg, terse_output); + if (output_format == FIO_OUTPUT_JSON) { + struct json_object *duobj; + json_array_add_disk_util(&du->dus, &du->agg, du_array); + duobj = json_array_last_value_object(du_array); + json_object_add_client_info(duobj, client); + } else + print_disk_util(&du->dus, &du->agg, output_format == FIO_OUTPUT_TERSE); } static void convert_jobs_eta(struct jobs_eta *je) @@ -860,13 +943,14 @@ static void convert_jobs_eta(struct jobs_eta *je) je->nr_running = le32_to_cpu(je->nr_running); je->nr_ramp = le32_to_cpu(je->nr_ramp); je->nr_pending = le32_to_cpu(je->nr_pending); + je->nr_setting_up = le32_to_cpu(je->nr_setting_up); je->files_open = le32_to_cpu(je->files_open); - for (i = 0; i < 2; i++) { - je->m_rate[i] = le32_to_cpu(je->m_rate[i]); - je->t_rate[i] = le32_to_cpu(je->t_rate[i]); - je->m_iops[i] = le32_to_cpu(je->m_iops[i]); - je->t_iops[i] = le32_to_cpu(je->t_iops[i]); + for (i = 0; i < DDIR_RWDIR_CNT; i++) { + je->m_rate[i] = le32_to_cpu(je->m_rate[i]); + je->t_rate[i] = le32_to_cpu(je->t_rate[i]); + je->m_iops[i] = le32_to_cpu(je->m_iops[i]); + je->t_iops[i] = le32_to_cpu(je->t_iops[i]); je->rate[i] = le32_to_cpu(je->rate[i]); je->iops[i] = le32_to_cpu(je->iops[i]); } @@ -875,6 +959,7 @@ static void convert_jobs_eta(struct jobs_eta *je) je->eta_sec = le64_to_cpu(je->eta_sec); je->nr_threads = le32_to_cpu(je->nr_threads); je->is_pow2 = le32_to_cpu(je->is_pow2); + je->unit_base = le32_to_cpu(je->unit_base); } void fio_client_sum_jobs_eta(struct jobs_eta *dst, struct jobs_eta *je) @@ -884,9 +969,10 @@ void fio_client_sum_jobs_eta(struct jobs_eta *dst, struct jobs_eta *je) dst->nr_running += je->nr_running; dst->nr_ramp += je->nr_ramp; dst->nr_pending += je->nr_pending; + dst->nr_setting_up += je->nr_setting_up; dst->files_open += je->files_open; - for (i = 0; i < 2; i++) { + for (i = 0; i < DDIR_RWDIR_CNT; i++) { dst->m_rate[i] += je->m_rate[i]; dst->t_rate[i] += je->t_rate[i]; dst->m_iops[i] += je->m_iops[i]; @@ -927,7 +1013,7 @@ static void remove_reply_cmd(struct fio_client *client, struct fio_net_cmd *cmd) } if (!reply) { - log_err("fio: client: unable to find matching tag (%lx)\n", cmd->tag); + log_err("fio: client: unable to find matching tag (%llx)\n", (unsigned long long) cmd->tag); return; } @@ -981,7 +1067,7 @@ static void handle_eta(struct fio_client *client, struct fio_net_cmd *cmd) static void handle_probe(struct fio_client *client, struct fio_net_cmd *cmd) { - struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload; + struct cmd_probe_reply_pdu *probe = (struct cmd_probe_reply_pdu *) cmd->payload; const char *os, *arch; char bit[16]; @@ -994,10 +1080,11 @@ static void handle_probe(struct fio_client *client, struct fio_net_cmd *cmd) os = "unknown"; sprintf(bit, "%d-bit", probe->bpp * 8); + probe->flags = le64_to_cpu(probe->flags); - log_info("hostname=%s, be=%u, %s, os=%s, arch=%s, fio=%s\n", + log_info("hostname=%s, be=%u, %s, os=%s, arch=%s, fio=%s, flags=%lx\n", probe->hostname, probe->bigendian, bit, os, arch, - probe->fio_version); + probe->fio_version, (unsigned long) probe->flags); if (!client->name) client->name = strdup((char *) probe->hostname); @@ -1008,7 +1095,13 @@ static void handle_start(struct fio_client *client, struct fio_net_cmd *cmd) struct cmd_start_pdu *pdu = (struct cmd_start_pdu *) cmd->payload; client->state = Client_started; - client->jobs = pdu->jobs; + client->jobs = le32_to_cpu(pdu->jobs); + client->nr_stat = le32_to_cpu(pdu->stat_outputs); + + if (sum_stat_clients > 1) + do_output_all_clients = 1; + + sum_stat_clients += client->nr_stat; } static void handle_stop(struct fio_client *client, struct fio_net_cmd *cmd) @@ -1034,19 +1127,15 @@ static void convert_text(struct fio_net_cmd *cmd) pdu->log_usec = le64_to_cpu(pdu->log_usec); } -/* - * This has been compressed on the server side, since it can be big. - * Uncompress here. - */ -static struct cmd_iolog_pdu *convert_iolog(struct fio_net_cmd *cmd) +static struct cmd_iolog_pdu *convert_iolog_gz(struct fio_net_cmd *cmd, + struct cmd_iolog_pdu *pdu) { - struct cmd_iolog_pdu *pdu = (struct cmd_iolog_pdu *) cmd->payload; +#ifdef CONFIG_ZLIB struct cmd_iolog_pdu *ret; - uint32_t nr_samples; - unsigned long total; z_stream stream; + uint32_t nr_samples; + size_t total; void *p; - int i; stream.zalloc = Z_NULL; stream.zfree = Z_NULL; @@ -1064,10 +1153,9 @@ static struct cmd_iolog_pdu *convert_iolog(struct fio_net_cmd *cmd) total = nr_samples * sizeof(struct io_sample); ret = malloc(total + sizeof(*pdu)); - ret->thread_number = le32_to_cpu(pdu->thread_number); ret->nr_samples = nr_samples; - ret->log_type = le32_to_cpu(pdu->log_type); - strcpy((char *) ret->name, (char *) pdu->name); + + memcpy(ret, pdu, sizeof(*pdu)); p = (void *) ret + sizeof(*pdu); @@ -1089,7 +1177,7 @@ static struct cmd_iolog_pdu *convert_iolog(struct fio_net_cmd *cmd) log_err("fio: inflate error %d\n", err); free(ret); ret = NULL; - goto out; + goto err; } this_len = this_chunk - stream.avail_out; @@ -1097,6 +1185,46 @@ static struct cmd_iolog_pdu *convert_iolog(struct fio_net_cmd *cmd) total -= this_len; } +err: + inflateEnd(&stream); + return ret; +#else + return NULL; +#endif +} + +/* + * This has been compressed on the server side, since it can be big. + * Uncompress here. + */ +static struct cmd_iolog_pdu *convert_iolog(struct fio_net_cmd *cmd) +{ + struct cmd_iolog_pdu *pdu = (struct cmd_iolog_pdu *) cmd->payload; + struct cmd_iolog_pdu *ret; + int i; + + /* + * Convert if compressed and we support it. If it's not + * compressed, we need not do anything. + */ + if (le32_to_cpu(pdu->compressed)) { +#ifndef CONFIG_ZLIB + log_err("fio: server sent compressed data by mistake\n"); + return NULL; +#endif + ret = convert_iolog_gz(cmd, pdu); + if (!ret) { + log_err("fio: failed decompressing log\n"); + return NULL; + } + } else + ret = pdu; + + ret->thread_number = le32_to_cpu(ret->thread_number); + ret->nr_samples = le32_to_cpu(ret->nr_samples); + ret->log_type = le32_to_cpu(ret->log_type); + ret->compressed = le32_to_cpu(ret->compressed); + for (i = 0; i < ret->nr_samples; i++) { struct io_sample *s = &ret->samples[i]; @@ -1106,8 +1234,6 @@ static struct cmd_iolog_pdu *convert_iolog(struct fio_net_cmd *cmd) s->bs = le32_to_cpu(s->bs); } -out: - inflateEnd(&stream); return ret; } @@ -1305,7 +1431,7 @@ static int fio_check_clients_timed_out(void) struct timeval tv; int ret = 0; - gettimeofday(&tv, NULL); + fio_gettime(&tv, NULL); flist_for_each_safe(entry, tmp, &client_list) { client = flist_entry(entry, struct fio_client, list); @@ -1333,11 +1459,10 @@ int fio_handle_clients(struct client_ops *ops) struct pollfd *pfds; int i, ret = 0, retval = 0; - gettimeofday(&eta_tv, NULL); + fio_gettime(&eta_tv, NULL); pfds = malloc(nr_clients * sizeof(struct pollfd)); - sum_stat_clients = nr_clients; init_thread_stat(&client_ts); init_group_run_stat(&client_gs); @@ -1368,8 +1493,8 @@ int fio_handle_clients(struct client_ops *ops) do { struct timeval tv; - gettimeofday(&tv, NULL); - if (mtime_since(&eta_tv, &tv) >= ops->eta_msec) { + fio_gettime(&tv, NULL); + if (mtime_since(&eta_tv, &tv) >= 900) { request_client_etas(ops); memcpy(&eta_tv, &tv, sizeof(tv)); @@ -1393,7 +1518,7 @@ int fio_handle_clients(struct client_ops *ops) client = find_client_by_fd(pfds[i].fd); if (!client) { - log_err("fio: unknown client fd %d\n", pfds[i].fd); + log_err("fio: unknown client fd %ld\n", (long) pfds[i].fd); continue; } if (!fio_handle_client(client)) { @@ -1407,6 +1532,8 @@ int fio_handle_clients(struct client_ops *ops) } } + fio_client_json_fini(); + free(pfds); return retval; }