[mirror_zfs-debian.git] / cmd / zpios / zpios_main.c

/*****************************************************************************\
 *  ZPIOS is a heavily modified version of the original PIOS test code.
 *  It is designed to have the test code running in the Linux kernel
 *  against ZFS while still being flexibly controled from user space.
 *
 *  Copyright (C) 2008-2010 Lawrence Livermore National Security, LLC.
 *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
 *  Written by Brian Behlendorf <behlendorf1@llnl.gov>.
 *  LLNL-CODE-403049
 *
 *  Original PIOS Test Code
 *  Copyright (C) 2004 Cluster File Systems, Inc.
 *  Written by Peter Braam <braam@clusterfs.com>
 *             Atul Vidwansa <atul@clusterfs.com>
 *             Milind Dumbare <milind@clusterfs.com>
 *
 *  This file is part of ZFS on Linux.
 *  For details, see <http://github.com/behlendorf/zfs/>.
 *
 *  ZPIOS is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by the
 *  Free Software Foundation; either version 2 of the License, or (at your
 *  option) any later version.
 *
 *  ZPIOS is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 *  for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with ZPIOS.  If not, see <http://www.gnu.org/licenses/>.
\*****************************************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <getopt.h>
#include <assert.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include "zpios.h"

static const char short_opt[] = "t:l:h:e:n:i:j:k:o:m:q:r:c:a:b:g:s:A:B:C:"
                                "L:p:M:xP:R:G:I:N:T:VzOfHv?";
static const struct option long_opt[] = {
	{"threadcount",         required_argument, 0, 't' },
	{"threadcount_low",     required_argument, 0, 'l' },
	{"threadcount_high",    required_argument, 0, 'h' },
	{"threadcount_incr",    required_argument, 0, 'e' },
	{"regioncount",         required_argument, 0, 'n' },
	{"regioncount_low",     required_argument, 0, 'i' },
	{"regioncount_high",    required_argument, 0, 'j' },
	{"regioncount_incr",    required_argument, 0, 'k' },
	{"offset",              required_argument, 0, 'o' },
	{"offset_low",          required_argument, 0, 'm' },
	{"offset_high",         required_argument, 0, 'q' },
	{"offset_incr",         required_argument, 0, 'r' },
	{"chunksize",           required_argument, 0, 'c' },
	{"chunksize_low",       required_argument, 0, 'a' },
	{"chunksize_high",      required_argument, 0, 'b' },
	{"chunksize_incr",      required_argument, 0, 'g' },
	{"regionsize",          required_argument, 0, 's' },
	{"regionsize_low",      required_argument, 0, 'A' },
	{"regionsize_high",     required_argument, 0, 'B' },
	{"regionsize_incr",     required_argument, 0, 'C' },
	{"load",                required_argument, 0, 'L' },
	{"pool",                required_argument, 0, 'p' },
	{"name",		required_argument, 0, 'M' },
	{"cleanup",             no_argument,       0, 'x' },
	{"prerun",              required_argument, 0, 'P' },
	{"postrun",             required_argument, 0, 'R' },
	{"log",                 required_argument, 0, 'G' },
	{"regionnoise",         required_argument, 0, 'I' },
	{"chunknoise",          required_argument, 0, 'N' },
	{"threaddelay",         required_argument, 0, 'T' },
	{"verify",              no_argument,       0, 'V' },
	{"zerocopy",            no_argument,       0, 'z' },
	{"nowait",              no_argument,       0, 'O' },
	{"noprefetch",          no_argument,       0, 'f' },
	{"human-readable",      no_argument,       0, 'H' },
	{"verbose",             no_argument,       0, 'v' },
	{"help",                no_argument,       0, '?' },
	{ 0,                    0,                 0,  0  },
};

static int zpiosctl_fd;				/* Control file descriptor */
static char zpios_version[VERSION_SIZE];	/* Kernel version string */
static char *zpios_buffer = NULL;		/* Scratch space area */
static int zpios_buffer_size = 0;		/* Scratch space size */

static int
usage(void)
{
	fprintf(stderr, "Usage: zpios\n");
	fprintf(stderr,
	        "	--threadcount       -t    =values\n"
	        "	--threadcount_low   -l    =value\n"
	        "	--threadcount_high  -h    =value\n"
	        "	--threadcount_incr  -e    =value\n"
	        "	--regioncount       -n    =values\n"
	        "	--regioncount_low   -i    =value\n"
	        "	--regioncount_high  -j    =value\n"
	        "	--regioncount_incr  -k    =value\n"
	        "	--offset            -o    =values\n"
	        "	--offset_low        -m    =value\n"
	        "	--offset_high       -q    =value\n"
	        "	--offset_incr       -r    =value\n"
	        "	--chunksize         -c    =values\n"
	        "	--chunksize_low     -a    =value\n"
	        "	--chunksize_high    -b    =value\n"
	        "	--chunksize_incr    -g    =value\n"
	        "	--regionsize        -s    =values\n"
	        "	--regionsize_low    -A    =value\n"
	        "	--regionsize_high   -B    =value\n"
	        "	--regionsize_incr   -C    =value\n"
	        "	--load              -L    =dmuio|ssf|fpp\n"
	        "	--pool              -p    =pool name\n"
		"	--name              -M    =test name\n"
	        "	--cleanup           -x\n"
	        "	--prerun            -P    =pre-command\n"
	        "	--postrun           -R    =post-command\n"
	        "	--log               -G    =log directory\n"
	        "	--regionnoise       -I    =shift\n"
	        "	--chunknoise        -N    =bytes\n"
	        "	--threaddelay       -T    =jiffies\n"
	        "	--verify            -V\n"
	        "	--zerocopy          -z\n"
	        "	--nowait            -O\n"
		"	--noprefetch        -f\n"
	        "	--human-readable    -H\n"
	        "	--verbose           -v    =increase verbosity\n"
	        "	--help              -?    =this help\n\n");

	return 0;
}

