#include <arpa/inet.h>
#include <netdb.h>
#include <signal.h>
+#ifdef CONFIG_ZLIB
#include <zlib.h>
+#endif
#include "fio.h"
#include "client.h"
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
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;
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)
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);
if (len) {
log_err("fio: failed reading job file %s\n", filename);
close(fd);
- free(buf);
+ free(pdu);
return 1;
}
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);
}
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 (!do_output_all_clients)
return;
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);
+ }
}
}
log_info("\nDisk stats (read/write):\n");
}
- print_disk_util(&du->dus, &du->agg, output_format == FIO_OUTPUT_TERSE);
+ 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)
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 < DDIR_RWDIR_CNT; 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]);
}
je->elapsed_sec = le64_to_cpu(je->elapsed_sec);
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);
+ je->unit_base = le32_to_cpu(je->unit_base);
}
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 < DDIR_RWDIR_CNT; i++) {
dst->t_rate[i] += je->t_rate[i];
dst->m_iops[i] += je->m_iops[i];
dst->t_iops[i] += je->t_iops[i];
+ dst->rate[i] += je->rate[i];
+ dst->iops[i] += je->iops[i];
}
dst->elapsed_sec += je->elapsed_sec;
}
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;
}
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];
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);
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;
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);
log_err("fio: inflate error %d\n", err);
free(ret);
ret = NULL;
- goto out;
+ goto err;
}
this_len = this_chunk - stream.avail_out;
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];
s->bs = le32_to_cpu(s->bs);
}
-out:
- inflateEnd(&stream);
return ret;
}
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)) {
}
}
+ fio_client_json_fini();
+
free(pfds);
return retval;
}
projects / fio.git / blobdiff