tools/diskomizer/buf_init.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

#pragma ident	"@(#)buf_init.c	1.8	09/05/26 SMI"

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Routines for inializing read and write buffers.
 */
#include <sys/types.h>
#include <sys/isa_defs.h>
#include <search.h>
#include "args.h"
#include "diskomizer64mpism.h"
#include "buf_init.h"

static uchar_t seq8(int, int);
static uchar_t rseq8(int, int);
static uchar_t seq16(int, int);
static uchar_t rseq16(int, int);
static uchar_t seq32(int, int);
static uchar_t rseq32(int, int);
static uchar_t seq64(int, int);
static uchar_t rseq64(int, int);
static uchar_t random_value(int, int);
static uchar_t fixed_value_func(int, int);
static uchar_t cjtpat_func(int, int);
static uchar_t isipat_func(int, int);
static uchar_t cjt_and_isi_func(int bufno, int i);
static uchar_t userpat_func(int, int);

static void rbufinit_init(uchar_t *, ulong_t len, const uchar_t * const);
static void zero_init(uchar_t *, ulong_t len, const uchar_t * const);
static void xor_init(uchar_t *, ulong_t len, const uchar_t * const);
static int rinit_init(uint64_t value);
static int cinit_init(uint64_t value);
static int userpat_init(struct ilist  *, int *, int);

static uint64_t *read_buf_source;

static struct ilist fixed_value;

typedef int (*init_init_t)(struct ilist  *, int *, int);

struct write_buf_initializers {
	const char *name;
	write_buf_initializer_t func; /* error handleing function */
	init_init_t init;
	int val;
};

typedef int (*rinit_init_t)(uint64_t);

struct read_buf_initializers {
	const char *name;
	read_buf_initializer_t func;
	rinit_init_t init;
	uint64_t val;
};

struct write_buf_initializers write_buf_initializers[] = {
	{"ONES", fixed_value_func, load_ilist, ~0},
	{"ZEROS", fixed_value_func, load_ilist, 0},
	{"SUPPLIED_VALUE", fixed_value_func, NULL, 0},
	{"SEQ", seq8, NULL, 0}, /* for compatability */
	{"RSEQ", rseq8, NULL, 0}, /* for compatability */
	{"SEQ8", seq8, NULL, 0},
	{"SREQ8", rseq8, NULL, 0},
	{"SEQ16", seq16, NULL, 0},
	{"SREQ16", rseq16, NULL, 0},
	{"SEQ32", seq32, NULL, 0},
	{"SREQ32", rseq32, NULL, 0},
	{"SEQ64", seq64, NULL, 0},
	{"SREQ64", rseq64, NULL, 0},
	{"RANDOM", random_value, NULL, 0},
	{"CJTPAT", cjtpat_func, NULL, 0},
	{"ISIPAT", isipat_func, NULL, 0},
	{"ISI_AND_CJT_PAT", cjt_and_isi_func, NULL, 0},
	{"USERPAT", userpat_func, userpat_init, 0}
};

static size_t nel_write_buf_initializers = ARRAY_LEN(write_buf_initializers);

struct read_buf_initializers read_buf_initializers[] = {
	{"DEADBEEF", rbufinit_init, rinit_init, 0xDEADBEEFDEADBEEFULL},
	{"DEADBEEF_64", rbufinit_init, rinit_init, 0xDEADBEEFULL},
	{"SUPPLIED_VALUE", rbufinit_init, cinit_init, 0ULL},
	{"ZERO", zero_init, NULL, 0ULL},
	{"ZERO_ONE", rbufinit_init, rinit_init, 0x5555555555555555ULL},
	{"ONE_ZERO", rbufinit_init, rinit_init, 0xAAAAAAAAAAAAAAAAULL},
	{"XOR", xor_init, NULL, 0ULL},
	{"NOP", (read_buf_initializer_t)nop, NULL, 0ULL},
	{"NONE", (read_buf_initializer_t)nop, NULL, 0ULL}
};

static size_t nel_read_buf_initializers = ARRAY_LEN(read_buf_initializers);

struct {
	uchar_t *buf;
	size_t len;
} userpat_data;

/*
 * Macro to return the correct char to give bigendian data all the time.
 */
#ifdef _BIG_ENDIAN

#define	RETURN_CHAR(X, I) return (X.c[(I) % sizeof (X)])

