X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=verify.c;h=eb8eddc78906f4b0dcaa13a9899495e5a8670dca;hp=66b3ef0d36583d1f7a045821b139b3961d5d03f5;hb=8e8b225d177c8e824785a87a1116309049a27a7c;hpb=c7e6ae4eb46c4e294df85ee4f7dc4c71d458daad

diff --git a/verify.c b/verify.c
index 66b3ef0d..eb8eddc7 100644
--- a/verify.c
+++ b/verify.c
@@ -36,41 +36,27 @@ void fill_pattern(struct thread_data *td, void *p, unsigned int len, struct io_u
 		if (use_seed)
 			__fill_random_buf(p, len, seed);
 		else
-			io_u->rand_seed = fill_random_buf(p, len);
+			io_u->rand_seed = fill_random_buf(&td->buf_state, p, len);
 		break;
 	case 1:
-		/*
-		 * See below write barrier comment
-		 */
-#if 0
-		read_barrier();
 		if (io_u->buf_filled_len >= len) {
 			dprint(FD_VERIFY, "using already filled verify pattern b=0 len=%u\n", len);
 			return;
 		}
-#endif
 		dprint(FD_VERIFY, "fill verify pattern b=0 len=%u\n", len);
 		memset(p, td->o.verify_pattern[0], len);
-		/*
-		 * We need to ensure that the pattern stores are seen before
-		 * the fill length store, or we could observe headers that
-		 * aren't valid to the extent notified by the fill length
-		 */
-		write_barrier();
 		io_u->buf_filled_len = len;
 		break;
 	default: {
 		unsigned int i = 0, size = 0;
 		unsigned char *b = p;
 
-#if 0
-		read_barrier();
 		if (io_u->buf_filled_len >= len) {
 			dprint(FD_VERIFY, "using already filled verify pattern b=%d len=%u\n",
 					td->o.verify_pattern_bytes, len);
 			return;
 		}
-#endif
+
 		dprint(FD_VERIFY, "fill verify pattern b=%d len=%u\n",
 					td->o.verify_pattern_bytes, len);
 
@@ -81,7 +67,6 @@ void fill_pattern(struct thread_data *td, void *p, unsigned int len, struct io_u
 			memcpy(b+i, td->o.verify_pattern, size);
 			i += size;
 		}
-		write_barrier();
 		io_u->buf_filled_len = len;
 		break;
 		}
@@ -179,6 +164,9 @@ static inline unsigned int __hdr_size(int verify_type)
 	case VERIFY_SHA1:
 		len = sizeof(struct vhdr_sha1);
 		break;
+	case VERIFY_PATTERN:
+		len = 0;
+		break;
 	default:
 		log_err("fio: unknown verify header!\n");
 		assert(0);
@@ -266,6 +254,9 @@ static void dump_verify_buffers(struct verify_header *hdr, struct vcont *vc)
 	struct io_u dummy;
 	void *buf;
 
+	if (!td->o.verify_dump)
+		return;
+
 	/*
 	 * Dump the contents we just read off disk
 	 */
@@ -317,20 +308,80 @@ static inline void *io_u_verify_off(struct verify_header *hdr, struct vcont *vc)
 	return vc->io_u->buf + vc->hdr_num * hdr->len + hdr_size(hdr);
 }
 
