client: check return of dup(2)

[fio.git] / client.c

diff --git a/client.c b/client.c
index 18247ef6b9bd277c0e66a980b3a49679aa4f1173..611ee2f5a3f929d9d7ae7c7d14c229196bdfedbb 100644 (file)
--- a/client.c
+++ b/client.c
@@ -1,13 +1,11 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <limits.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <sys/poll.h>
+#include <poll.h>
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <sys/wait.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <netinet/in.h>
@@ -23,14 +21,14 @@
 #include "server.h"
 #include "flist.h"
 #include "hash.h"
-#include "verify.h"
+#include "verify-state.h"
 
 static void handle_du(struct fio_client *client, struct fio_net_cmd *cmd);
 static void handle_ts(struct fio_client *client, struct fio_net_cmd *cmd);
 static void handle_gs(struct fio_client *client, struct fio_net_cmd *cmd);
 static void handle_probe(struct fio_client *client, struct fio_net_cmd *cmd);
 static void handle_text(struct fio_client *client, struct fio_net_cmd *cmd);
-static void handle_stop(struct fio_client *client, struct fio_net_cmd *cmd);
+static void handle_stop(struct fio_client *client);
 static void handle_start(struct fio_client *client, struct fio_net_cmd *cmd);
 
 static void convert_text(struct fio_net_cmd *cmd);
@@ -120,6 +118,54 @@ static int read_data(int fd, void *data, size_t size)
        return 0;
 }
 