#elif defined(_LITTLE_ENDIAN)

#define	RETURN_CHAR(X, I) return (X.c[(sizeof (X) - 1) - ((I) % sizeof (X))])

#else

/* This "can't" happen! */
#error "niether _BIG_ENDIAN or _LITTLE_ENDIAN defined"

#endif

/*
 * Seq8().  Returns an 8 bit quantity. Each
 * of the 8 bit quantinites are set following a standard pattern, which in
 * its simplest would be  just a sequence from 0 to 255. However since the
 * by initialising from 0 to 250, giving 251 values, we make the combination
 * of pattern and position of the pattern in a block not repeat for 251
 * blocks.  By then shifting each value by a variable amount between 0 and 4
 * depending on each block we move the number of blocks before the pattern
 * posistion pair repeats up to 1255 blocks.
 *
 * You end up with 5 blocks of X-Y inclusive:
 *
 *	0-250
 *	1-251
 *	2-252
 *	3-253
 *	4-254
 *
 *	The final pattern you see in the data is of this form:
 *
 *	0-250
 *	1-251
 *	2-252
 *	3-253
 *	4-254
 *	0-250
 *	1-251
 *	2-252
 *	3-253
 *	4-254
 *
 *
 * 251 and 5 are used as 251 is the largest prime less than or equal to
 * 256 and 5 is the largest prime that when added to to 251 gives less than 256.
 */
static uchar_t
seq8(int bufno, int i)
{
	uchar_t x, y, c;
	ulong_t len = INDEX_TO_DIOLEN(max_disk_io_len);
	ulong_t bufoff = (bufno * len) + i;

	x = bufoff % 251;
	y = (bufoff / 251) % 5;

	c = x + y;
	return (c);
}

static uchar_t
rseq8(int bufno, int i)
{
	return (0xff - seq8(bufno, i));
}
/*
 * the key primes for 16 bit numbers are 13 and 65521. Apart from
 * that the theory is the same as for the 8 bit numbers.
 */
static uint16_t
seq16gen(int bufno, int i)
{
	uint16_t x, y, s;
	ulong_t len = INDEX_TO_DIOLEN(max_disk_io_len);
	ulong_t bufoff = ((bufno * len) + i) / sizeof (uint16_t);

	x = bufoff % 65521;
	y = (bufoff / 65521) % 13;

	s = x + y;
	return (s);
}

static uchar_t
seq16(int bufno, int i)
{
	union {
		uchar_t c[sizeof (uint16_t)];
		uint16_t s;
	} u;

	u.s = seq16gen(bufno, i);

	RETURN_CHAR(u, i);
}

static uchar_t
rseq16(int bufno, int i)
{
	union {
		uchar_t c[sizeof (uint16_t)];
		uint16_t s;
	} u;

	u.s = USHRT_MAX - seq16gen(bufno, i);

	RETURN_CHAR(u, i);
}

/*
 * For 32 bit numbers the primes are: 4294967291 and 3
 */
static uint32_t
seq32gen(int bufno, int i)
{
	uint32_t x, y, s;
	ulong_t len = INDEX_TO_DIOLEN(max_disk_io_len);
	ulong_t bufoff = ((bufno * len) + i) / sizeof (uint32_t);

	x = bufoff % 4294967291LL;
	y = (bufoff / 4294967291LL) % 3;

	s = x + y;
	return (s);
}

static uchar_t
seq32(int bufno, int i)
{
	union {
		uchar_t c[sizeof (uint32_t)];
		uint32_t i;
	} u;

	u.i = seq32gen(bufno, i);

	RETURN_CHAR(u, i);
}

static uchar_t
rseq32(int bufno, int i)
{
	union {
		uchar_t c[sizeof (uint32_t)];
		uint32_t i;
	} u;

	u.i = UINT_MAX - seq32gen(bufno, i);

	RETURN_CHAR(u, i);
}

/*
 * For 64 bit numbers we are just not going to repeat so don't
 * do the prime bit.
 */
static uint64_t
seq64gen(int bufno, int i)
{
	uint64_t len = INDEX_TO_DIOLEN(max_disk_io_len);
	uint64_t bufoff = ((bufno * len) + i) / sizeof (uint64_t);

	return (bufoff);
}

