#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"
__fill_random_buf_percentage(seed, p, o->compress_percentage, len, len, o->buffer_pattern, o->buffer_pattern_bytes);
}
-static uint64_t 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, uint64_t seed, int use_seed)
{
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;
}
*/
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);
/*
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);
}
{
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"
- " (requested block: offset=%llu, length=%llu)\n",
+ " (requested block: offset=%llu, length=%llu, flags=%x)\n",
vc->name, vc->io_u->file->file_name, offset, hdr->len,
- vc->io_u->offset, vc->io_u->buflen);
+ vc->io_u->verify_offset, vc->io_u->buflen, vc->io_u->flags);
if (vc->good_crc && vc->bad_crc) {
log_err(" Expected CRC: ");
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;
}
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;
}
* 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,
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->offset, io_u->buflen);
+ 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;
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;
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);
/*
* 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);
/*
* 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);
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;
ret = pthread_cond_wait(&td->verify_cond,
&td->io_u_lock);
if (ret) {
- pthread_mutex_unlock(&td->io_u_lock);
break;
}
}
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;
}