server: convert more memset to on-stack initialization

[fio.git] / server.c

diff --git a/server.c b/server.c
index e6ea4cdbfdcabc911a97f0e96d1e99e92b8c520b..54d703d0b056f1b02a6baaf3d4e95011d3f0543e 100644 (file)
--- a/server.c
+++ b/server.c
@@ -616,7 +616,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, NULL, SK_F_SIMPLE);
+       return fio_net_queue_cmd(FIO_NET_CMD_QUIT, NULL, 0, NULL, SK_F_SIMPLE | SK_F_INLINE);
 }
 
 int fio_net_send_quit(int sk)
@@ -636,7 +636,7 @@ static int fio_net_send_ack(struct fio_net_cmd *cmd, int error, int signal)
 
        epdu.error = __cpu_to_le32(error);
        epdu.signal = __cpu_to_le32(signal);
-       return fio_net_queue_cmd(FIO_NET_CMD_STOP, &epdu, sizeof(epdu), &tag, SK_F_COPY);
+       return fio_net_queue_cmd(FIO_NET_CMD_STOP, &epdu, sizeof(epdu), &tag, SK_F_COPY | SK_F_INLINE);
 }
 
 static int fio_net_queue_stop(int error, int signal)
@@ -844,25 +844,24 @@ 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) - 1);
 
-       probe.os        = FIO_OS;
-       probe.arch      = FIO_ARCH;
-       probe.bpp       = sizeof(void *);
-       probe.cpus      = __cpu_to_le32(cpus_online());
-
        /*
         * If the client supports compression and we do too, then enable it
         */
@@ -951,7 +950,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,6 +970,7 @@ static int handle_trigger_cmd(struct fio_net_cmd *cmd)
                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;
 }
@@ -1014,7 +1014,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;
@@ -1538,6 +1538,8 @@ 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.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] = cpu_to_le32(ts->block_infos[i]);
@@ -1553,7 +1555,7 @@ void fio_server_send_ts(struct thread_stat *ts, struct group_run_stats *rs)
        convert_gs(&p.rs, rs);
 
        dprint(FD_NET, "ts->ss_state = %d\n", ts->ss_state);
-       if (ts->ss_state & __FIO_SS_DATA) {
+       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));
@@ -1823,13 +1825,12 @@ static int __fio_append_iolog_gz(struct sk_entry *first, struct io_log *log,
 
 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;
-       z_stream stream;
-
-       memset(&stream, 0, sizeof(stream));
-       stream.zalloc = Z_NULL;
-       stream.zfree = Z_NULL;
-       stream.opaque = Z_NULL;
 
        if (deflateInit(&stream, Z_DEFAULT_COMPRESSION) != Z_OK)
                return 1;
@@ -1925,16 +1926,16 @@ static int fio_append_text_log(struct sk_entry *first, struct io_log *log)
 
 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;
        struct flist_head *entry;
        int ret = 0;
 
-       pdu.nr_samples = cpu_to_le64(iolog_nr_samples(log));
-       pdu.thread_number = cpu_to_le32(td->thread_number);
-       pdu.log_type = cpu_to_le32(log->log_type);
-       pdu.log_hist_coarseness = cpu_to_le32(log->hist_coarseness);
-
        if (!flist_empty(&log->chunk_list))
                pdu.compressed = __cpu_to_le32(STORE_COMPRESSED);
        else if (use_zlib)
@@ -1995,11 +1996,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,
@@ -2237,11 +2238,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) {
@@ -2400,11 +2400,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);
 }