[fio.git] / verify.c

/*
 * IO verification helpers
 */
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <assert.h>

#include "fio.h"

static void fill_random_bytes(struct thread_data *td,
			      void *p, unsigned int len)
{
	unsigned int todo;
	int r;

	while (len) {
		r = os_random_long(&td->verify_state);

		/*
		 * lrand48_r seems to be broken and only fill the bottom
		 * 32-bits, even on 64-bit archs with 64-bit longs
		 */
		todo = sizeof(r);
		if (todo > len)
			todo = len;

		memcpy(p, &r, todo);

		len -= todo;
		p += todo;
	}
}

void memswp(void* buf1, void* buf2, unsigned int len)
{
	struct verify_header swap;
	memcpy(&swap, buf1, len);
	memcpy(buf1, buf2, len);
	memcpy(buf2, &swap, len);
}

static void hexdump(void *buffer, int len)
{
	unsigned char *p = buffer;
	int i;

	for (i = 0; i < len; i++)
		log_info("%02x", p[i]);
	log_info("\n");
}

static int verify_io_u_crc7(struct verify_header *hdr, struct io_u *io_u,
                            unsigned char header_num)
{
	void *p = io_u->buf + header_num * hdr->len + sizeof(*hdr);
	unsigned char c;

	c = crc7(p, hdr->len - sizeof(*hdr));

	if (c != hdr->crc7) {
		log_err("crc7: verify failed at %llu/%u\n",
		                io_u->offset + header_num * hdr->len,
				hdr->len);
		log_err("crc7: wanted %x, got %x\n", hdr->crc7, c);
		return 1;
	}

	return 0;
}

static int verify_io_u_crc16(struct verify_header *hdr, struct io_u *io_u,
                             unsigned int header_num)
{
	void *p = io_u->buf + header_num * hdr->len + sizeof(*hdr);
	unsigned short c;

	c = crc16(p, hdr->len - sizeof(*hdr));

	if (c != hdr->crc16) {
		log_err("crc16: verify failed at %llu/%u\n",
		                io_u->offset + header_num * hdr->len,
				hdr->len);
		log_err("crc16: wanted %x, got %x\n", hdr->crc16, c);
		return 1;
	}

	return 0;
}

static int verify_io_u_crc64(struct verify_header *hdr, struct io_u *io_u,
                             unsigned int header_num)
{
	void *p = io_u->buf + header_num * hdr->len + sizeof(*hdr);
	unsigned long long c;

	c = crc64(p, hdr->len - sizeof(*hdr));

	if (c != hdr->crc64) {
		log_err("crc64: verify failed at %llu/%u\n",
				io_u->offset + header_num * hdr->len,
				hdr->len);
		log_err("crc64: wanted %llx, got %llx\n", hdr->crc64, c);
		return 1;
	}

	return 0;
}

static int verify_io_u_crc32(struct verify_header *hdr, struct io_u *io_u,
		             unsigned int header_num)
{
	void *p = io_u->buf + header_num * hdr->len + sizeof(*hdr);
	unsigned long c;

	c = crc32(p, hdr->len - sizeof(*hdr));

	if (c != hdr->crc32) {
		log_err("crc32: verify failed at %llu/%u\n",
		                io_u->offset + header_num * hdr->len,
				hdr->len);
		log_err("crc32: wanted %lx, got %lx\n", hdr->crc32, c);
		return 1;
	}

	return 0;
}

static int verify_io_u_md5(struct verify_header *hdr, struct io_u *io_u,
		           unsigned int header_num)
{
	void *p = io_u->buf + header_num * hdr->len + sizeof(*hdr);
	uint32_t hash[MD5_HASH_WORDS];
	struct md5_ctx md5_ctx = {
		.hash = hash,
	};

	md5_update(&md5_ctx, p, hdr->len - sizeof(*hdr));

	if (memcmp(hdr->md5_digest, md5_ctx.hash, sizeof(md5_ctx.hash))) {
		log_err("md5: verify failed at %llu/%u\n",
		              io_u->offset + header_num * hdr->len,
		              hdr->len);
		hexdump(hdr->md5_digest, sizeof(hdr->md5_digest));
		hexdump(md5_ctx.hash, sizeof(hash));
		return 1;
	}

	return 0;
}