static void args_fini(cmd_args_t *args)
{
	assert(args != NULL);
	free(args);
}

static cmd_args_t *
args_init(int argc, char **argv)
{
	cmd_args_t *args;
	uint32_t fl_th = 0;
	uint32_t fl_rc = 0;
	uint32_t fl_of = 0;
	uint32_t fl_rs = 0;
	uint32_t fl_cs = 0;
	int c, rc;

	if (argc == 1) {
		usage();
		return (cmd_args_t *)NULL;
	}

	/* Configure and populate the args structures */
	args = malloc(sizeof(*args));
	if (args == NULL)
		return NULL;

	memset(args, 0, sizeof(*args));

	while ((c=getopt_long(argc, argv, short_opt, long_opt, NULL)) != -1) {
		rc = 0;

		switch (c) {
		case 't': /* --thread count */
		        rc = set_count(REGEX_NUMBERS, REGEX_NUMBERS_COMMA,
				       &args->T, optarg, &fl_th, "threadcount");
			break;
		case 'l': /* --threadcount_low */
			rc = set_lhi(REGEX_NUMBERS, &args->T, optarg,
			             FLAG_LOW, &fl_th, "threadcount_low");
			break;
		case 'h': /* --threadcount_high */
			rc = set_lhi(REGEX_NUMBERS, &args->T, optarg,
			             FLAG_HIGH, &fl_th, "threadcount_high");
			break;
		case 'e': /* --threadcount_inc */
			rc = set_lhi(REGEX_NUMBERS, &args->T, optarg,
			             FLAG_INCR, &fl_th, "threadcount_incr");
			break;
		case 'n': /* --regioncount */
			rc = set_count(REGEX_NUMBERS, REGEX_NUMBERS_COMMA,
				       &args->N, optarg, &fl_rc, "regioncount");
			break;
		case 'i': /* --regioncount_low */
			rc = set_lhi(REGEX_NUMBERS, &args->N, optarg,
			             FLAG_LOW, &fl_rc, "regioncount_low");
			break;
		case 'j': /* --regioncount_high */
			rc = set_lhi(REGEX_NUMBERS, &args->N, optarg,
			             FLAG_HIGH, &fl_rc, "regioncount_high");
			break;
		case 'k': /* --regioncount_inc */
			rc = set_lhi(REGEX_NUMBERS, &args->N, optarg,
			             FLAG_INCR, &fl_rc, "regioncount_incr");
			break;
		case 'o': /* --offset */
			rc = set_count(REGEX_SIZE, REGEX_SIZE_COMMA,
				       &args->O, optarg, &fl_of, "offset");
			break;
		case 'm': /* --offset_low */
			rc = set_lhi(REGEX_SIZE, &args->O, optarg,
			             FLAG_LOW, &fl_of, "offset_low");
			break;
		case 'q': /* --offset_high */
			rc = set_lhi(REGEX_SIZE, &args->O, optarg,
			             FLAG_HIGH, &fl_of, "offset_high");
			break;
		case 'r': /* --offset_inc */
			rc = set_lhi(REGEX_NUMBERS, &args->O, optarg,
			             FLAG_INCR, &fl_of, "offset_incr");
			break;
		case 'c': /* --chunksize */
			rc = set_count(REGEX_SIZE, REGEX_SIZE_COMMA,
				       &args->C, optarg, &fl_cs, "chunksize");
			break;
		case 'a': /* --chunksize_low */
			rc = set_lhi(REGEX_SIZE, &args->C, optarg,
			             FLAG_LOW, &fl_cs, "chunksize_low");
			break;
		case 'b': /* --chunksize_high */
			rc = set_lhi(REGEX_SIZE, &args->C, optarg,
			             FLAG_HIGH, &fl_cs, "chunksize_high");
			break;
		case 'g': /* --chunksize_inc */
			rc = set_lhi(REGEX_NUMBERS, &args->C, optarg,
			             FLAG_INCR, &fl_cs, "chunksize_incr");
			break;
		case 's': /* --regionsize */
			rc = set_count(REGEX_SIZE, REGEX_SIZE_COMMA,
				       &args->S, optarg, &fl_rs, "regionsize");
			break;
		case 'A': /* --regionsize_low */
			rc = set_lhi(REGEX_SIZE, &args->S, optarg,
			             FLAG_LOW, &fl_rs, "regionsize_low");
			break;
		case 'B': /* --regionsize_high */
			rc = set_lhi(REGEX_SIZE, &args->S, optarg,
			             FLAG_HIGH, &fl_rs, "regionsize_high");
			break;
		case 'C': /* --regionsize_inc */
			rc = set_lhi(REGEX_NUMBERS, &args->S, optarg,
			             FLAG_INCR, &fl_rs, "regionsize_incr");
			break;
		case 'L': /* --load */
			rc = set_load_params(args, optarg);
			break;
		case 'p': /* --pool */
			args->pool = optarg;
			break;
		case 'M':
			args->name = optarg;
			break;
		case 'x': /* --cleanup */
			args->flags |= DMU_REMOVE;
			break;
		case 'P': /* --prerun */
			strncpy(args->pre, optarg, ZPIOS_PATH_SIZE - 1);
			break;
		case 'R': /* --postrun */
			strncpy(args->post, optarg, ZPIOS_PATH_SIZE - 1);
			break;
		case 'G': /* --log */
			strncpy(args->log, optarg, ZPIOS_PATH_SIZE - 1);
			break;
		case 'I': /* --regionnoise */
			rc = set_noise(&args->regionnoise, optarg, "regionnoise");
			break;
		case 'N': /* --chunknoise */
			rc = set_noise(&args->chunknoise, optarg, "chunknoise");
			break;
		case 'T': /* --threaddelay */
			rc = set_noise(&args->thread_delay, optarg, "threaddelay");
			break;
		case 'V': /* --verify */
			args->flags |= DMU_VERIFY;
			break;
		case 'z': /* --zerocopy */
			args->flags |= (DMU_WRITE_ZC | DMU_READ_ZC);
			break;
		case 'O': /* --nowait */
			args->flags |= DMU_WRITE_NOWAIT;
			break;
		case 'f': /* --noprefetch */
			args->flags |= DMU_READ_NOPF;
			break;
		case 'H': /* --human-readable */
			args->human_readable = 1;
			break;
		case 'v': /* --verbose */
			args->verbose++;
			break;
		case '?':
			rc = 1;
			break;
		default:
			fprintf(stderr,"Unknown option '%s'\n",argv[optind-1]);
			rc = EINVAL;
			break;
		}

		if (rc) {
			usage();
			args_fini(args);
			return NULL;
		}
	}

	check_mutual_exclusive_command_lines(fl_th, "threadcount");
	check_mutual_exclusive_command_lines(fl_rc, "regioncount");
	check_mutual_exclusive_command_lines(fl_of, "offset");
	check_mutual_exclusive_command_lines(fl_rs, "regionsize");
	check_mutual_exclusive_command_lines(fl_cs, "chunksize");

	if (args->pool == NULL) {
		fprintf(stderr, "Error: Pool not specificed\n");
		usage();
		args_fini(args);
		return NULL;
	}

	if ((args->flags & (DMU_WRITE_ZC | DMU_READ_ZC)) &&
	    (args->flags & DMU_VERIFY)) {
                fprintf(stderr, "Error, --zerocopy incompatible --verify, "
                            "used for performance analysis only\n");
		usage();
		args_fini(args);
		return NULL;
	}

	return args;
}