-static int verify_io_u_meta(struct verify_header *hdr, struct thread_data *td,
-			    struct vcont *vc)
+static unsigned int hweight8(unsigned int w)
+{
+	unsigned int res = w - ((w >> 1) & 0x55);
+
+	res = (res & 0x33) + ((res >> 2) & 0x33);
+	return (res + (res >> 4)) & 0x0F;
+}
+
+static int verify_io_u_pattern(struct verify_header *hdr, struct vcont *vc)
+{
+	struct thread_data *td = vc->td;
+	struct io_u *io_u = vc->io_u;
+	char *buf, *pattern;
+	unsigned int header_size = __hdr_size(td->o.verify);
+	unsigned int len, mod, i, size, pattern_size;
+
+	pattern = td->o.verify_pattern;
+	pattern_size = td->o.verify_pattern_bytes;
+	if (pattern_size <= 1)
+		pattern_size = MAX_PATTERN_SIZE;
+	buf = (void *) hdr + header_size;
+	len = get_hdr_inc(td, io_u) - header_size;
+	mod = header_size % pattern_size;
+
+	for (i = 0; i < len; i += size) {
+		size = pattern_size - mod;
+		if (size > (len - i))
+			size = len - i;
+		if (memcmp(buf + i, pattern + mod, size))
+			// Let the slow compare find the first mismatch byte.
+			break;
+		mod = 0;
+	}
+
+	for (; i < len; i++) {
+		if (buf[i] != pattern[mod]) {
+			unsigned int bits;
+
+			bits = hweight8(buf[i] ^ pattern[mod]);
+			log_err("fio: got pattern %x, wanted %x. Bad bits %d\n",
+				buf[i], pattern[mod], bits);
+			log_err("fio: bad pattern block offset %u\n", i);
+			dump_verify_buffers(hdr, vc);
+			return EILSEQ;
+		}
+		mod++;
+		if (mod == td->o.verify_pattern_bytes)
+			mod = 0;
+	}
+
+	return 0;
+}
+
+static int verify_io_u_meta(struct verify_header *hdr, struct vcont *vc)
 {
+	struct thread_data *td = vc->td;
 	struct vhdr_meta *vh = hdr_priv(hdr);
 	struct io_u *io_u = vc->io_u;
+	int ret = EILSEQ;
 
 	dprint(FD_VERIFY, "meta verify io_u %p, len %u\n", io_u, hdr->len);
 
 	if (vh->offset == io_u->offset + vc->hdr_num * td->o.verify_interval)
+		ret = 0;
+
+	if (td->o.verify_pattern_bytes)
+		ret |= verify_io_u_pattern(hdr, vc);
+
+	if (!ret)
 		return 0;
 
 	vc->name = "meta";
 	log_verify_failure(hdr, vc);
-	return EILSEQ;
+	return ret;
 }
 
 static int verify_io_u_sha512(struct verify_header *hdr, struct vcont *vc)
@@ -541,46 +592,6 @@ static int verify_io_u_md5(struct verify_header *hdr, struct vcont *vc)
 	return EILSEQ;
 }
 
-static unsigned int hweight8(unsigned int w)
-{
-	unsigned int res = w - ((w >> 1) & 0x55);
-
-	res = (res & 0x33) + ((res >> 2) & 0x33);
-	return (res + (res >> 4)) & 0x0F;
-}
-
-int verify_io_u_pattern(struct verify_header *hdr, struct vcont *vc)
-{
-	struct thread_data *td = vc->td;
-	struct io_u *io_u = vc->io_u;
-	char *buf, *pattern;
-	unsigned int hdr_size = __hdr_size(td->o.verify);
-	unsigned int len, mod, i;
-
-	pattern = td->o.verify_pattern;
-	buf = (void *) hdr + hdr_size;
-	len = get_hdr_inc(td, io_u) - hdr_size;
-	mod = hdr_size % td->o.verify_pattern_bytes;
-
-	for (i = 0; i < len; i++) {
-		if (buf[i] != pattern[mod]) {
-			unsigned int bits;
-
-			bits = hweight8(buf[i] ^ pattern[mod]);
-			log_err("fio: got pattern %x, wanted %x. Bad bits %d\n",
-				buf[i], pattern[mod], bits);
-			log_err("fio: bad pattern block offset %u\n", i);
-			dump_verify_buffers(hdr, vc);
-			return EILSEQ;
-		}
-		mod++;
-		if (mod == td->o.verify_pattern_bytes)
-			mod = 0;
-	}
-
-	return 0;
-}
-
 /*
  * Push IO verification to a separate thread
  */