int verify_io_u(struct thread_data *td, struct io_u *io_u)
{
	struct verify_header *hdr;
	unsigned int hdr_inc, hdr_num = 0;
	void *p;
	int ret;

	if (td->o.verify == VERIFY_NULL || io_u->ddir != DDIR_READ)
		return 0;

	hdr_inc = io_u->buflen;
	if (td->o.header_interval)
		hdr_inc = td->o.header_interval;

	for (p = io_u->buf; p < io_u->buf + io_u->buflen; p += hdr_inc) {
		if (td->o.header_offset)
			memswp(p, p + td->o.header_offset, sizeof(*hdr));

		hdr = p;

		if (hdr->fio_magic != FIO_HDR_MAGIC) {
			log_err("Bad verify header %x\n", hdr->fio_magic);
			return EIO;
		}

		switch (hdr->verify_type) {
		case VERIFY_MD5:
			ret = verify_io_u_md5(hdr, io_u, hdr_num);
			break;
		case VERIFY_CRC64:
			ret = verify_io_u_crc64(hdr, io_u, hdr_num);
			break;
		case VERIFY_CRC32:
			ret = verify_io_u_crc32(hdr, io_u, hdr_num);
			break;
		case VERIFY_CRC16:
			ret = verify_io_u_crc16(hdr, io_u, hdr_num);
			break;
		case VERIFY_CRC7:
			ret = verify_io_u_crc7(hdr, io_u, hdr_num);
			break;
		default:
			log_err("Bad verify type %u\n", hdr->verify_type);
			ret = 1;
		}
		hdr_num++;
	}

	return 0;
}

static void fill_crc7(struct verify_header *hdr, void *p, unsigned int len)
{
	hdr->crc7 = crc7(p, len);
}

static void fill_crc16(struct verify_header *hdr, void *p, unsigned int len)
{
	hdr->crc16 = crc16(p, len);
}

static void fill_crc32(struct verify_header *hdr, void *p, unsigned int len)
{
	hdr->crc32 = crc32(p, len);
}

static void fill_crc64(struct verify_header *hdr, void *p, unsigned int len)
{
	hdr->crc64 = crc64(p, len);
}

static void fill_md5(struct verify_header *hdr, void *p, unsigned int len)
{
	struct md5_ctx md5_ctx = {
		.hash = (uint32_t *) hdr->md5_digest,
	};

	md5_update(&md5_ctx, p, len);
}

/*
 * fill body of io_u->buf with random data and add a header with the
 * crc32 or md5 sum of that data.
 */
void populate_verify_io_u(struct thread_data *td, struct io_u *io_u)
{
	struct verify_header *hdr;
	void *p = io_u->buf, *data;
	unsigned int hdr_inc, data_len;

	if (td->o.verify == VERIFY_NULL)
		return;

	fill_random_bytes(td, p, io_u->buflen);

	hdr_inc = io_u->buflen;
	if (td->o.header_interval)
		hdr_inc = td->o.header_interval;
	data_len = hdr_inc - sizeof(*hdr);

	for (;p < io_u->buf + io_u->buflen; p += hdr_inc) {
		hdr = p;

		hdr->fio_magic = FIO_HDR_MAGIC;
		hdr->verify_type = td->o.verify;
		hdr->len = hdr_inc;

		data = p + sizeof(*hdr);
		switch (td->o.verify) {
		case VERIFY_MD5:
			fill_md5(hdr, data, data_len);
			break;
		case VERIFY_CRC64:
			fill_crc64(hdr, data, data_len);
			break;
		case VERIFY_CRC32:
			fill_crc32(hdr, data, data_len);
			break;
		case VERIFY_CRC16:
			fill_crc16(hdr, data, data_len);
			break;
		case VERIFY_CRC7:
			fill_crc7(hdr, data, data_len);
			break;
		default:
			log_err("fio: bad verify type: %d\n", td->o.verify);
			assert(0);
		}
		if (td->o.header_offset)
			memswp(p, p + td->o.header_offset, sizeof(*hdr));
	}
}