static uchar_t
seq64(int bufno, int i)
{
	union {
		uchar_t c[sizeof (uint64_t)];
		uint64_t l;
	} u;

	u.l = seq64gen(bufno, i);

	RETURN_CHAR(u, i);
}

static uchar_t
rseq64(int bufno, int i)
{
	union {
		uchar_t c[sizeof (uint64_t)];
		uint64_t l;
	} u;

	u.l = 0xffffffffffffffffULL - seq64gen(bufno, i);

	RETURN_CHAR(u, i);
}

/*ARGSUSED*/
static uchar_t
random_value(int bufno, int i)
{
	return ((uchar_t)(lrand48() >> 8));
}

static uint_t
get_fixed_value(int bufno)
{
	if (fixed_value.weightings == NULL)
		return (fixed_value.vals[bufno % fixed_value.wlen]);
	else
		return (fixed_value.vals[fixed_value.weightings[bufno
		    % fixed_value.wlen]]);
}

/*
 * Users can supply 32 bit fixed values. So this function has to give
 * them back in the correct way.
 */
/*ARGSUSED*/
static uchar_t
fixed_value_func(int bufno, int i)
{
	union {
		uchar_t c[sizeof (uint32_t)];
		uint32_t i;
	} u;

	u.i = get_fixed_value(bufno);

	return (u.c[i % sizeof (uint32_t)]);
}

static int
wb_key_cmp(const void *k, const void *v)
{
	return (strcasecmp((char *)k,
	    ((struct write_buf_initializers *)v)->name));
}

write_buf_initializer_t
setup_write_buf_initializer(void)
{
	struct write_buf_initializers *r;

	fixed_value = opts.write_buffer_supplied_value;

	r = (struct write_buf_initializers *)lfind(
	    opts.initializer, write_buf_initializers,
	    &nel_write_buf_initializers,
	    sizeof (write_buf_initializers[0]),
	    wb_key_cmp);

	if (r != NULL) {
		if (r->init != NULL) {
			if (r->init(&fixed_value, &r->val, 1) == 0) {
				return (NULL);
			}
		}
		return (r->func);
	}
	return (NULL);
}

/*ARGSUSED2*/
static void
zero_init(uchar_t *buf, ulong_t len, const uchar_t * const foo)
{
	(void) memset(buf, NULL, len);
}
/*ARGSUSED2*/
static void
deadbeef64_init(uchar_t *buf, ulong_t len, const uchar_t * const foo)
{
	ulong_t i;

	for (i = 0; i < len; i += 64) {
		uint32_t *ptr;

		/*LINTED*/
		ptr = (uint32_t *)(buf + i);
		*ptr = 0xdeadbeef;
	}
}

static void
uint32_init(uchar_t *buf, ulong_t len, uint32_t value)
{
	ulong_t i;

	for (i = 0; i < len; i += sizeof (uint32_t)) {
		uint32_t *ptr;

		/*LINTED*/
		ptr = (uint32_t *)(buf + i);
		*ptr = value;
	}
}

/*ARGSUSED2*/
static void
rbufinit_init(uchar_t *buf, ulong_t len, const uchar_t * const foo)
{
	memcpy(buf, read_buf_source, len);
}

static void
xor_init(uchar_t *buf, ulong_t len, const uchar_t * const data_written)
{
	ulong_t i;

	for (i = 0; i < len; i += sizeof (uint32_t)) {
		uint32_t *to;
		uint32_t *from;

		/*LINTED*/
		to = (uint32_t *)(buf + i);
		/*LINTED*/
		from = (uint32_t *)(data_written + i);
		*to = 0xffffffff ^ *from;
	}
}

static int
rb_key_cmp(const void *k, const void *v)
{
	return (strcasecmp((char *)k,
	    ((struct read_buf_initializers *)v)->name));
}

read_buf_initializer_t
setup_read_buf_initializer(void)
{
	struct read_buf_initializers *r;

	if ((r = (struct read_buf_initializers *)lfind(
	    opts.read_buffer_init, read_buf_initializers,
	    &nel_read_buf_initializers,
	    sizeof (read_buf_initializers[0]), rb_key_cmp)) != NULL) {
		if (r->init != NULL) {
			if (r->init(r->val) == 0) {
				return (NULL);
			}
		}
		return (r->func);
	} else {
		return (NULL);
	}
}


