From bfb41d98f63cb9fb72cb7c82618be10bc6d52c33 Mon Sep 17 00:00:00 2001 From: Jens Axboe Date: Fri, 10 Aug 2007 13:56:08 +0200 Subject: [PATCH] Remove verify_pattern option, replace with verify=pattern:x Integrate the pattern verification with the other verify types, it's much cleaner that way. Signed-off-by: Jens Axboe --- HOWTO | 17 +++++++++-------- fio.h | 1 + options.c | 35 ++++++++++++++++++++++++----------- verify.c | 27 ++++++++++++++------------- 4 files changed, 48 insertions(+), 32 deletions(-) diff --git a/HOWTO b/HOWTO index 3bee1a2d..6ece3c18 100644 --- a/HOWTO +++ b/HOWTO @@ -599,6 +599,15 @@ verify=str If writing to a file, fio can verify the file contents (timestamp, block number etc.). The block number is verified. + pattern Fill the IO buffers with a specific pattern, + that we can use to verify. Depending on the + width of the pattern, fio will fill 1/2/3/4 + bytes of the buffer at the time. The pattern + cannot be larger than a 32-bit quantity. The + given pattern is given as a postfix to this + option, ala: verify=pattern:0x5a. It accepts + both hex and dec values. + null Only pretend to verify. Useful for testing internals with ioengine=null, not for much else. @@ -624,14 +633,6 @@ verify_interval=siint Write the verification header at a finer granularity size of header_interval. blocksize should divide this evenly. -verify_pattern=int If set, fio will fill the io buffers with this - pattern. Fio defaults to filling with totally random - bytes, but sometimes it's interesting to fill with a known - pattern for io verification purposes. Depending on the - width of the pattern, fio will fill 1/2/3/4 bytes of the - buffer at the time. The verify_pattern cannot be larger than - a 32-bit quantity. - verify_fatal=bool Normally fio will keep checking the entire contents before quitting on a block verification failure. If this option is set, fio will exit the job on the first observed diff --git a/fio.h b/fio.h index 6b111555..c202b0dc 100644 --- a/fio.h +++ b/fio.h @@ -198,6 +198,7 @@ enum { VERIFY_SHA256, /* sha256 sum data blocks */ VERIFY_SHA512, /* sha512 sum data blocks */ VERIFY_META, /* block_num, timestamp etc. */ + VERIFY_PATTERN, /* verify a specific pattern */ VERIFY_NULL, /* pretend to verify */ }; diff --git a/options.c b/options.c index f1ee6bcf..82d5ff51 100644 --- a/options.c +++ b/options.c @@ -217,12 +217,27 @@ static int str_verify_offset_cb(void *data, unsigned int *off) return 0; } -static int str_verify_pattern_cb(void *data, unsigned int *off) +static int str_verify_cb(void *data, const char *mem) { struct thread_data *td = data; - unsigned int msb; + unsigned int nr, msb; + char *pat; - msb = fls(*off); + if (td->o.verify != VERIFY_PATTERN) + return 0; + + pat = get_opt_postfix(mem); + if (!pat) { + log_err("fio: missing pattern\n"); + return 1; + } + + if (strstr(pat, "0x") || strstr(pat, "0X")) + nr = strtol(pat, NULL, 16); + else + nr = strtol(pat, NULL, 16); + + msb = fls(nr); if (msb <= 8) td->o.verify_pattern_bytes = 1; else if (msb <= 16) @@ -232,7 +247,7 @@ static int str_verify_pattern_cb(void *data, unsigned int *off) else td->o.verify_pattern_bytes = 4; - td->o.verify_pattern = *off; + td->o.verify_pattern = nr; return 0; } @@ -603,6 +618,7 @@ static struct fio_option options[] = { .name = "verify", .type = FIO_OPT_STR, .off1 = td_var_offset(verify), + .cb = str_verify_cb, .help = "Verify data written", .def = "0", .posval = { @@ -642,6 +658,10 @@ static struct fio_option options[] = { .oval = VERIFY_META, .help = "Use io information", }, + { .ival = "pattern", + .oval = VERIFY_PATTERN, + .help = "Verify a specific buffer pattern", + }, { .ival = "null", .oval = VERIFY_NULL, @@ -681,13 +701,6 @@ static struct fio_option options[] = { .cb = str_verify_offset_cb, .parent = "verify", }, - { - .name = "verify_pattern", - .type = FIO_OPT_INT, - .cb = str_verify_pattern_cb, - .help = "Fill pattern for IO buffers", - .parent = "verify", - }, { .name = "verify_fatal", .type = FIO_OPT_BOOL, diff --git a/verify.c b/verify.c index 8427b6f9..2acd216d 100644 --- a/verify.c +++ b/verify.c @@ -112,6 +112,7 @@ static inline unsigned int __hdr_size(int verify_type) switch (verify_type) { case VERIFY_NONE: case VERIFY_NULL: + case VERIFY_PATTERN: len = 0; break; case VERIFY_MD5: @@ -405,19 +406,6 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u) return EIO; } - if (td->o.verify_pattern_bytes) { - ret = verify_io_u_pattern(td->o.verify_pattern, - td->o.verify_pattern_bytes, - p + hdr_size, - hdr_inc - hdr_size, - hdr_size % 4); - if (ret) - log_err("fio: verify failed at %llu/%u\n", - io_u->offset + hdr_num * hdr->len, - hdr->len); - continue; - } - switch (hdr->verify_type) { case VERIFY_MD5: ret = verify_io_u_md5(hdr, io_u, hdr_num); @@ -443,6 +431,17 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u) case VERIFY_META: ret = verify_io_u_meta(hdr, td, io_u, hdr_num); break; + case VERIFY_PATTERN: + ret = verify_io_u_pattern(td->o.verify_pattern, + td->o.verify_pattern_bytes, + p + hdr_size, + hdr_inc - hdr_size, + hdr_size % 4); + if (ret) + log_err("fio: verify failed at %llu/%u\n", + io_u->offset + hdr_num * hdr->len, + hdr->len); + break; default: log_err("Bad verify type %u\n", hdr->verify_type); ret = 1; @@ -581,6 +580,8 @@ void populate_verify_io_u(struct thread_data *td, struct io_u *io_u) case VERIFY_META: fill_meta(hdr, td, io_u, header_num); break; + case VERIFY_PATTERN: + break; default: log_err("fio: bad verify type: %d\n", td->o.verify); assert(0); -- 2.25.1