static int
dev_clear(void)
{
	zpios_cfg_t cfg;
	int rc;

	memset(&cfg, 0, sizeof(cfg));
	cfg.cfg_magic = ZPIOS_CFG_MAGIC;
        cfg.cfg_cmd   = ZPIOS_CFG_BUFFER_CLEAR;
	cfg.cfg_arg1  = 0;

	rc = ioctl(zpiosctl_fd, ZPIOS_CFG, &cfg);
	if (rc)
		fprintf(stderr, "Ioctl() error %lu / %d: %d\n",
		        (unsigned long) ZPIOS_CFG, cfg.cfg_cmd, errno);

	lseek(zpiosctl_fd, 0, SEEK_SET);

	return rc;
}

/* Passing a size of zero simply results in querying the current size */
static int
dev_size(int size)
{
	zpios_cfg_t cfg;
	int rc;

	memset(&cfg, 0, sizeof(cfg));
	cfg.cfg_magic = ZPIOS_CFG_MAGIC;
        cfg.cfg_cmd   = ZPIOS_CFG_BUFFER_SIZE;
	cfg.cfg_arg1  = size;

	rc = ioctl(zpiosctl_fd, ZPIOS_CFG, &cfg);
	if (rc) {
		fprintf(stderr, "Ioctl() error %lu / %d: %d\n",
		        (unsigned long) ZPIOS_CFG, cfg.cfg_cmd, errno);
		return rc;
	}

	return cfg.cfg_rc1;
}

static void
dev_fini(void)
{
	if (zpios_buffer)
		free(zpios_buffer);

	if (zpiosctl_fd != -1) {
		if (close(zpiosctl_fd) == -1) {
			fprintf(stderr, "Unable to close %s: %d\n",
		                ZPIOS_DEV, errno);
		}
	}
}

static int
dev_init(void)
{
	int rc;

	zpiosctl_fd = open(ZPIOS_DEV, O_RDONLY);
	if (zpiosctl_fd == -1) {
		fprintf(stderr, "Unable to open %s: %d\n"
		        "Is the zpios module loaded?\n", ZPIOS_DEV, errno);
		rc = errno;
		goto error;
	}

	if ((rc = dev_clear()))
		goto error;

	if ((rc = dev_size(0)) < 0)
		goto error;

	zpios_buffer_size = rc;
	zpios_buffer = (char *)malloc(zpios_buffer_size);
	if (zpios_buffer == NULL) {
		rc = ENOMEM;
		goto error;
	}

	memset(zpios_buffer, 0, zpios_buffer_size);
	return 0;
error:
	if (zpiosctl_fd != -1) {
		if (close(zpiosctl_fd) == -1) {
			fprintf(stderr, "Unable to close %s: %d\n",
		                ZPIOS_DEV, errno);
		}
	}

	return rc;
}

static int
get_next(uint64_t *val, range_repeat_t *range)
{
	/* if low, incr, high is given */
	if (range->val_count == 0) {
		*val = (range->val_low) +
		       (range->val_low * range->next_val / 100);

		if (*val > range->val_high)
			return 0; /* No more values, limit exceeded */

		if (!range->next_val)
			range->next_val = range->val_inc_perc;
		else
			range->next_val = range->next_val+range->val_inc_perc;

		return 1; /* more values to come */

	/* if only one val is given */
	} else if (range->val_count == 1) {
		if (range->next_val)
			return 0; /* No more values, we only have one */

		*val = range->val[0];
		range->next_val = 1;
		return 1; /* more values to come */

	/* if comma separated values are given */
	} else if (range->val_count > 1) {
		if (range->next_val > range->val_count - 1)
			return 0; /* No more values, limit exceeded */

		*val = range->val[range->next_val];
		range->next_val++;
		return 1; /* more values to come */
	}

	return 0;
}

