t/nvmept_trim: increase transfer size for some tests

[fio.git] / verify.c

diff --git a/verify.c b/verify.c
index d6a229cac3f1c9b9aa05cad38e9b623ccafabd2f..b2fede24710fd3fcedfbcda890b3b9def9a957be 100644 (file)
--- a/verify.c
+++ b/verify.c
@@ -338,12 +338,20 @@ static void dump_verify_buffers(struct verify_header *hdr, struct vcont *vc)
 static void log_verify_failure(struct verify_header *hdr, struct vcont *vc)
 {
        unsigned long long offset;
+       uint32_t len;
+       struct thread_data *td = vc->td;
 
        offset = vc->io_u->verify_offset;
-       offset += vc->hdr_num * hdr->len;
+       if (td->o.verify != VERIFY_PATTERN_NO_HDR) {
+               len = hdr->len;
+               offset += (unsigned long long) vc->hdr_num * len;
+       } else {
+               len = vc->io_u->buflen;
+       }
+
        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->name, vc->io_u->file->file_name, offset, len,
                        vc->io_u->verify_offset, vc->io_u->buflen, vc->io_u->flags);
 
        if (vc->good_crc && vc->bad_crc) {
@@ -398,7 +406,8 @@ static int verify_io_u_pattern(struct verify_header *hdr, struct vcont *vc)
                                (unsigned char)buf[i],
                                (unsigned char)pattern[mod],
                                bits);
-                       log_err("fio: bad pattern block offset %u\n", i);
+                       log_err("fio: bad pattern block offset %u\n",
+                               i + header_size);
                        vc->name = "pattern";
                        log_verify_failure(hdr, vc);
                        return EILSEQ;
@@ -917,9 +926,11 @@ int verify_io_u(struct thread_data *td, struct io_u **io_u_ptr)
                hdr = p;
 
                /*
-                * Make rand_seed check pass when have verify_backlog.
+                * Make rand_seed check pass when have verify_backlog or
+                * zone reset frequency for zonemode=zbd.
                 */
-               if (!td_rw(td) || (td->flags & TD_F_VER_BACKLOG))
+               if (!td_rw(td) || (td->flags & TD_F_VER_BACKLOG) ||
+                   td->o.zrf.u.f)
                        io_u->rand_seed = hdr->rand_seed;
 
                if (td->o.verify != VERIFY_PATTERN_NO_HDR) {
@@ -1566,10 +1577,9 @@ static int fill_file_completions(struct thread_data *td,
 struct all_io_list *get_all_io_list(int save_mask, size_t *sz)
 {
        struct all_io_list *rep;
-       struct thread_data *td;
        size_t depth;
        void *next;
-       int i, nr;
+       int nr;
 
        compiletime_assert(sizeof(struct all_io_list) == 8, "all_io_list");
 
@@ -1579,14 +1589,14 @@ struct all_io_list *get_all_io_list(int save_mask, size_t *sz)
         */
        depth = 0;
        nr = 0;
-       for_each_td(td, i) {
-               if (save_mask != IO_LIST_ALL && (i + 1) != save_mask)
+       for_each_td(td) {
+               if (save_mask != IO_LIST_ALL && (__td_index + 1) != save_mask)
                        continue;
                td->stop_io = 1;
                td->flags |= TD_F_VSTATE_SAVED;
                depth += (td->o.iodepth * td->o.nr_files);
                nr++;
-       }
+       } end_for_each();
 
        if (!nr)
                return NULL;
@@ -1594,26 +1604,25 @@ struct all_io_list *get_all_io_list(int save_mask, size_t *sz)
        *sz = sizeof(*rep);
        *sz += nr * sizeof(struct thread_io_list);
        *sz += depth * sizeof(struct file_comp);
-       rep = malloc(*sz);
-       memset(rep, 0, *sz);
+       rep = calloc(1, *sz);
 
        rep->threads = cpu_to_le64((uint64_t) nr);
 
        next = &rep->state[0];
-       for_each_td(td, i) {
+       for_each_td(td) {
                struct thread_io_list *s = next;
                unsigned int comps, index = 0;
 
-               if (save_mask != IO_LIST_ALL && (i + 1) != save_mask)
+               if (save_mask != IO_LIST_ALL && (__td_index + 1) != save_mask)
                        continue;
 
                comps = fill_file_completions(td, s, &index);
 
                s->no_comps = cpu_to_le64((uint64_t) comps);
-               s->depth = cpu_to_le64((uint64_t) td->o.iodepth);
-               s->nofiles = cpu_to_le64((uint64_t) td->o.nr_files);
+               s->depth = cpu_to_le32((uint32_t) td->o.iodepth);
+               s->nofiles = cpu_to_le32((uint32_t) td->o.nr_files);
                s->numberio = cpu_to_le64((uint64_t) td->io_issues[DDIR_WRITE]);
-               s->index = cpu_to_le64((uint64_t) i);
+               s->index = cpu_to_le64((uint64_t) __td_index);
                if (td->random_state.use64) {
                        s->rand.state64.s[0] = cpu_to_le64(td->random_state.state64.s1);
                        s->rand.state64.s[1] = cpu_to_le64(td->random_state.state64.s2);
@@ -1631,7 +1640,7 @@ struct all_io_list *get_all_io_list(int save_mask, size_t *sz)
                }
                snprintf((char *) s->name, sizeof(s->name), "%s", td->o.name);
                next = io_list_next(s);
-       }
+       } end_for_each();
 
        return rep;
 }
@@ -1648,6 +1657,10 @@ static int open_state_file(const char *name, const char *prefix, int num,
        else
                flags = O_RDONLY;
 
+#ifdef _WIN32
+       flags |= O_BINARY;
+#endif
+
        verify_state_gen_name(out, sizeof(out), name, prefix, num);
 
        fd = open(out, flags, 0644);