+static int read_ini_data(int fd, void *data, size_t size)
+{
+       char *p = data;
+       int ret = 0;
+       FILE *fp;
+       int dupfd;
+
+       dupfd = dup(fd);
+       if (dupfd < 0)
+               return errno;
+
+       fp = fdopen(dupfd, "r");
+       if (!fp)
+               return errno;
+
+       while (1) {
+               ssize_t len;
+               char buf[OPT_LEN_MAX+1], *sub;
+
+               if (!fgets(buf, sizeof(buf), fp)) {
+                       if (ferror(fp)) {
+                               if (errno == EAGAIN || errno == EINTR)
+                                       continue;
+                               ret = errno;
+                       }
+                       break;
+               }
+
+               sub = fio_option_dup_subs(buf);
+               len = strlen(sub);
+               if (len + 1 > size) {
+                       log_err("fio: no space left to read data\n");
+                       free(sub);
+                       ret = ENOSPC;
+                       break;
+               }
+
+               memcpy(p, sub, len);
+               free(sub);
+               p += len;
+               *p = '\0';
+               size -= len;
+       }
+
+       fclose(fp);
+       return ret;
+}
+
 static void fio_client_json_init(void)
 {
        char time_buf[32];
@@ -765,13 +811,17 @@ static int __fio_client_send_local_ini(struct fio_client *client,
                return ret;
        }
 
+       /*
+        * Add extra space for variable expansion, but doesn't guarantee.
+        */
+       sb.st_size += OPT_LEN_MAX;
        p_size = sb.st_size + sizeof(*pdu);
        pdu = malloc(p_size);
        buf = pdu->buf;
 
        len = sb.st_size;
        p = buf;
-       if (read_data(fd, p, len)) {
+       if (read_ini_data(fd, p, len)) {
                log_err("fio: failed reading job file %s\n", filename);
                close(fd);
                free(pdu);
@@ -905,21 +955,21 @@ static void convert_ts(struct thread_stat *dst, struct thread_stat *src)
        }
 
        for (i = 0; i < FIO_IO_U_MAP_NR; i++) {
-               dst->io_u_map[i]        = le32_to_cpu(src->io_u_map[i]);
-               dst->io_u_submit[i]     = le32_to_cpu(src->io_u_submit[i]);
-               dst->io_u_complete[i]   = le32_to_cpu(src->io_u_complete[i]);
+               dst->io_u_map[i]        = le64_to_cpu(src->io_u_map[i]);
+               dst->io_u_submit[i]     = le64_to_cpu(src->io_u_submit[i]);
+               dst->io_u_complete[i]   = le64_to_cpu(src->io_u_complete[i]);
        }
 
        for (i = 0; i < FIO_IO_U_LAT_N_NR; i++)
-               dst->io_u_lat_n[i]      = le32_to_cpu(src->io_u_lat_n[i]);
+               dst->io_u_lat_n[i]      = le64_to_cpu(src->io_u_lat_n[i]);
        for (i = 0; i < FIO_IO_U_LAT_U_NR; i++)
-               dst->io_u_lat_u[i]      = le32_to_cpu(src->io_u_lat_u[i]);
+               dst->io_u_lat_u[i]      = le64_to_cpu(src->io_u_lat_u[i]);
        for (i = 0; i < FIO_IO_U_LAT_M_NR; i++)
-               dst->io_u_lat_m[i]      = le32_to_cpu(src->io_u_lat_m[i]);
+               dst->io_u_lat_m[i]      = le64_to_cpu(src->io_u_lat_m[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]);
+                       dst->io_u_plat[i][j] = le64_to_cpu(src->io_u_plat[i][j]);
 
        for (i = 0; i < DDIR_RWDIR_CNT; i++) {
                dst->total_io_u[i]      = le64_to_cpu(src->total_io_u[i]);
@@ -1024,6 +1074,7 @@ static void handle_ts(struct fio_client *client, struct fio_net_cmd *cmd)
        client_ts.thread_number = p->ts.thread_number;
        client_ts.groupid = p->ts.groupid;
        client_ts.unified_rw_rep = p->ts.unified_rw_rep;
+       client_ts.sig_figs = p->ts.sig_figs;
 
        if (++sum_stat_nr == sum_stat_clients) {
                strcpy(client_ts.name, "All clients");
@@ -1282,7 +1333,7 @@ static void client_flush_hist_samples(FILE *f, int hist_coarseness, void *sample
        int log_offset;
        uint64_t i, j, nr_samples;
        struct io_u_plat_entry *entry;
-       unsigned int *io_u_plat;
+       uint64_t *io_u_plat;
 
        int stride = 1 << hist_coarseness;
 
@@ -1305,9 +1356,9 @@ static void client_flush_hist_samples(FILE *f, int hist_coarseness, void *sample
                fprintf(f, "%lu, %u, %u, ", (unsigned long) s->time,
                                                io_sample_ddir(s), s->bs);
                for (j = 0; j < FIO_IO_U_PLAT_NR - stride; j += stride) {
-                       fprintf(f, "%lu, ", hist_sum(j, stride, io_u_plat, NULL));
+                       fprintf(f, "%llu, ", (unsigned long long)hist_sum(j, stride, io_u_plat, NULL));
                }
-               fprintf(f, "%lu\n", (unsigned long)
+               fprintf(f, "%llu\n", (unsigned long long)
                        hist_sum(FIO_IO_U_PLAT_NR - stride, stride, io_u_plat, NULL));
 
        }
@@ -1340,7 +1391,7 @@ static int fio_client_handle_iolog(struct fio_client *client,
        sprintf(log_pathname, "%s.%s", pdu->name, client->hostname);
 
        if (store_direct) {
-               ssize_t ret;
+               ssize_t wrote;
                size_t sz;
                int fd;
 
@@ -1354,10 +1405,10 @@ static int fio_client_handle_iolog(struct fio_client *client,
                }
 
                sz = cmd->pdu_len - sizeof(*pdu);
-               ret = write(fd, pdu->samples, sz);
+               wrote = write(fd, pdu->samples, sz);
                close(fd);
 
-               if (ret != sz) {
+               if (wrote != sz) {
                        log_err("fio: short write on compressed log\n");
                        ret = 1;
                        goto out;
@@ -1442,7 +1493,7 @@ static void handle_start(struct fio_client *client, struct fio_net_cmd *cmd)
        sum_stat_clients += client->nr_stat;
 }
 
-static void handle_stop(struct fio_client *client, struct fio_net_cmd *cmd)
+static void handle_stop(struct fio_client *client)
 {
        if (client->error)
                log_info("client <%s>: exited with error %d\n", client->hostname, client->error);
@@ -1745,7 +1796,7 @@ int fio_handle_client(struct fio_client *client)
                client->state = Client_stopped;
                client->error = le32_to_cpu(pdu->error);
                client->signal = le32_to_cpu(pdu->signal);
-               ops->stop(client, cmd);
+               ops->stop(client);
                break;
                }
        case FIO_NET_CMD_ADD_JOB: {