static int
rinit_init(uint64_t value)
{
	uint64_t *x;
	int i;
	int fd;

	if ((fd = open("/dev/zero", O_RDWR)) == -1)
		return (NULL);

	x = (uint64_t *)mmap(NULL, INDEX_TO_DIOLEN(max_disk_io_len),
	    PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
	close(fd);
	if (x == MAP_FAILED)
		return (NULL);
	read_buf_source = x;

	for (i = 0; i < INDEX_TO_DIOLEN(max_disk_io_len);
	    i += sizeof (uint64_t)) {
		*(x++) = value;
	}

	mprotect((char *)read_buf_source, INDEX_TO_DIOLEN(max_disk_io_len),
	    PROT_READ);

	return (1);
}

static int
vinit_init(uint32_t value)
{
	union {
		uint64_t ll;
		uint32_t i[sizeof (uint64_t)/sizeof (uint32_t)];
	} u;
	int i;

	for (i = 0; i < ARRAY_LEN(u.i); i++) {
		u.i[i] = value;
	}
	return (rinit_init(u.ll));
}

static int
cinit_init(uint64_t value)
{
	return (vinit_init(opts.read_buffer_supplied_value));
}

static uchar_t
pat_func(int bufno, int i, uchar_t *pat, int plen)
{
	ulong_t len = INDEX_TO_DIOLEN(max_disk_io_len);
	ulong_t off = ((bufno * len) + i) % plen;

	return (pat[off]);
}
/*
 * CJTPAT Payload pattern is:
 *	167 7E's
 *	1 74
 *	1 7E
 *	1 AB
 *	51 B5's
 *	1 5E
 *	1 4A
 *	4 7E's
 *	1 FE
 */
static uchar_t cjtpat[] = {
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 1 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 2 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 3 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 4 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 5 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 6 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 7 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 8 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 9 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 10 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 11 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 12 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 13 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 14 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 15 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, /* 16 */
	0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x74, 0x7e, 0xab, /* 17 */
	0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, /* 18 */
	0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, /* 19 */
	0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, /* 20 */
	0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, /* 21 */
	0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, /* 22 */
	0xb5, 0x5e, 0x4A, 0x7e, 0x7e, 0x7e, 0x7e, 0xfe /* 23 */
};

static uchar_t
cjtpat_func(int bufno, int i)
{
	assert(sizeof (cjtpat) == 228);

	return (pat_func(bufno, i, cjtpat, sizeof (cjtpat)));
}

/*
 * ISI "Killer" pattern
 *
 * 00101101, = 0x2d
 * 11110100, = 0xf4
 * 10000010, = 0x82
 * 11011111, = 0xdf
 * 01001000, = 0x48
 */
static uchar_t isipat[] = {
	0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb,
	0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb,
	0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb,
	0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb,
	0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb,
	0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb,
	0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb,
	0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb, 0xf4, 0xeb,
	0xf4, 0x2d, 0xf4, 0x82, 0xdf, 0x48
};

static uchar_t
isipat_func(int bufno, int i)
{
	return (pat_func(bufno, i, isipat, sizeof (isipat)));
}

static int
userpat_init(struct ilist  *a, int *b, int c)
{

	int fd;
	struct stat buf;

	if ((fd = open(opts.expert_userpat_file, O_RDONLY)) == -1) {
		return (1);
	}
	if (fstat(fd, &buf) == -1) {
		close(fd);
		return (1);
	}

	userpat_data.buf = (uchar_t *)mmap(0, buf.st_size,
	    PROT_READ, MAP_PRIVATE, fd, 0);
	close(fd);

	if (userpat_data.buf == MAP_FAILED) {
		return (1);
	}
	userpat_data.len = buf.st_size;
}

static uchar_t
userpat_func(int bufno, int i)
{
	return (pat_func(bufno, i, userpat_data.buf, userpat_data.len));
}

static uchar_t
cjt_and_isi_func(int bufno, int i)
{
	ulong_t plen = sizeof (isipat) + sizeof (cjtpat);
	ulong_t len = INDEX_TO_DIOLEN(max_disk_io_len);
	ulong_t off = ((bufno * len) + i) % plen;

	if (off > sizeof (isipat)) {
		return (cjtpat[off - sizeof (isipat)]);
	} else {
		return (isipat[off]);
	}
}