verify: Simplify dump_buf()

[fio.git] / verify.c

diff --git a/verify.c b/verify.c
index 1c39fa2e877f14511f575bf847f14c55acdba634..c5fa24110143cb46cee4a6dad1db9a7e878c6a01 100644 (file)
--- a/verify.c
+++ b/verify.c
@@ -30,9 +30,6 @@
 static void populate_hdr(struct thread_data *td, struct io_u *io_u,
                         struct verify_header *hdr, unsigned int header_num,
                         unsigned int header_len);
-static void fill_hdr(struct thread_data *td, struct io_u *io_u,
-                    struct verify_header *hdr, unsigned int header_num,
-                    unsigned int header_len, uint64_t rand_seed);
 static void __fill_hdr(struct thread_data *td, struct io_u *io_u,
                       struct verify_header *hdr, unsigned int header_num,
                       unsigned int header_len, uint64_t rand_seed);
@@ -90,8 +87,13 @@ static unsigned int get_hdr_inc(struct thread_data *td, struct io_u *io_u)
 {
        unsigned int hdr_inc;
 
+       /*
+        * If we use bs_unaligned, buflen can be larger than the verify
+        * interval (which just defaults to the smallest blocksize possible).
+        */
        hdr_inc = io_u->buflen;
-       if (td->o.verify_interval && td->o.verify_interval <= io_u->buflen)
+       if (td->o.verify_interval && td->o.verify_interval <= io_u->buflen &&
+           !td->o.bs_unaligned)
                hdr_inc = td->o.verify_interval;
 
        return hdr_inc;
@@ -239,40 +241,27 @@ struct vcont {
 };
 
 #define DUMP_BUF_SZ    255
-static int dump_buf_warned;
 
 static void dump_buf(char *buf, unsigned int len, unsigned long long offset,
                     const char *type, struct fio_file *f)
 {
-       char *ptr, fname[DUMP_BUF_SZ];
-       size_t buf_left = DUMP_BUF_SZ;
+       char *ptr, *fname;
+       char sep[2] = { FIO_OS_PATH_SEPARATOR, 0 };
        int ret, fd;
 
        ptr = strdup(f->file_name);
 
-       memset(fname, 0, sizeof(fname));
-       if (aux_path)
-               sprintf(fname, "%s%s", aux_path, FIO_OS_PATH_SEPARATOR);
-
-       strncpy(fname + strlen(fname), basename(ptr), buf_left - 1);
-
-       buf_left -= strlen(fname);
-       if (buf_left <= 0) {
-               if (!dump_buf_warned) {
-                       log_err("fio: verify failure dump buffer too small\n");
-                       dump_buf_warned = 1;
-               }
-               free(ptr);
-               return;
+       if (asprintf(&fname, "%s%s%s.%llu.%s", aux_path ? : "",
+                    aux_path ? sep : "", basename(ptr), offset, type) < 0) {
+               if (!fio_did_warn(FIO_WARN_VERIFY_BUF))
+                       log_err("fio: not enough memory for dump buffer filename\n");
+               goto free_ptr;
        }
 
-       snprintf(fname + strlen(fname), buf_left, ".%llu.%s", offset, type);
-
        fd = open(fname, O_CREAT | O_TRUNC | O_WRONLY, 0644);
        if (fd < 0) {
                perror("open verify buf file");
-               free(ptr);
-               return;
+               goto free_fname;
        }
 
        while (len) {
@@ -289,6 +278,11 @@ static void dump_buf(char *buf, unsigned int len, unsigned long long offset,
 
        close(fd);
        log_err("       %s data dumped as %s\n", type, fname);
+
+free_fname:
+       free(fname);
+
+free_ptr:
        free(ptr);
 }
 
@@ -388,7 +382,7 @@ static int verify_io_u_pattern(struct verify_header *hdr, struct vcont *vc)
        (void)paste_format_inplace(pattern, pattern_size,
                                   td->o.verify_fmt, td->o.verify_fmt_sz, io_u);
 
-       buf = (void *) hdr + header_size;
+       buf = (char *) hdr + header_size;
        len = get_hdr_inc(td, io_u) - header_size;
        mod = (get_hdr_inc(td, io_u) * vc->hdr_num + header_size) % pattern_size;
 
@@ -749,9 +743,9 @@ int verify_io_u_async(struct thread_data *td, struct io_u **io_u_ptr)
        }
        flist_add_tail(&io_u->verify_list, &td->verify_list);
        *io_u_ptr = NULL;
-       pthread_mutex_unlock(&td->io_u_lock);
 
        pthread_cond_signal(&td->verify_cond);
+       pthread_mutex_unlock(&td->io_u_lock);
        return 0;
 }
 
@@ -1167,7 +1161,7 @@ static void __fill_hdr(struct thread_data *td, struct io_u *io_u,
        hdr->rand_seed = rand_seed;
        hdr->offset = io_u->offset + header_num * td->o.verify_interval;
        hdr->time_sec = io_u->start_time.tv_sec;
-       hdr->time_usec = io_u->start_time.tv_usec;
+       hdr->time_nsec = io_u->start_time.tv_nsec;
        hdr->thread = td->thread_number;
        hdr->numberio = io_u->numberio;
        hdr->crc32 = fio_crc32c(p, offsetof(struct verify_header, crc32));
@@ -1178,7 +1172,6 @@ static void fill_hdr(struct thread_data *td, struct io_u *io_u,
                     struct verify_header *hdr, unsigned int header_num,
                     unsigned int header_len, uint64_t rand_seed)
 {
-
        if (td->o.verify != VERIFY_PATTERN_NO_HDR)
                __fill_hdr(td, io_u, hdr, header_num, header_len, rand_seed);
 }
@@ -1188,9 +1181,10 @@ static void populate_hdr(struct thread_data *td, struct io_u *io_u,
                         unsigned int header_len)
 {
        unsigned int data_len;
-       void *data, *p;
+       void *data;
+       char *p;
 
-       p = (void *) hdr;
+       p = (char *) hdr;
 
        fill_hdr(td, io_u, hdr, header_num, header_len, io_u->rand_seed);
 
@@ -1308,7 +1302,7 @@ int get_next_verify(struct thread_data *td, struct io_u *io_u)
                return 0;
 
        if (!RB_EMPTY_ROOT(&td->io_hist_tree)) {
-               struct rb_node *n = rb_first(&td->io_hist_tree);
+               struct fio_rb_node *n = rb_first(&td->io_hist_tree);
 
                ipo = rb_entry(n, struct io_piece, rb_node);
 
@@ -1455,9 +1449,9 @@ static void *verify_async_thread(void *data)
 done:
        pthread_mutex_lock(&td->io_u_lock);
        td->nr_verify_threads--;
+       pthread_cond_signal(&td->free_cond);
        pthread_mutex_unlock(&td->io_u_lock);
 
-       pthread_cond_signal(&td->free_cond);
        return NULL;
 }
 
@@ -1493,9 +1487,12 @@ int verify_async_init(struct thread_data *td)
 
        if (i != td->o.verify_async) {
                log_err("fio: only %d verify threads started, exiting\n", i);
+
+               pthread_mutex_lock(&td->io_u_lock);
                td->verify_thread_exit = 1;
-               write_barrier();
                pthread_cond_broadcast(&td->verify_cond);
+               pthread_mutex_unlock(&td->io_u_lock);
+
                return 1;
        }
 
@@ -1504,12 +1501,10 @@ int verify_async_init(struct thread_data *td)
 
 void verify_async_exit(struct thread_data *td)
 {
+       pthread_mutex_lock(&td->io_u_lock);
        td->verify_thread_exit = 1;
-       write_barrier();
        pthread_cond_broadcast(&td->verify_cond);
 
-       pthread_mutex_lock(&td->io_u_lock);
-
        while (td->nr_verify_threads)
                pthread_cond_wait(&td->free_cond, &td->io_u_lock);
 
@@ -1725,7 +1720,7 @@ void verify_save_state(int mask)
                char prefix[PATH_MAX];
 
                if (aux_path)
-                       sprintf(prefix, "%s%slocal", aux_path, FIO_OS_PATH_SEPARATOR);
+                       sprintf(prefix, "%s%clocal", aux_path, FIO_OS_PATH_SEPARATOR);
                else
                        strcpy(prefix, "local");