Merge branch 'dev' of https://github.com/smartxworks/fio
[fio.git] / server.c
index f6f3441..23e549a 100644 (file)
--- a/server.c
+++ b/server.c
@@ -1,10 +1,8 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdarg.h>
 #include <unistd.h>
-#include <limits.h>
 #include <errno.h>
-#include <sys/poll.h>
+#include <poll.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <sys/socket.h>
 #include "server.h"
 #include "crc/crc16.h"
 #include "lib/ieee754.h"
-#include "verify.h"
+#include "verify-state.h"
 #include "smalloc.h"
 
 int fio_net_port = FIO_NET_PORT;
 
-int exit_backend = 0;
+bool exit_backend = false;
 
 enum {
        SK_F_FREE       = 1,
@@ -50,17 +48,6 @@ struct sk_entry {
        struct flist_head next; /* Other sk_entry's, if linked command */
 };
 
-struct sk_out {
-       unsigned int refs;      /* frees sk_out when it drops to zero.
-                                * protected by below ->lock */
-
-       int sk;                 /* socket fd to talk to client */
-       struct fio_mutex lock;  /* protects ref and below list */
-       struct flist_head list; /* list of pending transmit work */
-       struct fio_mutex wait;  /* wake backend when items added to list */
-       struct fio_mutex xmit;  /* held while sending data */
-};
-
 static char *fio_server_arg;
 static char *bind_sock;
 static struct sockaddr_in saddr_in;
@@ -85,7 +72,7 @@ struct fio_fork_item {
 };
 
 struct cmd_reply {
-       struct fio_mutex lock;
+       struct fio_sem lock;
        void *data;
        size_t size;
        int error;
@@ -114,16 +101,17 @@ static const char *fio_server_ops[FIO_NET_CMD_NR] = {
        "LOAD_FILE",
        "VTRIGGER",
        "SENDFILE",
+       "JOB_OPT",
 };
 
 static void sk_lock(struct sk_out *sk_out)
 {
-       fio_mutex_down(&sk_out->lock);
+       fio_sem_down(&sk_out->lock);
 }
 
 static void sk_unlock(struct sk_out *sk_out)
 {
-       fio_mutex_up(&sk_out->lock);
+       fio_sem_up(&sk_out->lock);
 }
 
 void sk_out_assign(struct sk_out *sk_out)
@@ -139,9 +127,9 @@ void sk_out_assign(struct sk_out *sk_out)
 
 static void sk_out_free(struct sk_out *sk_out)
 {
-       __fio_mutex_remove(&sk_out->lock);
-       __fio_mutex_remove(&sk_out->wait);
-       __fio_mutex_remove(&sk_out->xmit);
+       __fio_sem_remove(&sk_out->lock);
+       __fio_sem_remove(&sk_out->wait);
+       __fio_sem_remove(&sk_out->xmit);
        sfree(sk_out);
 }
 
@@ -262,14 +250,15 @@ static int fio_send_data(int sk, const void *p, unsigned int len)
        return fio_sendv_data(sk, &iov, 1);
 }
 
-static int fio_recv_data(int sk, void *p, unsigned int len, bool wait)
+static int fio_recv_data(int sk, void *buf, unsigned int len, bool wait)
 {
        int flags;
+       char *p = buf;
 
        if (wait)
                flags = MSG_WAITALL;
        else
-               flags = MSG_DONTWAIT;
+               flags = OS_MSG_DONTWAIT;
 
        do {
                int ret = recv(sk, p, len, flags);
@@ -307,6 +296,8 @@ static int verify_convert_cmd(struct fio_net_cmd *cmd)
        if (crc != cmd->cmd_crc16) {
                log_err("fio: server bad crc on command (got %x, wanted %x)\n",
                                cmd->cmd_crc16, crc);
+               fprintf(f_err, "fio: server bad crc on command (got %x, wanted %x)\n",
+                               cmd->cmd_crc16, crc);
                return 1;
        }
 
@@ -321,6 +312,8 @@ static int verify_convert_cmd(struct fio_net_cmd *cmd)
                break;
        default:
                log_err("fio: bad server cmd version %d\n", cmd->version);
+               fprintf(f_err, "fio: client/server version mismatch (%d != %d)\n",
+                               cmd->version, FIO_SERVER_VER);
                return 1;
        }
 
@@ -387,7 +380,7 @@ struct fio_net_cmd *fio_net_recv_cmd(int sk, bool wait)
                        break;
 
                /* There's payload, get it */
-               pdu = (void *) cmdret->payload + pdu_offset;
+               pdu = (char *) cmdret->payload + pdu_offset;
                ret = fio_recv_data(sk, pdu, cmd.pdu_len, wait);
                if (ret)
                        break;
@@ -448,7 +441,7 @@ static uint64_t alloc_reply(uint64_t tag, uint16_t opcode)
 
        reply = calloc(1, sizeof(*reply));
        INIT_FLIST_HEAD(&reply->list);
-       fio_gettime(&reply->tv, NULL);
+       fio_gettime(&reply->ts, NULL);
        reply->saved_tag = tag;
        reply->opcode = opcode;
 
@@ -537,6 +530,9 @@ static struct sk_entry *fio_net_prep_cmd(uint16_t opcode, void *buf,
        struct sk_entry *entry;
 
        entry = smalloc(sizeof(*entry));
+       if (!entry)
+               return NULL;
+
        INIT_FLIST_HEAD(&entry->next);
        entry->opcode = opcode;
        if (flags & SK_F_COPY) {
@@ -567,7 +563,7 @@ static void fio_net_queue_entry(struct sk_entry *entry)
                flist_add_tail(&entry->list, &sk_out->list);
                sk_unlock(sk_out);
 
-               fio_mutex_up(&sk_out->wait);
+               fio_sem_up(&sk_out->wait);
        }
 }
 
@@ -577,8 +573,12 @@ static int fio_net_queue_cmd(uint16_t opcode, void *buf, off_t size,
        struct sk_entry *entry;
 
        entry = fio_net_prep_cmd(opcode, buf, size, tagptr, flags);
-       fio_net_queue_entry(entry);
-       return 0;
+       if (entry) {
+               fio_net_queue_entry(entry);
+               return 0;
+       }
+
+       return 1;
 }
 
 static int fio_net_send_simple_stack_cmd(int sk, uint16_t opcode, uint64_t tag)
@@ -621,7 +621,7 @@ static int fio_net_queue_quit(void)
 {
        dprint(FD_NET, "server: sending quit\n");
 
-       return fio_net_queue_cmd(FIO_NET_CMD_QUIT, NULL, 0, 0, SK_F_SIMPLE);
+       return fio_net_queue_cmd(FIO_NET_CMD_QUIT, NULL, 0, NULL, SK_F_SIMPLE);
 }
 
 int fio_net_send_quit(int sk)
@@ -849,24 +849,23 @@ static int handle_jobline_cmd(struct fio_net_cmd *cmd)
 static int handle_probe_cmd(struct fio_net_cmd *cmd)
 {
        struct cmd_client_probe_pdu *pdu = (struct cmd_client_probe_pdu *) cmd->payload;
-       struct cmd_probe_reply_pdu probe;
        uint64_t tag = cmd->tag;
+       struct cmd_probe_reply_pdu probe = {
+#ifdef CONFIG_BIG_ENDIAN
+               .bigendian      = 1,
+#endif
+               .os             = FIO_OS,
+               .arch           = FIO_ARCH,
+               .bpp            = sizeof(void *),
+               .cpus           = __cpu_to_le32(cpus_online()),
+       };
 
        dprint(FD_NET, "server: sending probe reply\n");
 
        strcpy(me, (char *) pdu->server);
 
-       memset(&probe, 0, sizeof(probe));
        gethostname((char *) probe.hostname, sizeof(probe.hostname));
-#ifdef CONFIG_BIG_ENDIAN
-       probe.bigendian = 1;
-#endif
-       strncpy((char *) probe.fio_version, fio_version_string, sizeof(probe.fio_version));
-
-       probe.os        = FIO_OS;
-       probe.arch      = FIO_ARCH;
-       probe.bpp       = sizeof(void *);
-       probe.cpus      = __cpu_to_le32(cpus_online());
+       strncpy((char *) probe.fio_version, fio_version_string, sizeof(probe.fio_version) - 1);
 
        /*
         * If the client supports compression and we do too, then enable it
@@ -907,11 +906,11 @@ static int handle_send_eta_cmd(struct fio_net_cmd *cmd)
                je->files_open          = cpu_to_le32(je->files_open);
 
                for (i = 0; i < DDIR_RWDIR_CNT; 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_rate[i]   = cpu_to_le64(je->m_rate[i]);
+                       je->t_rate[i]   = cpu_to_le64(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->rate[i]     = cpu_to_le64(je->rate[i]);
                        je->iops[i]     = cpu_to_le32(je->iops[i]);
                }
 
@@ -956,7 +955,7 @@ static int handle_update_job_cmd(struct fio_net_cmd *cmd)
        return 0;
 }
 
-static int handle_trigger_cmd(struct fio_net_cmd *cmd)
+static int handle_trigger_cmd(struct fio_net_cmd *cmd, struct flist_head *job_list)
 {
        struct cmd_vtrigger_pdu *pdu = (struct cmd_vtrigger_pdu *) cmd->payload;
        char *buf = (char *) pdu->cmd;
@@ -971,10 +970,12 @@ static int handle_trigger_cmd(struct fio_net_cmd *cmd)
                struct all_io_list state;
 
                state.threads = cpu_to_le64((uint64_t) 0);
-               fio_net_queue_cmd(FIO_NET_CMD_VTRIGGER, &state, sizeof(state), NULL, SK_F_COPY);
+               fio_net_queue_cmd(FIO_NET_CMD_VTRIGGER, &state, sizeof(state), NULL, SK_F_COPY | SK_F_INLINE);
        } else
-               fio_net_queue_cmd(FIO_NET_CMD_VTRIGGER, rep, sz, NULL, SK_F_FREE);
+               fio_net_queue_cmd(FIO_NET_CMD_VTRIGGER, rep, sz, NULL, SK_F_FREE | SK_F_INLINE);
 
+       fio_terminate_threads(TERMINATE_ALL);
+       fio_server_check_jobs(job_list);
        exec_trigger(buf);
        return 0;
 }
@@ -994,7 +995,7 @@ static int handle_command(struct sk_out *sk_out, struct flist_head *job_list,
                ret = 0;
                break;
        case FIO_NET_CMD_EXIT:
-               exit_backend = 1;
+               exit_backend = true;
                return -1;
        case FIO_NET_CMD_LOAD_FILE:
                ret = handle_load_file_cmd(cmd);
@@ -1018,7 +1019,7 @@ static int handle_command(struct sk_out *sk_out, struct flist_head *job_list,
                ret = handle_update_job_cmd(cmd);
                break;
        case FIO_NET_CMD_VTRIGGER:
-               ret = handle_trigger_cmd(cmd);
+               ret = handle_trigger_cmd(cmd, job_list);
                break;
        case FIO_NET_CMD_SENDFILE: {
                struct cmd_sendfile_reply *in;
@@ -1043,7 +1044,7 @@ static int handle_command(struct sk_out *sk_out, struct flist_head *job_list,
                                memcpy(rep->data, in->data, in->size);
                        }
                }
-               fio_mutex_up(&rep->lock);
+               fio_sem_up(&rep->lock);
                break;
                }
        default:
@@ -1062,17 +1063,35 @@ static int fio_send_cmd_ext_pdu(int sk, uint16_t opcode, const void *buf,
 {
        struct fio_net_cmd cmd;
        struct iovec iov[2];
+       size_t this_len;
+       int ret;
 
        iov[0].iov_base = (void *) &cmd;
        iov[0].iov_len = sizeof(cmd);
-       iov[1].iov_base = (void *) buf;
-       iov[1].iov_len = size;
 
-       __fio_init_net_cmd(&cmd, opcode, size, tag);
-       cmd.flags = __cpu_to_le32(flags);
-       fio_net_cmd_crc_pdu(&cmd, buf);
+       do {
+               uint32_t this_flags = flags;
+
+               this_len = size;
+               if (this_len > FIO_SERVER_MAX_FRAGMENT_PDU)
+                       this_len = FIO_SERVER_MAX_FRAGMENT_PDU;
+
+               if (this_len < size)
+                       this_flags |= FIO_NET_CMD_F_MORE;
 
-       return fio_sendv_data(sk, iov, 2);
+               __fio_init_net_cmd(&cmd, opcode, this_len, tag);
+               cmd.flags = __cpu_to_le32(this_flags);
+               fio_net_cmd_crc_pdu(&cmd, buf);
+
+               iov[1].iov_base = (void *) buf;
+               iov[1].iov_len = this_len;
+
+               ret = fio_sendv_data(sk, iov, 2);
+               size -= this_len;
+               buf += this_len;
+       } while (!ret && size);
+
+       return ret;
 }
 
 static void finish_entry(struct sk_entry *entry)
@@ -1124,7 +1143,7 @@ static int handle_sk_entry(struct sk_out *sk_out, struct sk_entry *entry)
 {
        int ret;
 
-       fio_mutex_down(&sk_out->xmit);
+       fio_sem_down(&sk_out->xmit);
 
        if (entry->flags & SK_F_VEC)
                ret = send_vec_entry(sk_out, entry);
@@ -1136,7 +1155,7 @@ static int handle_sk_entry(struct sk_out *sk_out, struct sk_entry *entry)
                                        entry->size, &entry->tag, NULL);
        }
 
-       fio_mutex_up(&sk_out->xmit);
+       fio_sem_up(&sk_out->xmit);
 
        if (ret)
                log_err("fio: failed handling cmd %s\n", fio_server_op(entry->opcode));
@@ -1184,7 +1203,6 @@ static int handle_connection(struct sk_out *sk_out)
                        .events = POLLIN,
                };
 
-               ret = 0;
                do {
                        int timeout = 1000;
 
@@ -1201,7 +1219,7 @@ static int handle_connection(struct sk_out *sk_out)
                                break;
                        } else if (!ret) {
                                fio_server_check_jobs(&job_list);
-                               fio_mutex_down_timeout(&sk_out->wait, timeout);
+                               fio_sem_down_timeout(&sk_out->wait, timeout);
                                continue;
                        }
 
@@ -1267,7 +1285,7 @@ static int get_my_addr_str(int sk)
 
        ret = getsockname(sk, sockaddr_p, &len);
        if (ret) {
-               log_err("fio: getsockaddr: %s\n", strerror(errno));
+               log_err("fio: getsockname: %s\n", strerror(errno));
                return -1;
        }
 
@@ -1344,12 +1362,17 @@ static int accept_loop(int listen_sk)
 
                dprint(FD_NET, "server: connect from %s\n", from);
 
-               sk_out = smalloc(sizeof(*sk_out));
+               sk_out = scalloc(1, sizeof(*sk_out));
+               if (!sk_out) {
+                       close(sk);
+                       return -1;
+               }
+
                sk_out->sk = sk;
                INIT_FLIST_HEAD(&sk_out->list);
-               __fio_mutex_init(&sk_out->lock, FIO_MUTEX_UNLOCKED);
-               __fio_mutex_init(&sk_out->wait, FIO_MUTEX_LOCKED);
-               __fio_mutex_init(&sk_out->xmit, FIO_MUTEX_UNLOCKED);
+               __fio_sem_init(&sk_out->lock, FIO_SEM_UNLOCKED);
+               __fio_sem_init(&sk_out->wait, FIO_SEM_LOCKED);
+               __fio_sem_init(&sk_out->xmit, FIO_SEM_UNLOCKED);
 
                pid = fork();
                if (pid) {
@@ -1421,7 +1444,7 @@ static void convert_gs(struct group_run_stats *dst, struct group_run_stats *src)
                dst->min_run[i]         = cpu_to_le64(src->min_run[i]);
                dst->max_bw[i]          = cpu_to_le64(src->max_bw[i]);
                dst->min_bw[i]          = cpu_to_le64(src->min_bw[i]);
-               dst->io_kb[i]           = cpu_to_le64(src->io_kb[i]);
+               dst->iobytes[i]         = cpu_to_le64(src->iobytes[i]);
                dst->agg[i]             = cpu_to_le64(src->agg[i]);
        }
 
@@ -1429,6 +1452,7 @@ static void convert_gs(struct group_run_stats *dst, struct group_run_stats *src)
        dst->unit_base  = cpu_to_le32(src->unit_base);
        dst->groupid    = cpu_to_le32(src->groupid);
        dst->unified_rw_rep     = cpu_to_le32(src->unified_rw_rep);
+       dst->sig_figs   = cpu_to_le32(src->sig_figs);
 }
 
 /*
@@ -1439,14 +1463,19 @@ void fio_server_send_ts(struct thread_stat *ts, struct group_run_stats *rs)
 {
        struct cmd_ts_pdu p;
        int i, j;
+       void *ss_buf;
+       uint64_t *ss_iops, *ss_bw;
 
        dprint(FD_NET, "server sending end stats\n");
 
        memset(&p, 0, sizeof(p));
 
-       strncpy(p.ts.name, ts->name, FIO_JOBNAME_SIZE - 1);
-       strncpy(p.ts.verror, ts->verror, FIO_VERROR_SIZE - 1);
-       strncpy(p.ts.description, ts->description, FIO_JOBDESC_SIZE - 1);
+       strncpy(p.ts.name, ts->name, FIO_JOBNAME_SIZE);
+       p.ts.name[FIO_JOBNAME_SIZE - 1] = '\0';
+       strncpy(p.ts.verror, ts->verror, FIO_VERROR_SIZE);
+       p.ts.verror[FIO_VERROR_SIZE - 1] = '\0';
+       strncpy(p.ts.description, ts->description, FIO_JOBDESC_SIZE);
+       p.ts.description[FIO_JOBDESC_SIZE - 1] = '\0';
 
        p.ts.error              = cpu_to_le32(ts->error);
        p.ts.thread_number      = cpu_to_le32(ts->thread_number);
@@ -1460,6 +1489,7 @@ void fio_server_send_ts(struct thread_stat *ts, struct group_run_stats *rs)
                convert_io_stat(&p.ts.slat_stat[i], &ts->slat_stat[i]);
                convert_io_stat(&p.ts.lat_stat[i], &ts->lat_stat[i]);
                convert_io_stat(&p.ts.bw_stat[i], &ts->bw_stat[i]);
+               convert_io_stat(&p.ts.iops_stat[i], &ts->iops_stat[i]);
        }
 
        p.ts.usr_time           = cpu_to_le64(ts->usr_time);
@@ -1467,7 +1497,8 @@ void fio_server_send_ts(struct thread_stat *ts, struct group_run_stats *rs)
        p.ts.ctx                = cpu_to_le64(ts->ctx);
        p.ts.minf               = cpu_to_le64(ts->minf);
        p.ts.majf               = cpu_to_le64(ts->majf);
-       p.ts.clat_percentiles   = cpu_to_le64(ts->clat_percentiles);
+       p.ts.clat_percentiles   = cpu_to_le32(ts->clat_percentiles);
+       p.ts.lat_percentiles    = cpu_to_le32(ts->lat_percentiles);
        p.ts.percentile_precision = cpu_to_le64(ts->percentile_precision);
 
        for (i = 0; i < FIO_IO_U_LIST_MAX_LEN; i++) {
@@ -1478,19 +1509,21 @@ void fio_server_send_ts(struct thread_stat *ts, struct group_run_stats *rs)
        }
 
        for (i = 0; i < FIO_IO_U_MAP_NR; i++) {
-               p.ts.io_u_map[i]        = cpu_to_le32(ts->io_u_map[i]);
-               p.ts.io_u_submit[i]     = cpu_to_le32(ts->io_u_submit[i]);
-               p.ts.io_u_complete[i]   = cpu_to_le32(ts->io_u_complete[i]);
+               p.ts.io_u_map[i]        = cpu_to_le64(ts->io_u_map[i]);
+               p.ts.io_u_submit[i]     = cpu_to_le64(ts->io_u_submit[i]);
+               p.ts.io_u_complete[i]   = cpu_to_le64(ts->io_u_complete[i]);
        }
 
-       for (i = 0; i < FIO_IO_U_LAT_U_NR; i++) {
-               p.ts.io_u_lat_u[i]      = cpu_to_le32(ts->io_u_lat_u[i]);
-               p.ts.io_u_lat_m[i]      = cpu_to_le32(ts->io_u_lat_m[i]);
-       }
+       for (i = 0; i < FIO_IO_U_LAT_N_NR; i++)
+               p.ts.io_u_lat_n[i]      = cpu_to_le64(ts->io_u_lat_n[i]);
+       for (i = 0; i < FIO_IO_U_LAT_U_NR; i++)
+               p.ts.io_u_lat_u[i]      = cpu_to_le64(ts->io_u_lat_u[i]);
+       for (i = 0; i < FIO_IO_U_LAT_M_NR; i++)
+               p.ts.io_u_lat_m[i]      = cpu_to_le64(ts->io_u_lat_m[i]);
 
        for (i = 0; i < DDIR_RWDIR_CNT; i++)
                for (j = 0; j < FIO_IO_U_PLAT_NR; j++)
-                       p.ts.io_u_plat[i][j] = cpu_to_le32(ts->io_u_plat[i][j]);
+                       p.ts.io_u_plat[i][j] = cpu_to_le64(ts->io_u_plat[i][j]);
 
        for (i = 0; i < DDIR_RWDIR_CNT; i++) {
                p.ts.total_io_u[i]      = cpu_to_le64(ts->total_io_u[i]);
@@ -1500,6 +1533,7 @@ void fio_server_send_ts(struct thread_stat *ts, struct group_run_stats *rs)
 
        p.ts.total_submit       = cpu_to_le64(ts->total_submit);
        p.ts.total_complete     = cpu_to_le64(ts->total_complete);
+       p.ts.nr_zone_resets     = cpu_to_le64(ts->nr_zone_resets);
 
        for (i = 0; i < DDIR_RWDIR_CNT; i++) {
                p.ts.io_bytes[i]        = cpu_to_le64(ts->io_bytes[i]);
@@ -1518,13 +1552,46 @@ void fio_server_send_ts(struct thread_stat *ts, struct group_run_stats *rs)
        p.ts.latency_window     = cpu_to_le64(ts->latency_window);
        p.ts.latency_percentile.u.i = cpu_to_le64(fio_double_to_uint64(ts->latency_percentile.u.f));
 
-       p.ts.nr_block_infos     = le64_to_cpu(ts->nr_block_infos);
+       p.ts.sig_figs           = cpu_to_le32(ts->sig_figs);
+
+       p.ts.nr_block_infos     = cpu_to_le64(ts->nr_block_infos);
        for (i = 0; i < p.ts.nr_block_infos; i++)
-               p.ts.block_infos[i] = le32_to_cpu(ts->block_infos[i]);
+               p.ts.block_infos[i] = cpu_to_le32(ts->block_infos[i]);
+
+       p.ts.ss_dur             = cpu_to_le64(ts->ss_dur);
+       p.ts.ss_state           = cpu_to_le32(ts->ss_state);
+       p.ts.ss_head            = cpu_to_le32(ts->ss_head);
+       p.ts.ss_limit.u.i       = cpu_to_le64(fio_double_to_uint64(ts->ss_limit.u.f));
+       p.ts.ss_slope.u.i       = cpu_to_le64(fio_double_to_uint64(ts->ss_slope.u.f));
+       p.ts.ss_deviation.u.i   = cpu_to_le64(fio_double_to_uint64(ts->ss_deviation.u.f));
+       p.ts.ss_criterion.u.i   = cpu_to_le64(fio_double_to_uint64(ts->ss_criterion.u.f));
+
+       p.ts.cachehit           = cpu_to_le64(ts->cachehit);
+       p.ts.cachemiss          = cpu_to_le64(ts->cachemiss);
 
        convert_gs(&p.rs, rs);
 
-       fio_net_queue_cmd(FIO_NET_CMD_TS, &p, sizeof(p), NULL, SK_F_COPY);
+       dprint(FD_NET, "ts->ss_state = %d\n", ts->ss_state);
+       if (ts->ss_state & FIO_SS_DATA) {
+               dprint(FD_NET, "server sending steadystate ring buffers\n");
+
+               ss_buf = malloc(sizeof(p) + 2*ts->ss_dur*sizeof(uint64_t));
+
+               memcpy(ss_buf, &p, sizeof(p));
+
+               ss_iops = (uint64_t *) ((struct cmd_ts_pdu *)ss_buf + 1);
+               ss_bw = ss_iops + (int) ts->ss_dur;
+               for (i = 0; i < ts->ss_dur; i++) {
+                       ss_iops[i] = cpu_to_le64(ts->ss_iops_data[i]);
+                       ss_bw[i] = cpu_to_le64(ts->ss_bw_data[i]);
+               }
+
+               fio_net_queue_cmd(FIO_NET_CMD_TS, ss_buf, sizeof(p) + 2*ts->ss_dur*sizeof(uint64_t), NULL, SK_F_COPY);
+
+               free(ss_buf);
+       }
+       else
+               fio_net_queue_cmd(FIO_NET_CMD_TS, &p, sizeof(p), NULL, SK_F_COPY);
 }
 
 void fio_server_send_gs(struct group_run_stats *rs)
@@ -1538,7 +1605,7 @@ void fio_server_send_gs(struct group_run_stats *rs)
 }
 
 void fio_server_send_job_options(struct flist_head *opt_list,
-                                unsigned int groupid)
+                                unsigned int gid)
 {
        struct cmd_job_option pdu;
        struct flist_head *entry;
@@ -1553,12 +1620,12 @@ void fio_server_send_job_options(struct flist_head *opt_list,
                p = flist_entry(entry, struct print_option, list);
                memset(&pdu, 0, sizeof(pdu));
 
-               if (groupid == -1U) {
+               if (gid == -1U) {
                        pdu.global = __cpu_to_le16(1);
                        pdu.groupid = 0;
                } else {
                        pdu.global = 0;
-                       pdu.groupid = cpu_to_le32(groupid);
+                       pdu.groupid = cpu_to_le32(gid);
                }
                len = strlen(p->name);
                if (len >= sizeof(pdu.name)) {
@@ -1634,63 +1701,219 @@ void fio_server_send_du(void)
        }
 }
 
-static int fio_append_iolog_gz(struct sk_entry *first, struct io_log *log)
-{
-       int ret = 0;
 #ifdef CONFIG_ZLIB
+
+static inline void __fio_net_prep_tail(z_stream *stream, void *out_pdu,
+                                       struct sk_entry **last_entry,
+                                       struct sk_entry *first)
+{
+       unsigned int this_len = FIO_SERVER_MAX_FRAGMENT_PDU - stream->avail_out;
+
+       *last_entry = fio_net_prep_cmd(FIO_NET_CMD_IOLOG, out_pdu, this_len,
+                                NULL, SK_F_VEC | SK_F_INLINE | SK_F_FREE);
+       if (*last_entry)
+               flist_add_tail(&(*last_entry)->list, &first->next);
+}
+
+/*
+ * Deflates the next input given, creating as many new packets in the
+ * linked list as necessary.
+ */
+static int __deflate_pdu_buffer(void *next_in, unsigned int next_sz, void **out_pdu,
+                               struct sk_entry **last_entry, z_stream *stream,
+                               struct sk_entry *first)
+{
+       int ret;
+
+       stream->next_in = next_in;
+       stream->avail_in = next_sz;
+       do {
+               if (!stream->avail_out) {
+                       __fio_net_prep_tail(stream, *out_pdu, last_entry, first);
+                       if (*last_entry == NULL)
+                               return 1;
+
+                       *out_pdu = malloc(FIO_SERVER_MAX_FRAGMENT_PDU);
+
+                       stream->avail_out = FIO_SERVER_MAX_FRAGMENT_PDU;
+                       stream->next_out = *out_pdu;
+               }
+
+               ret = deflate(stream, Z_BLOCK);
+
+               if (ret < 0) {
+                       free(*out_pdu);
+                       return 1;
+               }
+       } while (stream->avail_in);
+
+       return 0;
+}
+
+static int __fio_append_iolog_gz_hist(struct sk_entry *first, struct io_log *log,
+                                     struct io_logs *cur_log, z_stream *stream)
+{
        struct sk_entry *entry;
-       z_stream stream;
        void *out_pdu;
+       int ret, i, j;
+       int sample_sz = log_entry_sz(log);
 
-       /*
-        * Dirty - since the log is potentially huge, compress it into
-        * FIO_SERVER_MAX_FRAGMENT_PDU chunks and let the receiving
-        * side defragment it.
-        */
        out_pdu = malloc(FIO_SERVER_MAX_FRAGMENT_PDU);
+       stream->avail_out = FIO_SERVER_MAX_FRAGMENT_PDU;
+       stream->next_out = out_pdu;
 
-       stream.zalloc = Z_NULL;
-       stream.zfree = Z_NULL;
-       stream.opaque = Z_NULL;
+       for (i = 0; i < cur_log->nr_samples; i++) {
+               struct io_sample *s;
+               struct io_u_plat_entry *cur_plat_entry, *prev_plat_entry;
+               uint64_t *cur_plat, *prev_plat;
 
-       if (deflateInit(&stream, Z_DEFAULT_COMPRESSION) != Z_OK) {
-               ret = 1;
-               goto err;
+               s = get_sample(log, cur_log, i);
+               ret = __deflate_pdu_buffer(s, sample_sz, &out_pdu, &entry, stream, first);
+               if (ret)
+                       return ret;
+
+               /* Do the subtraction on server side so that client doesn't have to
+                * reconstruct our linked list from packets.
+                */
+               cur_plat_entry  = s->data.plat_entry;
+               prev_plat_entry = flist_first_entry(&cur_plat_entry->list, struct io_u_plat_entry, list);
+               cur_plat  = cur_plat_entry->io_u_plat;
+               prev_plat = prev_plat_entry->io_u_plat;
+
+               for (j = 0; j < FIO_IO_U_PLAT_NR; j++) {
+                       cur_plat[j] -= prev_plat[j];
+               }
+
+               flist_del(&prev_plat_entry->list);
+               free(prev_plat_entry);
+
+               ret = __deflate_pdu_buffer(cur_plat_entry, sizeof(*cur_plat_entry),
+                                          &out_pdu, &entry, stream, first);
+
+               if (ret)
+                       return ret;
        }
 
-       stream.next_in = (void *) log->log;
-       stream.avail_in = log->nr_samples * log_entry_sz(log);
+       __fio_net_prep_tail(stream, out_pdu, &entry, first);
+       return entry == NULL;
+}
+
+static int __fio_append_iolog_gz(struct sk_entry *first, struct io_log *log,
+                                struct io_logs *cur_log, z_stream *stream)
+{
+       unsigned int this_len;
+       void *out_pdu;
+       int ret;
+
+       if (log->log_type == IO_LOG_TYPE_HIST)
+               return __fio_append_iolog_gz_hist(first, log, cur_log, stream);
+
+       stream->next_in = (void *) cur_log->log;
+       stream->avail_in = cur_log->nr_samples * log_entry_sz(log);
 
        do {
+               struct sk_entry *entry;
+
+               /*
+                * Dirty - since the log is potentially huge, compress it into
+                * FIO_SERVER_MAX_FRAGMENT_PDU chunks and let the receiving
+                * side defragment it.
+                */
+               out_pdu = malloc(FIO_SERVER_MAX_FRAGMENT_PDU);
+
+               stream->avail_out = FIO_SERVER_MAX_FRAGMENT_PDU;
+               stream->next_out = out_pdu;
+               ret = deflate(stream, Z_BLOCK);
+               /* may be Z_OK, or Z_STREAM_END */
+               if (ret < 0) {
+                       free(out_pdu);
+                       return 1;
+               }
+
+               this_len = FIO_SERVER_MAX_FRAGMENT_PDU - stream->avail_out;
+
+               entry = fio_net_prep_cmd(FIO_NET_CMD_IOLOG, out_pdu, this_len,
+                                        NULL, SK_F_VEC | SK_F_INLINE | SK_F_FREE);
+               if (!entry) {
+                       free(out_pdu);
+                       return 1;
+               }
+               flist_add_tail(&entry->list, &first->next);
+       } while (stream->avail_in);
+
+       return 0;
+}
+
+static int fio_append_iolog_gz(struct sk_entry *first, struct io_log *log)
+{
+       z_stream stream = {
+               .zalloc = Z_NULL,
+               .zfree  = Z_NULL,
+               .opaque = Z_NULL,
+       };
+       int ret = 0;
+
+       if (deflateInit(&stream, Z_DEFAULT_COMPRESSION) != Z_OK)
+               return 1;
+
+       while (!flist_empty(&log->io_logs)) {
+               struct io_logs *cur_log;
+
+               cur_log = flist_first_entry(&log->io_logs, struct io_logs, list);
+               flist_del_init(&cur_log->list);
+
+               ret = __fio_append_iolog_gz(first, log, cur_log, &stream);
+               if (ret)
+                       break;
+       }
+
+       ret = deflate(&stream, Z_FINISH);
+
+       while (ret != Z_STREAM_END) {
+               struct sk_entry *entry;
                unsigned int this_len;
+               void *out_pdu;
 
+               out_pdu = malloc(FIO_SERVER_MAX_FRAGMENT_PDU);
                stream.avail_out = FIO_SERVER_MAX_FRAGMENT_PDU;
                stream.next_out = out_pdu;
+
                ret = deflate(&stream, Z_FINISH);
                /* may be Z_OK, or Z_STREAM_END */
-               if (ret < 0)
-                       goto err_zlib;
+               if (ret < 0) {
+                       free(out_pdu);
+                       break;
+               }
 
                this_len = FIO_SERVER_MAX_FRAGMENT_PDU - stream.avail_out;
 
                entry = fio_net_prep_cmd(FIO_NET_CMD_IOLOG, out_pdu, this_len,
-                                               NULL, SK_F_VEC | SK_F_INLINE | SK_F_FREE);
-               out_pdu = NULL;
+                                        NULL, SK_F_VEC | SK_F_INLINE | SK_F_FREE);
+               if (!entry) {
+                       free(out_pdu);
+                       break;
+               }
                flist_add_tail(&entry->list, &first->next);
-       } while (stream.avail_in);
+       } while (ret != Z_STREAM_END);
 
-err_zlib:
-       deflateEnd(&stream);
-err:
-       free(out_pdu);
-#endif
-       return ret;
+       ret = deflateEnd(&stream);
+       if (ret == Z_OK)
+               return 0;
+
+       return 1;
 }
+#else
+static int fio_append_iolog_gz(struct sk_entry *first, struct io_log *log)
+{
+       return 1;
+}
+#endif
 
 static int fio_append_gz_chunks(struct sk_entry *first, struct io_log *log)
 {
        struct sk_entry *entry;
        struct flist_head *node;
+       int ret = 0;
 
        pthread_mutex_lock(&log->chunk_lock);
        flist_for_each(node, &log->chunk_list) {
@@ -1699,33 +1922,53 @@ static int fio_append_gz_chunks(struct sk_entry *first, struct io_log *log)
                c = flist_entry(node, struct iolog_compress, list);
                entry = fio_net_prep_cmd(FIO_NET_CMD_IOLOG, c->buf, c->len,
                                                NULL, SK_F_VEC | SK_F_INLINE);
+               if (!entry) {
+                       ret = 1;
+                       break;
+               }
                flist_add_tail(&entry->list, &first->next);
        }
        pthread_mutex_unlock(&log->chunk_lock);
-
-       return 0;
+       return ret;
 }
 
 static int fio_append_text_log(struct sk_entry *first, struct io_log *log)
 {
        struct sk_entry *entry;
-       size_t size = log->nr_samples * log_entry_sz(log);
+       int ret = 0;
 
-       entry = fio_net_prep_cmd(FIO_NET_CMD_IOLOG, log->log, size,
-                                       NULL, SK_F_VEC | SK_F_INLINE);
-       flist_add_tail(&entry->list, &first->next);
-       return 0;
+       while (!flist_empty(&log->io_logs)) {
+               struct io_logs *cur_log;
+               size_t size;
+
+               cur_log = flist_first_entry(&log->io_logs, struct io_logs, list);
+               flist_del_init(&cur_log->list);
+
+               size = cur_log->nr_samples * log_entry_sz(log);
+
+               entry = fio_net_prep_cmd(FIO_NET_CMD_IOLOG, cur_log->log, size,
+                                               NULL, SK_F_VEC | SK_F_INLINE);
+               if (!entry) {
+                       ret = 1;
+                       break;
+               }
+               flist_add_tail(&entry->list, &first->next);
+       }
+
+       return ret;
 }
 
 int fio_send_iolog(struct thread_data *td, struct io_log *log, const char *name)
 {
-       struct cmd_iolog_pdu pdu;
+       struct cmd_iolog_pdu pdu = {
+               .nr_samples             = cpu_to_le64(iolog_nr_samples(log)),
+               .thread_number          = cpu_to_le32(td->thread_number),
+               .log_type               = cpu_to_le32(log->log_type),
+               .log_hist_coarseness    = cpu_to_le32(log->hist_coarseness),
+       };
        struct sk_entry *first;
-       int i, ret = 0;
-
-       pdu.nr_samples = cpu_to_le64(log->nr_samples);
-       pdu.thread_number = cpu_to_le32(td->thread_number);
-       pdu.log_type = cpu_to_le32(log->log_type);
+       struct flist_head *entry;
+       int ret = 0;
 
        if (!flist_empty(&log->chunk_list))
                pdu.compressed = __cpu_to_le32(STORE_COMPRESSED);
@@ -1741,18 +1984,25 @@ int fio_send_iolog(struct thread_data *td, struct io_log *log, const char *name)
         * We can't do this for a pre-compressed log, but for that case,
         * log->nr_samples is zero anyway.
         */
-       for (i = 0; i < log->nr_samples; i++) {
-               struct io_sample *s = get_sample(log, i);
+       flist_for_each(entry, &log->io_logs) {
+               struct io_logs *cur_log;
+               int i;
+
+               cur_log = flist_entry(entry, struct io_logs, list);
+
+               for (i = 0; i < cur_log->nr_samples; i++) {
+                       struct io_sample *s = get_sample(log, cur_log, i);
 
-               s->time         = cpu_to_le64(s->time);
-               s->val          = cpu_to_le64(s->val);
-               s->__ddir       = cpu_to_le32(s->__ddir);
-               s->bs           = cpu_to_le32(s->bs);
+                       s->time         = cpu_to_le64(s->time);
+                       s->data.val     = cpu_to_le64(s->data.val);
+                       s->__ddir       = cpu_to_le32(s->__ddir);
+                       s->bs           = cpu_to_le64(s->bs);
 
-               if (log->log_offset) {
-                       struct io_sample_offset *so = (void *) s;
+                       if (log->log_offset) {
+                               struct io_sample_offset *so = (void *) s;
 
-                       so->offset = cpu_to_le64(so->offset);
+                               so->offset = cpu_to_le64(so->offset);
+                       }
                }
        }
 
@@ -1760,6 +2010,8 @@ int fio_send_iolog(struct thread_data *td, struct io_log *log, const char *name)
         * Assemble header entry first
         */
        first = fio_net_prep_cmd(FIO_NET_CMD_IOLOG, &pdu, sizeof(pdu), NULL, SK_F_VEC | SK_F_INLINE | SK_F_COPY);
+       if (!first)
+               return 1;
 
        /*
         * Now append actual log entries. If log compression was enabled on
@@ -1780,11 +2032,11 @@ int fio_send_iolog(struct thread_data *td, struct io_log *log, const char *name)
 
 void fio_server_send_add_job(struct thread_data *td)
 {
-       struct cmd_add_job_pdu pdu;
+       struct cmd_add_job_pdu pdu = {
+               .thread_number = cpu_to_le32(td->thread_number),
+               .groupid = cpu_to_le32(td->groupid),
+       };
 
-       memset(&pdu, 0, sizeof(pdu));
-       pdu.thread_number = cpu_to_le32(td->thread_number);
-       pdu.groupid = cpu_to_le32(td->groupid);
        convert_thread_options_to_net(&pdu.top, &td->o);
 
        fio_net_queue_cmd(FIO_NET_CMD_ADD_JOB, &pdu, sizeof(pdu), NULL,
@@ -1797,11 +2049,11 @@ void fio_server_send_start(struct thread_data *td)
 
        assert(sk_out->sk != -1);
 
-       fio_net_queue_cmd(FIO_NET_CMD_SERVER_START, NULL, 0, 0, SK_F_SIMPLE);
+       fio_net_queue_cmd(FIO_NET_CMD_SERVER_START, NULL, 0, NULL, SK_F_SIMPLE);
 }
 
 int fio_server_get_verify_state(const char *name, int threadnumber,
-                               void **datap, int *version)
+                               void **datap)
 {
        struct thread_io_list *s;
        struct cmd_sendfile out;
@@ -1813,12 +2065,10 @@ int fio_server_get_verify_state(const char *name, int threadnumber,
        dprint(FD_NET, "server: request verify state\n");
 
        rep = smalloc(sizeof(*rep));
-       if (!rep) {
-               log_err("fio: smalloc pool too small\n");
+       if (!rep)
                return ENOMEM;
-       }
 
-       __fio_mutex_init(&rep->lock, FIO_MUTEX_LOCKED);
+       __fio_sem_init(&rep->lock, FIO_SEM_LOCKED);
        rep->data = NULL;
        rep->error = 0;
 
@@ -1831,7 +2081,7 @@ int fio_server_get_verify_state(const char *name, int threadnumber,
        /*
         * Wait for the backend to receive the reply
         */
-       if (fio_mutex_down_timeout(&rep->lock, 10000)) {
+       if (fio_sem_down_timeout(&rep->lock, 10000)) {
                log_err("fio: timed out waiting for reply\n");
                ret = ETIMEDOUT;
                goto fail;
@@ -1853,7 +2103,7 @@ fail:
         * the header, and the thread_io_list checksum
         */
        s = rep->data + sizeof(struct verify_state_hdr);
-       if (verify_state_hdr(rep->data, s, version)) {
+       if (verify_state_hdr(rep->data, s)) {
                ret = EILSEQ;
                goto fail;
        }
@@ -1868,7 +2118,7 @@ fail:
        *datap = data;
 
        sfree(rep->data);
-       __fio_mutex_remove(&rep->lock);
+       __fio_sem_remove(&rep->lock);
        sfree(rep);
        return ret;
 }
@@ -1898,22 +2148,21 @@ static int fio_init_server_ip(void)
                return -1;
        }
 #ifdef SO_REUSEPORT
-       if (setsockopt(sk, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)) < 0) {
-               log_err("fio: setsockopt(REUSEPORT): %s\n", strerror(errno));
-               close(sk);
-               return -1;
-       }
+       /*
+        * Not fatal if fails, so just ignore it if that happens
+        */
+       setsockopt(sk, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
 #endif
 
        if (use_ipv6) {
-               const void *src = &saddr_in6.sin6_addr;
+               void *src = &saddr_in6.sin6_addr;
 
                addr = (struct sockaddr *) &saddr_in6;
                socklen = sizeof(saddr_in6);
                saddr_in6.sin6_family = AF_INET6;
                str = inet_ntop(AF_INET6, src, buf, sizeof(buf));
        } else {
-               const void *src = &saddr_in.sin_addr;
+               void *src = &saddr_in.sin_addr;
 
                addr = (struct sockaddr *) &saddr_in;
                socklen = sizeof(saddr_in);
@@ -1981,7 +2230,7 @@ static int fio_init_server_connection(void)
 
        if (!bind_sock) {
                char *p, port[16];
-               const void *src;
+               void *src;
                int af;
 
                if (use_ipv6) {
@@ -2025,11 +2274,10 @@ int fio_server_parse_host(const char *host, int ipv6, struct in_addr *inp,
                ret = inet_pton(AF_INET, host, inp);
 
        if (ret != 1) {
-               struct addrinfo hints, *res;
-
-               memset(&hints, 0, sizeof(hints));
-               hints.ai_family = ipv6 ? AF_INET6 : AF_INET;
-               hints.ai_socktype = SOCK_STREAM;
+               struct addrinfo *res, hints = {
+                       .ai_family = ipv6 ? AF_INET6 : AF_INET,
+                       .ai_socktype = SOCK_STREAM,
+               };
 
                ret = getaddrinfo(host, NULL, &hints, &res);
                if (ret) {
@@ -2062,7 +2310,7 @@ int fio_server_parse_host(const char *host, int ipv6, struct in_addr *inp,
  * For local domain sockets:
  *     *ptr is the filename, *is_sock is 1.
  */
-int fio_server_parse_string(const char *str, char **ptr, int *is_sock,
+int fio_server_parse_string(const char *str, char **ptr, bool *is_sock,
                            int *port, struct in_addr *inp,
                            struct in6_addr *inp6, int *ipv6)
 {
@@ -2071,13 +2319,13 @@ int fio_server_parse_string(const char *str, char **ptr, int *is_sock,
        int lport = 0;
 
        *ptr = NULL;
-       *is_sock = 0;
+       *is_sock = false;
        *port = fio_net_port;
        *ipv6 = 0;
 
        if (!strncmp(str, "sock:", 5)) {
                *ptr = strdup(str + 5);
-               *is_sock = 1;
+               *is_sock = true;
 
                return 0;
        }
@@ -2156,7 +2404,8 @@ int fio_server_parse_string(const char *str, char **ptr, int *is_sock,
 static int fio_handle_server_arg(void)
 {
        int port = fio_net_port;
-       int is_sock, ret = 0;
+       bool is_sock;
+       int ret = 0;
 
        saddr_in.sin_addr.s_addr = htonl(INADDR_ANY);
 
@@ -2187,11 +2436,11 @@ static void sig_int(int sig)
 
 static void set_sig_handlers(void)
 {
-       struct sigaction act;
+       struct sigaction act = {
+               .sa_handler = sig_int,
+               .sa_flags = SA_RESTART,
+       };
 
-       memset(&act, 0, sizeof(act));
-       act.sa_handler = sig_int;
-       act.sa_flags = SA_RESTART;
        sigaction(SIGINT, &act, NULL);
 }
 
@@ -2250,7 +2499,7 @@ void fio_server_got_signal(int signal)
                sk_out->sk = -1;
        else {
                log_info("\nfio: terminating on signal %d\n", signal);
-               exit_backend = 1;
+               exit_backend = true;
        }
 }
 
@@ -2321,7 +2570,7 @@ int fio_start_server(char *pidfile)
 
        pid = fork();
        if (pid < 0) {
-               log_err("fio: failed server fork: %s", strerror(errno));
+               log_err("fio: failed server fork: %s\n", strerror(errno));
                free(pidfile);
                return -1;
        } else if (pid) {
@@ -2332,7 +2581,7 @@ int fio_start_server(char *pidfile)
 
        setsid();
        openlog("fio", LOG_NDELAY|LOG_NOWAIT|LOG_PID, LOG_USER);
-       log_syslog = 1;
+       log_syslog = true;
        close(STDIN_FILENO);
        close(STDOUT_FILENO);
        close(STDERR_FILENO);