int get_next_verify(struct thread_data *td, struct io_u *io_u)
{
	struct io_piece *ipo = NULL;

	/*
	 * this io_u is from a requeue, we already filled the offsets
	 */
	if (io_u->file)
		return 0;

	if (!RB_EMPTY_ROOT(&td->io_hist_tree)) {
		struct rb_node *n = rb_first(&td->io_hist_tree);

		ipo = rb_entry(n, struct io_piece, rb_node);
		rb_erase(n, &td->io_hist_tree);
	} else if (!list_empty(&td->io_hist_list)) {
		ipo = list_entry(td->io_hist_list.next, struct io_piece, list);
		list_del(&ipo->list);
	}

	if (ipo) {
		io_u->offset = ipo->offset;
		io_u->buflen = ipo->len;
		io_u->file = ipo->file;

		if ((io_u->file->flags & FIO_FILE_OPEN) == 0) {
			int r = td_io_open_file(td, io_u->file);

			if (r)
				return 1;
		}

		get_file(ipo->file);
		assert(io_u->file->flags & FIO_FILE_OPEN);
		io_u->ddir = DDIR_READ;
		io_u->xfer_buf = io_u->buf;
		io_u->xfer_buflen = io_u->buflen;
		free(ipo);
		return 0;
	}

	return 1;
}
Commit	Line	Data
	1	/*
	2	* IO verification helpers
	3	*/
	4	#include <unistd.h>
	5	#include <fcntl.h>
	6	#include <string.h>
	7	#include <assert.h>
	8
	9	#include "fio.h"
	10
	11	static void fill_random_bytes(struct thread_data *td,
	12	void *p, unsigned int len)
	13	{
	14	unsigned int todo;
	15	int r;
	16
	17	while (len) {
	18	r = os_random_long(&td->verify_state);
	19
	20	/*
	21	* lrand48_r seems to be broken and only fill the bottom
	22	* 32-bits, even on 64-bit archs with 64-bit longs
	23	*/
	24	todo = sizeof(r);
	25	if (todo > len)
	26	todo = len;
	27
	28	memcpy(p, &r, todo);
	29
	30	len -= todo;
	31	p += todo;
	32	}
	33	}
	34
	35	void memswp(void* buf1, void* buf2, unsigned int len)
	36	{
	37	struct verify_header swap;
	38	memcpy(&swap, buf1, len);
	39	memcpy(buf1, buf2, len);
	40	memcpy(buf2, &swap, len);
	41	}
	42
	43	static void hexdump(void *buffer, int len)
	44	{
	45	unsigned char *p = buffer;
	46	int i;
	47
	48	for (i = 0; i < len; i++)
	49	log_info("%02x", p[i]);
	50	log_info("\n");
	51	}
	52
	53	static int verify_io_u_crc7(struct verify_header hdr, struct io_u io_u,
	54	unsigned char header_num)
	55	{
	56	void p = io_u->buf + header_num hdr->len + sizeof(*hdr);
	57	unsigned char c;
	58
	59	c = crc7(p, hdr->len - sizeof(*hdr));
	60
	61	if (c != hdr->crc7) {
	62	log_err("crc7: verify failed at %llu/%u\n",
	63	io_u->offset + header_num * hdr->len,
	64	hdr->len);
	65	log_err("crc7: wanted %x, got %x\n", hdr->crc7, c);
	66	return 1;
	67	}
	68
	69	return 0;
	70	}
	71
	72	static int verify_io_u_crc16(struct verify_header hdr, struct io_u io_u,
	73	unsigned int header_num)
	74	{
	75	void p = io_u->buf + header_num hdr->len + sizeof(*hdr);
	76	unsigned short c;
	77
	78	c = crc16(p, hdr->len - sizeof(*hdr));
	79
	80	if (c != hdr->crc16) {
	81	log_err("crc16: verify failed at %llu/%u\n",
	82	io_u->offset + header_num * hdr->len,
	83	hdr->len);
	84	log_err("crc16: wanted %x, got %x\n", hdr->crc16, c);
	85	return 1;
	86	}
	87
	88	return 0;
	89	}
	90
	91	static int verify_io_u_crc64(struct verify_header hdr, struct io_u io_u,
	92	unsigned int header_num)
	93	{
	94	void p = io_u->buf + header_num hdr->len + sizeof(*hdr);
	95	unsigned long long c;
	96
	97	c = crc64(p, hdr->len - sizeof(*hdr));
	98
	99	if (c != hdr->crc64) {
	100	log_err("crc64: verify failed at %llu/%u\n",
	101	io_u->offset + header_num * hdr->len,
	102	hdr->len);
	103	log_err("crc64: wanted %llx, got %llx\n", hdr->crc64, c);
	104	return 1;
	105	}
	106
	107	return 0;
	108	}
	109
	110	static int verify_io_u_crc32(struct verify_header hdr, struct io_u io_u,
	111	unsigned int header_num)
	112	{
	113	void p = io_u->buf + header_num hdr->len + sizeof(*hdr);
	114	unsigned long c;
	115
	116	c = crc32(p, hdr->len - sizeof(*hdr));
	117
	118	if (c != hdr->crc32) {
	119	log_err("crc32: verify failed at %llu/%u\n",
	120	io_u->offset + header_num * hdr->len,
	121	hdr->len);
	122	log_err("crc32: wanted %lx, got %lx\n", hdr->crc32, c);
	123	return 1;
	124	}
	125
	126	return 0;
	127	}
	128
	129	static int verify_io_u_md5(struct verify_header hdr, struct io_u io_u,
	130	unsigned int header_num)
	131	{
	132	void p = io_u->buf + header_num hdr->len + sizeof(*hdr);
	133	uint32_t hash[MD5_HASH_WORDS];
	134	struct md5_ctx md5_ctx = {
	135	.hash = hash,
	136	};
	137
	138	md5_update(&md5_ctx, p, hdr->len - sizeof(*hdr));
	139
	140	if (memcmp(hdr->md5_digest, md5_ctx.hash, sizeof(md5_ctx.hash))) {
	141	log_err("md5: verify failed at %llu/%u\n",
	142	io_u->offset + header_num * hdr->len,
	143	hdr->len);
	144	hexdump(hdr->md5_digest, sizeof(hdr->md5_digest));
	145	hexdump(md5_ctx.hash, sizeof(hash));
	146	return 1;
	147	}
	148
	149	return 0;
	150	}
	151
	152	int verify_io_u(struct thread_data td, struct io_u io_u)
	153	{
	154	struct verify_header *hdr;
	155	unsigned int hdr_inc, hdr_num = 0;
	156	void *p;
	157	int ret;
	158
	159	if (td->o.verify == VERIFY_NULL \|\| io_u->ddir != DDIR_READ)
	160	return 0;
	161
	162	hdr_inc = io_u->buflen;
	163	if (td->o.header_interval)
	164	hdr_inc = td->o.header_interval;
	165
	166	for (p = io_u->buf; p < io_u->buf + io_u->buflen; p += hdr_inc) {
	167	if (td->o.header_offset)
	168	memswp(p, p + td->o.header_offset, sizeof(*hdr));
	169
	170	hdr = p;
	171
	172	if (hdr->fio_magic != FIO_HDR_MAGIC) {
	173	log_err("Bad verify header %x\n", hdr->fio_magic);
	174	return EIO;
	175	}
	176
	177	switch (hdr->verify_type) {
	178	case VERIFY_MD5:
	179	ret = verify_io_u_md5(hdr, io_u, hdr_num);
	180	break;
	181	case VERIFY_CRC64:
	182	ret = verify_io_u_crc64(hdr, io_u, hdr_num);
	183	break;
	184	case VERIFY_CRC32:
	185	ret = verify_io_u_crc32(hdr, io_u, hdr_num);
	186	break;
	187	case VERIFY_CRC16:
	188	ret = verify_io_u_crc16(hdr, io_u, hdr_num);
	189	break;
	190	case VERIFY_CRC7:
	191	ret = verify_io_u_crc7(hdr, io_u, hdr_num);
	192	break;
	193	default:
	194	log_err("Bad verify type %u\n", hdr->verify_type);
	195	ret = 1;
	196	}
	197	hdr_num++;
	198	}
	199
	200	return 0;
	201	}
	202
	203	static void fill_crc7(struct verify_header hdr, void p, unsigned int len)
	204	{
	205	hdr->crc7 = crc7(p, len);
	206	}
	207
	208	static void fill_crc16(struct verify_header hdr, void p, unsigned int len)
	209	{
	210	hdr->crc16 = crc16(p, len);
	211	}
	212
	213	static void fill_crc32(struct verify_header hdr, void p, unsigned int len)
	214	{
	215	hdr->crc32 = crc32(p, len);
	216	}
	217
	218	static void fill_crc64(struct verify_header hdr, void p, unsigned int len)
	219	{
	220	hdr->crc64 = crc64(p, len);
	221	}
	222
	223	static void fill_md5(struct verify_header hdr, void p, unsigned int len)
	224	{
	225	struct md5_ctx md5_ctx = {
	226	.hash = (uint32_t *) hdr->md5_digest,
	227	};
	228
	229	md5_update(&md5_ctx, p, len);
	230	}
	231
	232	/*
	233	* fill body of io_u->buf with random data and add a header with the
	234	* crc32 or md5 sum of that data.
	235	*/
	236	void populate_verify_io_u(struct thread_data td, struct io_u io_u)
	237	{
	238	struct verify_header *hdr;
	239	void p = io_u->buf, data;
	240	unsigned int hdr_inc, data_len;
	241
	242	if (td->o.verify == VERIFY_NULL)
	243	return;
	244
	245	fill_random_bytes(td, p, io_u->buflen);
	246
	247	hdr_inc = io_u->buflen;
	248	if (td->o.header_interval)
	249	hdr_inc = td->o.header_interval;
	250	data_len = hdr_inc - sizeof(*hdr);
	251
	252	for (;p < io_u->buf + io_u->buflen; p += hdr_inc) {
	253	hdr = p;
	254
	255	hdr->fio_magic = FIO_HDR_MAGIC;
	256	hdr->verify_type = td->o.verify;
	257	hdr->len = hdr_inc;
	258
	259	data = p + sizeof(*hdr);
	260	switch (td->o.verify) {
	261	case VERIFY_MD5:
	262	fill_md5(hdr, data, data_len);
	263	break;
	264	case VERIFY_CRC64:
	265	fill_crc64(hdr, data, data_len);
	266	break;
	267	case VERIFY_CRC32:
	268	fill_crc32(hdr, data, data_len);
	269	break;
	270	case VERIFY_CRC16:
	271	fill_crc16(hdr, data, data_len);
	272	break;
	273	case VERIFY_CRC7:
	274	fill_crc7(hdr, data, data_len);
	275	break;
	276	default:
	277	log_err("fio: bad verify type: %d\n", td->o.verify);
	278	assert(0);
	279	}
	280	if (td->o.header_offset)
	281	memswp(p, p + td->o.header_offset, sizeof(*hdr));
	282	}
	283	}
	284
	285	int get_next_verify(struct thread_data td, struct io_u io_u)
	286	{
	287	struct io_piece *ipo = NULL;
	288
	289	/*
	290	* this io_u is from a requeue, we already filled the offsets
	291	*/
	292	if (io_u->file)
	293	return 0;
	294
	295	if (!RB_EMPTY_ROOT(&td->io_hist_tree)) {
	296	struct rb_node *n = rb_first(&td->io_hist_tree);
	297
	298	ipo = rb_entry(n, struct io_piece, rb_node);
	299	rb_erase(n, &td->io_hist_tree);
	300	} else if (!list_empty(&td->io_hist_list)) {
	301	ipo = list_entry(td->io_hist_list.next, struct io_piece, list);
	302	list_del(&ipo->list);
	303	}
	304
	305	if (ipo) {
	306	io_u->offset = ipo->offset;
	307	io_u->buflen = ipo->len;
	308	io_u->file = ipo->file;
	309
	310	if ((io_u->file->flags & FIO_FILE_OPEN) == 0) {
	311	int r = td_io_open_file(td, io_u->file);
	312
	313	if (r)
	314	return 1;
	315	}
	316
	317	get_file(ipo->file);
	318	assert(io_u->file->flags & FIO_FILE_OPEN);
	319	io_u->ddir = DDIR_READ;
	320	io_u->xfer_buf = io_u->buf;
	321	io_u->xfer_buflen = io_u->buflen;
	322	free(ipo);
	323	return 0;
	324	}
	325
	326	return 1;
	327	}