static int
run_one(cmd_args_t *args, uint32_t id, uint32_t T, uint32_t N,
        uint64_t C, uint64_t S, uint64_t O)
{
	zpios_cmd_t *cmd;
        int rc, rc2, cmd_size;

        dev_clear();

	cmd_size = sizeof(zpios_cmd_t) + ((T + N + 1) * sizeof(zpios_stats_t));
        cmd = (zpios_cmd_t *)malloc(cmd_size);
        if (cmd == NULL)
                return ENOMEM;

        memset(cmd, 0, cmd_size);
        cmd->cmd_magic = ZPIOS_CMD_MAGIC;
	strncpy(cmd->cmd_pool, args->pool, ZPIOS_NAME_SIZE - 1);
	strncpy(cmd->cmd_pre, args->pre, ZPIOS_PATH_SIZE - 1);
	strncpy(cmd->cmd_post, args->post, ZPIOS_PATH_SIZE - 1);
	strncpy(cmd->cmd_log, args->log, ZPIOS_PATH_SIZE - 1);
	cmd->cmd_id           = id;
	cmd->cmd_chunk_size   = C;
	cmd->cmd_thread_count = T;
	cmd->cmd_region_count = N;
	cmd->cmd_region_size  = S;
	cmd->cmd_offset       = O;
	cmd->cmd_region_noise = args->regionnoise;
	cmd->cmd_chunk_noise  = args->chunknoise;
	cmd->cmd_thread_delay = args->thread_delay;
	cmd->cmd_flags        = args->flags;
        cmd->cmd_data_size    = (T + N + 1) * sizeof(zpios_stats_t);

        rc = ioctl(zpiosctl_fd, ZPIOS_CMD, cmd);
	if (rc)
		args->rc = errno;

	print_stats(args, cmd);

        if (args->verbose) {
                rc2 = read(zpiosctl_fd, zpios_buffer, zpios_buffer_size - 1);
                if (rc2 < 0) {
                        fprintf(stdout, "Error reading results: %d\n", rc2);
                } else if ((rc2 > 0) && (strlen(zpios_buffer) > 0)) {
                        fprintf(stdout, "\n%s\n", zpios_buffer);
                        fflush(stdout);
                }
        }

        free(cmd);

        return rc;
}

static int
run_offsets(cmd_args_t *args)
{
	int rc = 0;

	while (rc == 0 && get_next(&args->current_O, &args->O)) {
		rc = run_one(args, args->current_id,
		             args->current_T, args->current_N, args->current_C,
		             args->current_S, args->current_O);
		args->current_id++;
	}

	args->O.next_val = 0;
	return rc;
}

static int
run_region_counts(cmd_args_t *args)
{
	int rc = 0;

	while (rc == 0 && get_next((uint64_t *)&args->current_N, &args->N))
	       rc = run_offsets(args);

	args->N.next_val = 0;
	return rc;
}

static int
run_region_sizes(cmd_args_t *args)
{
	int rc = 0;

	while (rc == 0 && get_next(&args->current_S, &args->S)) {
		if (args->current_S < args->current_C) {
			fprintf(stderr, "Error: in any run chunksize can "
				"not be smaller than regionsize.\n");
			return EINVAL;
		}

		rc = run_region_counts(args);
	}

	args->S.next_val = 0;
	return rc;
}

static int
run_chunk_sizes(cmd_args_t *args)
{
	int rc = 0;

	while (rc == 0 && get_next(&args->current_C, &args->C)) {
	       rc = run_region_sizes(args);
	}

	args->C.next_val = 0;
	return rc;
}

static int
run_thread_counts(cmd_args_t *args)
{
	int rc = 0;

	while (rc == 0 && get_next((uint64_t *)&args->current_T, &args->T))
		rc = run_chunk_sizes(args);

	return rc;
}