@@ -589,10 +600,8 @@ int verify_io_u_async(struct thread_data *td, struct io_u *io_u)
 	if (io_u->file)
 		put_file_log(td, io_u->file);
 
-	io_u->file = NULL;
-
 	pthread_mutex_lock(&td->io_u_lock);
-	
+
 	if (io_u->flags & IO_U_F_IN_CUR_DEPTH) {
 		td->cur_depth--;
 		io_u->flags &= ~IO_U_F_IN_CUR_DEPTH;
@@ -643,7 +652,7 @@ static int verify_trimmed_io_u(struct thread_data *td, struct io_u *io_u)
 int verify_io_u(struct thread_data *td, struct io_u *io_u)
 {
 	struct verify_header *hdr;
-	unsigned int hdr_size, hdr_inc, hdr_num = 0;
+	unsigned int header_size, hdr_inc, hdr_num = 0;
 	void *p;
 	int ret;
 
@@ -668,9 +677,9 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u)
 		if (ret && td->o.verify_fatal)
 			break;
 
-		hdr_size = __hdr_size(td->o.verify);
+		header_size = __hdr_size(td->o.verify);
 		if (td->o.verify_offset)
-			memswp(p, p + td->o.verify_offset, hdr_size);
+			memswp(p, p + td->o.verify_offset, header_size);
 		hdr = p;
 
 		if (hdr->fio_magic != FIO_HDR_MAGIC) {
@@ -681,25 +690,6 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u)
 			return EILSEQ;
 		}
 
-		if (td->o.verify_pattern_bytes) {
-			dprint(FD_VERIFY, "pattern verify io_u %p, len %u\n",
-								io_u, hdr->len);
-			ret = verify_io_u_pattern(hdr, &vc);
-			if (ret) {
-				log_err("pattern: verify failed at file %s offset %llu, length %u\n",
-					io_u->file->file_name,
-					io_u->offset + hdr_num * hdr->len,
-					hdr->len);
-			}
-
-			/*
-			 * Also verify the meta data, if applicable
-			 */
-			if (hdr->verify_type == VERIFY_META)
-				ret |= verify_io_u_meta(hdr, td, &vc);
-			continue;
-		}
-
 		switch (hdr->verify_type) {
 		case VERIFY_MD5:
 			ret = verify_io_u_md5(hdr, &vc);
@@ -727,11 +717,14 @@ int verify_io_u(struct thread_data *td, struct io_u *io_u)
 			ret = verify_io_u_sha512(hdr, &vc);
 			break;
 		case VERIFY_META:
-			ret = verify_io_u_meta(hdr, td, &vc);
+			ret = verify_io_u_meta(hdr, &vc);
 			break;
 		case VERIFY_SHA1:
 			ret = verify_io_u_sha1(hdr, &vc);
 			break;
+		case VERIFY_PATTERN:
+			ret = verify_io_u_pattern(hdr, &vc);
+			break;
 		default:
 			log_err("Bad verify type %u\n", hdr->verify_type);
 			ret = EINVAL;
@@ -910,6 +903,9 @@ static void populate_hdr(struct thread_data *td, struct io_u *io_u,
 						io_u, hdr->len);
 		fill_sha1(hdr, data, data_len);
 		break;
+	case VERIFY_PATTERN:
+		/* nothing to do here */
+		break;
 	default:
 		log_err("fio: bad verify type: %d\n", td->o.verify);
 		assert(0);
@@ -1035,7 +1031,7 @@ static void *verify_async_thread(void *data)
 			put_io_u(td, io_u);
 			if (!ret)
 				continue;
-			if (td->o.continue_on_error &&
+			if (td->o.continue_on_error & ERROR_TYPE_VERIFY &&
 			    td_non_fatal_error(ret)) {
 				update_error_count(td, ret);
 				td_clear_error(td);