Merge branch 's3_crypto' of github.com:hualongfeng/fio

[fio.git] / verify.c

diff --git a/verify.c b/verify.c
index 01492f24f9a0336c3b09ebb295aa0afe6963c4bd..0e1e4639348547b86319c67a05349e161f17b7e0 100644 (file)
--- a/verify.c
+++ b/verify.c
@@ -8,12 +8,14 @@
 #include <pthread.h>
 #include <libgen.h>
 
+#include "arch/arch.h"
 #include "fio.h"
 #include "verify.h"
 #include "trim.h"
 #include "lib/rand.h"
 #include "lib/hweight.h"
 #include "lib/pattern.h"
+#include "oslib/asprintf.h"
 
 #include "crc/md5.h"
 #include "crc/crc64.h"
@@ -39,33 +41,27 @@ void fill_buffer_pattern(struct thread_data *td, void *p, unsigned int len)
        (void)cpy_pattern(td->o.buffer_pattern, td->o.buffer_pattern_bytes, p, len);
 }
 
-static void __fill_buffer(struct thread_options *o, unsigned long seed, void *p,
+static void __fill_buffer(struct thread_options *o, uint64_t seed, void *p,
                          unsigned int len)
 {
        __fill_random_buf_percentage(seed, p, o->compress_percentage, len, len, o->buffer_pattern, o->buffer_pattern_bytes);
 }
 
-static unsigned long fill_buffer(struct thread_data *td, void *p,
-                                unsigned int len)
-{
-       struct frand_state *fs = &td->verify_state;
-       struct thread_options *o = &td->o;
-
-       return fill_random_buf_percentage(fs, p, o->compress_percentage, len, len, o->buffer_pattern, o->buffer_pattern_bytes);
-}
-
 void fill_verify_pattern(struct thread_data *td, void *p, unsigned int len,
-                        struct io_u *io_u, unsigned long seed, int use_seed)
+                        struct io_u *io_u, uint64_t seed, int use_seed)
 {
        struct thread_options *o = &td->o;
 
        if (!o->verify_pattern_bytes) {
                dprint(FD_VERIFY, "fill random bytes len=%u\n", len);
 
-               if (use_seed)
-                       __fill_buffer(o, seed, p, len);
-               else
-                       io_u->rand_seed = fill_buffer(td, p, len);
+               if (!use_seed) {
+                       seed = __rand(&td->verify_state);
+                       if (sizeof(int) != sizeof(long *))
+                               seed *= (unsigned long)__rand(&td->verify_state);
+               }
+               io_u->rand_seed = seed;
+               __fill_buffer(o, seed, p, len);
                return;
        }
 
@@ -100,7 +96,7 @@ static unsigned int get_hdr_inc(struct thread_data *td, struct io_u *io_u)
 }
 
 static void fill_pattern_headers(struct thread_data *td, struct io_u *io_u,
-                                unsigned long seed, int use_seed)
+                                uint64_t seed, int use_seed)
 {
        unsigned int hdr_inc, header_num;
        struct verify_header *hdr;
@@ -306,7 +302,7 @@ static void __dump_verify_buffers(struct verify_header *hdr, struct vcont *vc)
         */
        hdr_offset = vc->hdr_num * hdr->len;
 
-       dump_buf(io_u->buf + hdr_offset, hdr->len, io_u->offset + hdr_offset,
+       dump_buf(io_u->buf + hdr_offset, hdr->len, io_u->verify_offset + hdr_offset,
                        "received", vc->io_u->file);
 
        /*
@@ -321,7 +317,7 @@ static void __dump_verify_buffers(struct verify_header *hdr, struct vcont *vc)
 
        fill_pattern_headers(td, &dummy, hdr->rand_seed, 1);
 
-       dump_buf(buf + hdr_offset, hdr->len, io_u->offset + hdr_offset,
+       dump_buf(buf + hdr_offset, hdr->len, io_u->verify_offset + hdr_offset,
                        "expected", vc->io_u->file);
        free(buf);
 }
@@ -343,10 +339,12 @@ static void log_verify_failure(struct verify_header *hdr, struct vcont *vc)
 {
        unsigned long long offset;
 
-       offset = vc->io_u->offset;
+       offset = vc->io_u->verify_offset;
        offset += vc->hdr_num * hdr->len;
-       log_err("%.8s: verify failed at file %s offset %llu, length %u\n",
-                       vc->name, vc->io_u->file->file_name, offset, hdr->len);
+       log_err("%.8s: verify failed at file %s offset %llu, length %u"
+                       " (requested block: offset=%llu, length=%llu, flags=%x)\n",
+                       vc->name, vc->io_u->file->file_name, offset, hdr->len,
+                       vc->io_u->verify_offset, vc->io_u->buflen, vc->io_u->flags);
 
        if (vc->good_crc && vc->bad_crc) {
                log_err("       Expected CRC: ");
@@ -803,7 +801,7 @@ static int verify_trimmed_io_u(struct thread_data *td, struct io_u *io_u)
 
        log_err("trim: verify failed at file %s offset %llu, length %llu"
                ", block offset %lu\n",
-                       io_u->file->file_name, io_u->offset, io_u->buflen,
+                       io_u->file->file_name, io_u->verify_offset, io_u->buflen,
                        (unsigned long) offset);
        return EILSEQ;
 }
@@ -831,10 +829,10 @@ static int verify_header(struct io_u *io_u, struct thread_data *td,
                        hdr->rand_seed, io_u->rand_seed);
                goto err;
        }
-       if (hdr->offset != io_u->offset + hdr_num * td->o.verify_interval) {
+       if (hdr->offset != io_u->verify_offset + hdr_num * td->o.verify_interval) {
                log_err("verify: bad header offset %"PRIu64
                        ", wanted %llu",
-                       hdr->offset, io_u->offset);
+                       hdr->offset, io_u->verify_offset);
                goto err;
        }
 
@@ -842,13 +840,11 @@ static int verify_header(struct io_u *io_u, struct thread_data *td,
         * For read-only workloads, the program cannot be certain of the
         * last numberio written to a block. Checking of numberio will be
         * done only for workloads that write data.  For verify_only,
-        * numberio will be checked in the last iteration when the correct
-        * state of numberio, that would have been written to each block
-        * in a previous run of fio, has been reached.
+        * numberio check is skipped.
         */
        if (td_write(td) && (td_min_bs(td) == td_max_bs(td)) &&
            !td->o.time_based)
-               if (!td->o.verify_only || td->o.loops == 0)
+               if (!td->o.verify_only)
                        if (hdr->numberio != io_u->numberio) {
                                log_err("verify: bad header numberio %"PRIu16
                                        ", wanted %"PRIu16,
@@ -865,12 +861,14 @@ static int verify_header(struct io_u *io_u, struct thread_data *td,
        return 0;
 
 err:
-       log_err(" at file %s offset %llu, length %u\n",
+       log_err(" at file %s offset %llu, length %u"
+               " (requested block: offset=%llu, length=%llu)\n",
                io_u->file->file_name,
-               io_u->offset + hdr_num * hdr_len, hdr_len);
+               io_u->verify_offset + hdr_num * hdr_len, hdr_len,
+               io_u->verify_offset, io_u->buflen);
 
        if (td->o.verify_dump)
-               dump_buf(p, hdr_len, io_u->offset + hdr_num * hdr_len,
+               dump_buf(p, hdr_len, io_u->verify_offset + hdr_num * hdr_len,
                                "hdr_fail", io_u->file);
 
        return EILSEQ;
@@ -1158,7 +1156,7 @@ static void __fill_hdr(struct thread_data *td, struct io_u *io_u,
        hdr->verify_type = td->o.verify;
        hdr->len = header_len;
        hdr->rand_seed = rand_seed;
-       hdr->offset = io_u->offset + header_num * td->o.verify_interval;
+       hdr->offset = io_u->verify_offset + header_num * td->o.verify_interval;
        hdr->time_sec = io_u->start_time.tv_sec;
        hdr->time_nsec = io_u->start_time.tv_nsec;
        hdr->thread = td->thread_number;
@@ -1187,6 +1185,10 @@ static void populate_hdr(struct thread_data *td, struct io_u *io_u,
 
        fill_hdr(td, io_u, hdr, header_num, header_len, io_u->rand_seed);
 
+       if (header_len <= hdr_size(td, hdr)) {
+               td_verror(td, EINVAL, "Blocksize too small");
+               return;
+       }
        data_len = header_len - hdr_size(td, hdr);
 
        data = p + hdr_size(td, hdr);
@@ -1308,8 +1310,7 @@ int get_next_verify(struct thread_data *td, struct io_u *io_u)
                /*
                 * Ensure that the associated IO has completed
                 */
-               read_barrier();
-               if (ipo->flags & IP_F_IN_FLIGHT)
+               if (atomic_load_acquire(&ipo->flags) & IP_F_IN_FLIGHT)
                        goto nothing;
 
                rb_erase(n, &td->io_hist_tree);
@@ -1321,8 +1322,7 @@ int get_next_verify(struct thread_data *td, struct io_u *io_u)
                /*
                 * Ensure that the associated IO has completed
                 */
-               read_barrier();
-               if (ipo->flags & IP_F_IN_FLIGHT)
+               if (atomic_load_acquire(&ipo->flags) & IP_F_IN_FLIGHT)
                        goto nothing;
 
                flist_del(&ipo->list);
@@ -1334,6 +1334,7 @@ int get_next_verify(struct thread_data *td, struct io_u *io_u)
                td->io_hist_len--;
 
                io_u->offset = ipo->offset;
+               io_u->verify_offset = ipo->offset;
                io_u->buflen = ipo->len;
                io_u->numberio = ipo->numberio;
                io_u->file = ipo->file;
@@ -1410,7 +1411,6 @@ static void *verify_async_thread(void *data)
                        ret = pthread_cond_wait(&td->verify_cond,
                                                        &td->io_u_lock);
                        if (ret) {
-                               pthread_mutex_unlock(&td->io_u_lock);
                                break;
                        }
                }
@@ -1631,8 +1631,7 @@ struct all_io_list *get_all_io_list(int save_mask, size_t *sz)
                        s->rand.state32.s[3] = 0;
                        s->rand.use64 = 0;
                }
-               s->name[sizeof(s->name) - 1] = '\0';
-               strncpy((char *) s->name, td->o.name, sizeof(s->name) - 1);
+               snprintf((char *) s->name, sizeof(s->name), "%s", td->o.name);
                next = io_list_next(s);
        }
 
@@ -1867,7 +1866,7 @@ int verify_state_should_stop(struct thread_data *td, struct io_u *io_u)
        for (i = 0; i < s->no_comps; i++) {
                if (s->comps[i].fileno != f->fileno)
                        continue;
-               if (io_u->offset == s->comps[i].offset)
+               if (io_u->verify_offset == s->comps[i].offset)
                        return 0;
        }