int
main(int argc, char **argv)
{
	cmd_args_t *args;
	int rc = 0;

	/* Argument init and parsing */
	if ((args = args_init(argc, argv)) == NULL) {
		rc = -1;
		goto out;
	}

	/* Device specific init */
	if ((rc = dev_init()))
		goto out;

	/* Generic kernel version string */
	if (args->verbose)
		fprintf(stdout, "%s", zpios_version);

	print_stats_header(args);
	rc = run_thread_counts(args);
out:
	if (args != NULL)
		args_fini(args);

	dev_fini();
	return rc;
}
Commit	Line	Data
302ef151 BB	1	/*****************************************************************************\
	2	* ZPIOS is a heavily modified version of the original PIOS test code.
	3	* It is designed to have the test code running in the Linux kernel
	4	* against ZFS while still being flexibly controled from user space.
	5	*
	6	* Copyright (C) 2008-2010 Lawrence Livermore National Security, LLC.
	7	* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
	8	* Written by Brian Behlendorf <behlendorf1@llnl.gov>.
	9	* LLNL-CODE-403049
	10	*
	11	* Original PIOS Test Code
	12	* Copyright (C) 2004 Cluster File Systems, Inc.
	13	* Written by Peter Braam <braam@clusterfs.com>
	14	* Atul Vidwansa <atul@clusterfs.com>
	15	* Milind Dumbare <milind@clusterfs.com>
	16	*
	17	* This file is part of ZFS on Linux.
	18	* For details, see <http://github.com/behlendorf/zfs/>.
	19	*
	20	* ZPIOS is free software; you can redistribute it and/or modify it
	21	* under the terms of the GNU General Public License as published by the
	22	* Free Software Foundation; either version 2 of the License, or (at your
	23	* option) any later version.
	24	*
	25	* ZPIOS is distributed in the hope that it will be useful, but WITHOUT
	26	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	27	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	28	* for more details.
	29	*
	30	* You should have received a copy of the GNU General Public License along
	31	* with ZPIOS. If not, see <http://www.gnu.org/licenses/>.
	32	\*****************************************************************************/
	33
	34	#include <stdlib.h>
	35	#include <stdio.h>
	36	#include <string.h>
	37	#include <errno.h>
	38	#include <getopt.h>
	39	#include <assert.h>
	40	#include <fcntl.h>
	41	#include <unistd.h>
	42	#include <sys/ioctl.h>
	43	#include "zpios.h"
	44
	45	static const char short_opt[] = "t:l:h:e:n:i:j:k:o:m:q:r:c:a:b:g:s:A:B:C:"
	46	"L:p:M:xP:R:G:I:N:T:VzOfHv?";
	47	static const struct option long_opt[] = {
	48	{"threadcount", required_argument, 0, 't' },
	49	{"threadcount_low", required_argument, 0, 'l' },
	50	{"threadcount_high", required_argument, 0, 'h' },
	51	{"threadcount_incr", required_argument, 0, 'e' },
	52	{"regioncount", required_argument, 0, 'n' },
	53	{"regioncount_low", required_argument, 0, 'i' },
	54	{"regioncount_high", required_argument, 0, 'j' },
	55	{"regioncount_incr", required_argument, 0, 'k' },
	56	{"offset", required_argument, 0, 'o' },
	57	{"offset_low", required_argument, 0, 'm' },
	58	{"offset_high", required_argument, 0, 'q' },
	59	{"offset_incr", required_argument, 0, 'r' },
	60	{"chunksize", required_argument, 0, 'c' },
	61	{"chunksize_low", required_argument, 0, 'a' },
	62	{"chunksize_high", required_argument, 0, 'b' },
	63	{"chunksize_incr", required_argument, 0, 'g' },
	64	{"regionsize", required_argument, 0, 's' },
65	{"regionsize_low", required_argument, 0, 'A' },
66	{"regionsize_high", required_argument, 0, 'B' },
67	{"regionsize_incr", required_argument, 0, 'C' },
68	{"load", required_argument, 0, 'L' },
69	{"pool", required_argument, 0, 'p' },
70	{"name", required_argument, 0, 'M' },
71	{"cleanup", no_argument, 0, 'x' },
72	{"prerun", required_argument, 0, 'P' },
73	{"postrun", required_argument, 0, 'R' },
74	{"log", required_argument, 0, 'G' },
75	{"regionnoise", required_argument, 0, 'I' },
76	{"chunknoise", required_argument, 0, 'N' },
77	{"threaddelay", required_argument, 0, 'T' },
78	{"verify", no_argument, 0, 'V' },
79	{"zerocopy", no_argument, 0, 'z' },
80	{"nowait", no_argument, 0, 'O' },
81	{"noprefetch", no_argument, 0, 'f' },
82	{"human-readable", no_argument, 0, 'H' },
83	{"verbose", no_argument, 0, 'v' },
84	{"help", no_argument, 0, '?' },
85	{ 0, 0, 0, 0 },
86	};
87
88	static int zpiosctl_fd; /* Control file descriptor */
89	static char zpios_version[VERSION_SIZE]; /* Kernel version string */
90	static char zpios_buffer = NULL; / Scratch space area */
91	static int zpios_buffer_size = 0; /* Scratch space size */
92
93	static int
94	usage(void)
95	{
96	fprintf(stderr, "Usage: zpios\n");
97	fprintf(stderr,
98	" --threadcount -t =values\n"
99	" --threadcount_low -l =value\n"
100	" --threadcount_high -h =value\n"
101	" --threadcount_incr -e =value\n"
102	" --regioncount -n =values\n"
103	" --regioncount_low -i =value\n"
104	" --regioncount_high -j =value\n"
105	" --regioncount_incr -k =value\n"
106	" --offset -o =values\n"
107	" --offset_low -m =value\n"
108	" --offset_high -q =value\n"
109	" --offset_incr -r =value\n"
110	" --chunksize -c =values\n"
111	" --chunksize_low -a =value\n"
112	" --chunksize_high -b =value\n"
113	" --chunksize_incr -g =value\n"
114	" --regionsize -s =values\n"
115	" --regionsize_low -A =value\n"
116	" --regionsize_high -B =value\n"
117	" --regionsize_incr -C =value\n"
118	" --load -L =dmuio\|ssf\|fpp\n"
119	" --pool -p =pool name\n"
120	" --name -M =test name\n"
121	" --cleanup -x\n"
122	" --prerun -P =pre-command\n"
123	" --postrun -R =post-command\n"
124	" --log -G =log directory\n"
125	" --regionnoise -I =shift\n"
126	" --chunknoise -N =bytes\n"
127	" --threaddelay -T =jiffies\n"
128	" --verify -V\n"
129	" --zerocopy -z\n"
130	" --nowait -O\n"
131	" --noprefetch -f\n"
132	" --human-readable -H\n"
133	" --verbose -v =increase verbosity\n"
134	" --help -? =this help\n\n");
135
136	return 0;
137	}
138
139	static void args_fini(cmd_args_t *args)
140	{
141	assert(args != NULL);
142	free(args);
143	}
144
145	static cmd_args_t *
146	args_init(int argc, char **argv)
147	{
148	cmd_args_t *args;
149	uint32_t fl_th = 0;
150	uint32_t fl_rc = 0;
151	uint32_t fl_of = 0;
152	uint32_t fl_rs = 0;
153	uint32_t fl_cs = 0;
154	int c, rc;
155
156	if (argc == 1) {
157	usage();
158	return (cmd_args_t *)NULL;
159	}
160
161	/* Configure and populate the args structures */
162	args = malloc(sizeof(*args));
163	if (args == NULL)
164	return NULL;
165
166	memset(args, 0, sizeof(*args));
167
168	while ((c=getopt_long(argc, argv, short_opt, long_opt, NULL)) != -1) {
169	rc = 0;
170
171	switch (c) {
172	case 't': /* --thread count */
173	rc = set_count(REGEX_NUMBERS, REGEX_NUMBERS_COMMA,
174	&args->T, optarg, &fl_th, "threadcount");
175	break;
176	case 'l': /* --threadcount_low */
177	rc = set_lhi(REGEX_NUMBERS, &args->T, optarg,
178	FLAG_LOW, &fl_th, "threadcount_low");
179	break;
180	case 'h': /* --threadcount_high */
181	rc = set_lhi(REGEX_NUMBERS, &args->T, optarg,
182	FLAG_HIGH, &fl_th, "threadcount_high");
183	break;
184	case 'e': /* --threadcount_inc */
185	rc = set_lhi(REGEX_NUMBERS, &args->T, optarg,
186	FLAG_INCR, &fl_th, "threadcount_incr");
187	break;
188	case 'n': /* --regioncount */
189	rc = set_count(REGEX_NUMBERS, REGEX_NUMBERS_COMMA,
190	&args->N, optarg, &fl_rc, "regioncount");
191	break;
192	case 'i': /* --regioncount_low */
193	rc = set_lhi(REGEX_NUMBERS, &args->N, optarg,
194	FLAG_LOW, &fl_rc, "regioncount_low");
195	break;
196	case 'j': /* --regioncount_high */
197	rc = set_lhi(REGEX_NUMBERS, &args->N, optarg,
198	FLAG_HIGH, &fl_rc, "regioncount_high");
199	break;
200	case 'k': /* --regioncount_inc */
201	rc = set_lhi(REGEX_NUMBERS, &args->N, optarg,
202	FLAG_INCR, &fl_rc, "regioncount_incr");
203	break;
204	case 'o': /* --offset */
205	rc = set_count(REGEX_SIZE, REGEX_SIZE_COMMA,
206	&args->O, optarg, &fl_of, "offset");
207	break;
208	case 'm': /* --offset_low */
209	rc = set_lhi(REGEX_SIZE, &args->O, optarg,
210	FLAG_LOW, &fl_of, "offset_low");
211	break;
212	case 'q': /* --offset_high */
213	rc = set_lhi(REGEX_SIZE, &args->O, optarg,
214	FLAG_HIGH, &fl_of, "offset_high");
215	break;
216	case 'r': /* --offset_inc */
217	rc = set_lhi(REGEX_NUMBERS, &args->O, optarg,
218	FLAG_INCR, &fl_of, "offset_incr");
219	break;
220	case 'c': /* --chunksize */
221	rc = set_count(REGEX_SIZE, REGEX_SIZE_COMMA,
222	&args->C, optarg, &fl_cs, "chunksize");
223	break;
224	case 'a': /* --chunksize_low */
225	rc = set_lhi(REGEX_SIZE, &args->C, optarg,
226	FLAG_LOW, &fl_cs, "chunksize_low");
227	break;
228	case 'b': /* --chunksize_high */
229	rc = set_lhi(REGEX_SIZE, &args->C, optarg,
230	FLAG_HIGH, &fl_cs, "chunksize_high");
231	break;
232	case 'g': /* --chunksize_inc */
233	rc = set_lhi(REGEX_NUMBERS, &args->C, optarg,
234	FLAG_INCR, &fl_cs, "chunksize_incr");
235	break;
236	case 's': /* --regionsize */
237	rc = set_count(REGEX_SIZE, REGEX_SIZE_COMMA,
238	&args->S, optarg, &fl_rs, "regionsize");
239	break;
240	case 'A': /* --regionsize_low */
241	rc = set_lhi(REGEX_SIZE, &args->S, optarg,
242	FLAG_LOW, &fl_rs, "regionsize_low");
243	break;
244	case 'B': /* --regionsize_high */
245	rc = set_lhi(REGEX_SIZE, &args->S, optarg,
246	FLAG_HIGH, &fl_rs, "regionsize_high");
247	break;
248	case 'C': /* --regionsize_inc */
249	rc = set_lhi(REGEX_NUMBERS, &args->S, optarg,
250	FLAG_INCR, &fl_rs, "regionsize_incr");
251	break;
252	case 'L': /* --load */
253	rc = set_load_params(args, optarg);
254	break;
255	case 'p': /* --pool */
256	args->pool = optarg;
257	break;
258	case 'M':
259	args->name = optarg;
260	break;
261	case 'x': /* --cleanup */
262	args->flags \|= DMU_REMOVE;
263	break;
264	case 'P': /* --prerun */
265	strncpy(args->pre, optarg, ZPIOS_PATH_SIZE - 1);
266	break;
267	case 'R': /* --postrun */
268	strncpy(args->post, optarg, ZPIOS_PATH_SIZE - 1);
269	break;
270	case 'G': /* --log */
271	strncpy(args->log, optarg, ZPIOS_PATH_SIZE - 1);
272	break;
273	case 'I': /* --regionnoise */
274	rc = set_noise(&args->regionnoise, optarg, "regionnoise");
275	break;
276	case 'N': /* --chunknoise */
277	rc = set_noise(&args->chunknoise, optarg, "chunknoise");
278	break;
279	case 'T': /* --threaddelay */
280	rc = set_noise(&args->thread_delay, optarg, "threaddelay");
281	break;
282	case 'V': /* --verify */
283	args->flags \|= DMU_VERIFY;
284	break;
285	case 'z': /* --zerocopy */
286	args->flags \|= (DMU_WRITE_ZC \| DMU_READ_ZC);
287	break;
288	case 'O': /* --nowait */
289	args->flags \|= DMU_WRITE_NOWAIT;
290	break;
291	case 'f': /* --noprefetch */
292	args->flags \|= DMU_READ_NOPF;
293	break;
294	case 'H': /* --human-readable */
295	args->human_readable = 1;
296	break;
297	case 'v': /* --verbose */
298	args->verbose++;
299	break;
300	case '?':
301	rc = 1;
302	break;
303	default:
304	fprintf(stderr,"Unknown option '%s'\n",argv[optind-1]);
305	rc = EINVAL;
306	break;
307	}
308
309	if (rc) {
310	usage();
311	args_fini(args);
312	return NULL;
313	}
314	}
315
316	check_mutual_exclusive_command_lines(fl_th, "threadcount");
317	check_mutual_exclusive_command_lines(fl_rc, "regioncount");
318	check_mutual_exclusive_command_lines(fl_of, "offset");
319	check_mutual_exclusive_command_lines(fl_rs, "regionsize");
320	check_mutual_exclusive_command_lines(fl_cs, "chunksize");
321
322	if (args->pool == NULL) {
323	fprintf(stderr, "Error: Pool not specificed\n");
324	usage();
325	args_fini(args);
326	return NULL;
327	}
328
329	if ((args->flags & (DMU_WRITE_ZC \| DMU_READ_ZC)) &&
330	(args->flags & DMU_VERIFY)) {
331	fprintf(stderr, "Error, --zerocopy incompatible --verify, "
332	"used for performance analysis only\n");
333	usage();
334	args_fini(args);
335	return NULL;
336	}
337
338	return args;
339	}
340
341	static int
342	dev_clear(void)
343	{
344	zpios_cfg_t cfg;
345	int rc;
346
347	memset(&cfg, 0, sizeof(cfg));
348	cfg.cfg_magic = ZPIOS_CFG_MAGIC;
349	cfg.cfg_cmd = ZPIOS_CFG_BUFFER_CLEAR;
350	cfg.cfg_arg1 = 0;
351
352	rc = ioctl(zpiosctl_fd, ZPIOS_CFG, &cfg);
353	if (rc)
354	fprintf(stderr, "Ioctl() error %lu / %d: %d\n",
355	(unsigned long) ZPIOS_CFG, cfg.cfg_cmd, errno);
356
357	lseek(zpiosctl_fd, 0, SEEK_SET);
358
359	return rc;
360	}
361
362	/* Passing a size of zero simply results in querying the current size */
363	static int
364	dev_size(int size)
365	{
366	zpios_cfg_t cfg;
367	int rc;
368
369	memset(&cfg, 0, sizeof(cfg));
370	cfg.cfg_magic = ZPIOS_CFG_MAGIC;
371	cfg.cfg_cmd = ZPIOS_CFG_BUFFER_SIZE;
372	cfg.cfg_arg1 = size;
373
374	rc = ioctl(zpiosctl_fd, ZPIOS_CFG, &cfg);
375	if (rc) {
376	fprintf(stderr, "Ioctl() error %lu / %d: %d\n",
377	(unsigned long) ZPIOS_CFG, cfg.cfg_cmd, errno);
378	return rc;
379	}
380
381	return cfg.cfg_rc1;
382	}
383
384	static void
385	dev_fini(void)
386	{
387	if (zpios_buffer)
388	free(zpios_buffer);
389
390	if (zpiosctl_fd != -1) {
391	if (close(zpiosctl_fd) == -1) {
392	fprintf(stderr, "Unable to close %s: %d\n",
393	ZPIOS_DEV, errno);
394	}
395	}
396	}
397
398	static int
399	dev_init(void)
400	{
401	int rc;
402
403	zpiosctl_fd = open(ZPIOS_DEV, O_RDONLY);
404	if (zpiosctl_fd == -1) {
405	fprintf(stderr, "Unable to open %s: %d\n"
406	"Is the zpios module loaded?\n", ZPIOS_DEV, errno);
407	rc = errno;
408	goto error;
409	}
410
411	if ((rc = dev_clear()))
412	goto error;
413
414	if ((rc = dev_size(0)) < 0)
415	goto error;
416
417	zpios_buffer_size = rc;
418	zpios_buffer = (char *)malloc(zpios_buffer_size);
419	if (zpios_buffer == NULL) {
420	rc = ENOMEM;
421	goto error;
422	}
423
424	memset(zpios_buffer, 0, zpios_buffer_size);
425	return 0;
426	error:
427	if (zpiosctl_fd != -1) {
428	if (close(zpiosctl_fd) == -1) {
429	fprintf(stderr, "Unable to close %s: %d\n",
430	ZPIOS_DEV, errno);
431	}
432	}
433
434	return rc;
435	}
436
437	static int
438	get_next(uint64_t val, range_repeat_t range)
439	{
440	/* if low, incr, high is given */
441	if (range->val_count == 0) {
442	*val = (range->val_low) +
443	(range->val_low * range->next_val / 100);
444
445	if (*val > range->val_high)
446	return 0; /* No more values, limit exceeded */
447
448	if (!range->next_val)
449	range->next_val = range->val_inc_perc;
450	else
451	range->next_val = range->next_val+range->val_inc_perc;
452
453	return 1; /* more values to come */
454
455	/* if only one val is given */
456	} else if (range->val_count == 1) {
457	if (range->next_val)
458	return 0; /* No more values, we only have one */
459
460	*val = range->val[0];
461	range->next_val = 1;
462	return 1; /* more values to come */
463
464	/* if comma separated values are given */
465	} else if (range->val_count > 1) {
466	if (range->next_val > range->val_count - 1)
467	return 0; /* No more values, limit exceeded */
468
469	*val = range->val[range->next_val];
470	range->next_val++;
471	return 1; /* more values to come */
472	}
473
474	return 0;
475	}
476
477	static int
478	run_one(cmd_args_t *args, uint32_t id, uint32_t T, uint32_t N,
479	uint64_t C, uint64_t S, uint64_t O)
480	{
481	zpios_cmd_t *cmd;
482	int rc, rc2, cmd_size;
483
484	dev_clear();
485
486	cmd_size = sizeof(zpios_cmd_t) + ((T + N + 1) * sizeof(zpios_stats_t));
487	cmd = (zpios_cmd_t *)malloc(cmd_size);
488	if (cmd == NULL)
489	return ENOMEM;
490
491	memset(cmd, 0, cmd_size);
492	cmd->cmd_magic = ZPIOS_CMD_MAGIC;
493	strncpy(cmd->cmd_pool, args->pool, ZPIOS_NAME_SIZE - 1);
494	strncpy(cmd->cmd_pre, args->pre, ZPIOS_PATH_SIZE - 1);
495	strncpy(cmd->cmd_post, args->post, ZPIOS_PATH_SIZE - 1);
496	strncpy(cmd->cmd_log, args->log, ZPIOS_PATH_SIZE - 1);
497	cmd->cmd_id = id;
498	cmd->cmd_chunk_size = C;
499	cmd->cmd_thread_count = T;
500	cmd->cmd_region_count = N;
501	cmd->cmd_region_size = S;
502	cmd->cmd_offset = O;
503	cmd->cmd_region_noise = args->regionnoise;
504	cmd->cmd_chunk_noise = args->chunknoise;
505	cmd->cmd_thread_delay = args->thread_delay;
506	cmd->cmd_flags = args->flags;
507	cmd->cmd_data_size = (T + N + 1) * sizeof(zpios_stats_t);
508
509	rc = ioctl(zpiosctl_fd, ZPIOS_CMD, cmd);
510	if (rc)
511	args->rc = errno;
512
513	print_stats(args, cmd);
514
515	if (args->verbose) {
516	rc2 = read(zpiosctl_fd, zpios_buffer, zpios_buffer_size - 1);
517	if (rc2 < 0) {
518	fprintf(stdout, "Error reading results: %d\n", rc2);
519	} else if ((rc2 > 0) && (strlen(zpios_buffer) > 0)) {
520	fprintf(stdout, "\n%s\n", zpios_buffer);
521	fflush(stdout);
522	}
523	}
524
525	free(cmd);
526
527	return rc;
528	}
529
530	static int
531	run_offsets(cmd_args_t *args)
532	{
533	int rc = 0;
534
535	while (rc == 0 && get_next(&args->current_O, &args->O)) {
536	rc = run_one(args, args->current_id,
537	args->current_T, args->current_N, args->current_C,
538	args->current_S, args->current_O);
539	args->current_id++;
540	}
541
542	args->O.next_val = 0;
543	return rc;
544	}
545
546	static int
547	run_region_counts(cmd_args_t *args)
548	{
549	int rc = 0;
550
551	while (rc == 0 && get_next((uint64_t *)&args->current_N, &args->N))
552	rc = run_offsets(args);
553
554	args->N.next_val = 0;
555	return rc;
556	}
557
558	static int
559	run_region_sizes(cmd_args_t *args)
560	{
561	int rc = 0;
562
563	while (rc == 0 && get_next(&args->current_S, &args->S)) {
564	if (args->current_S < args->current_C) {
565	fprintf(stderr, "Error: in any run chunksize can "
566	"not be smaller than regionsize.\n");
567	return EINVAL;
568	}
569
570	rc = run_region_counts(args);
571	}
572
573	args->S.next_val = 0;
574	return rc;
575	}
576
577	static int
578	run_chunk_sizes(cmd_args_t *args)
579	{
580	int rc = 0;
581
582	while (rc == 0 && get_next(&args->current_C, &args->C)) {
583	rc = run_region_sizes(args);
584	}
585
586	args->C.next_val = 0;
587	return rc;
588	}
589
590	static int
591	run_thread_counts(cmd_args_t *args)
592	{
593	int rc = 0;
594
595	while (rc == 0 && get_next((uint64_t *)&args->current_T, &args->T))
596	rc = run_chunk_sizes(args);
597
598	return rc;
599	}
600
601	int
602	main(int argc, char **argv)
603	{
604	cmd_args_t *args;
605	int rc = 0;
606
607	/* Argument init and parsing */
608	if ((args = args_init(argc, argv)) == NULL) {
609	rc = -1;
610	goto out;
611	}
612
613	/* Device specific init */
614	if ((rc = dev_init()))
615	goto out;
616
617	/* Generic kernel version string */
618	if (args->verbose)
619	fprintf(stdout, "%s", zpios_version);
620
621	print_stats_header(args);
622	rc = run_thread_counts(args);
623	out:
624	if (args != NULL)
625	args_fini(args);
626
627	dev_fini();
628	return rc;
629	}