[fio.git] / parse.c

/*
 * This file contains the ini and command liner parser main.
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
#include <stdlib.h>

#include "parse.h"
#include "debug.h"
#include "options.h"

static struct fio_option *fio_options;
extern unsigned int fio_get_kb_base(void *);

static int vp_cmp(const void *p1, const void *p2)
{
	const struct value_pair *vp1 = p1;
	const struct value_pair *vp2 = p2;

	return strlen(vp2->ival) - strlen(vp1->ival);
}

static void posval_sort(struct fio_option *o, struct value_pair *vpmap)
{
	const struct value_pair *vp;
	int entries;

	memset(vpmap, 0, PARSE_MAX_VP * sizeof(struct value_pair));

	for (entries = 0; entries < PARSE_MAX_VP; entries++) {
		vp = &o->posval[entries];
		if (!vp->ival || vp->ival[0] == '\0')
			break;

		memcpy(&vpmap[entries], vp, sizeof(*vp));
	}

	qsort(vpmap, entries, sizeof(struct value_pair), vp_cmp);
}

static void show_option_range(struct fio_option *o, FILE *out)
{
	if (!o->minval && !o->maxval)
		return;

	fprintf(out, "%20s: min=%d", "range", o->minval);
	if (o->maxval)
		fprintf(out, ", max=%d", o->maxval);
	fprintf(out, "\n");
}

static void show_option_values(struct fio_option *o)
{
	int i = 0;

	do {
		const struct value_pair *vp = &o->posval[i];

		if (!vp->ival)
			break;

		printf("%20s: %-10s", i == 0 ? "valid values" : "", vp->ival);
		if (vp->help)
			printf(" %s", vp->help);
		printf("\n");
		i++;
	} while (i < PARSE_MAX_VP);

	if (i)
		printf("\n");
}

static void show_option_help(struct fio_option *o, FILE *out)
{
	const char *typehelp[] = {
		"string (opt=bla)",
		"string with possible k/m/g postfix (opt=4k)",
		"string with time postfix (opt=10s)",
		"string (opt=bla)",
		"string with dual range (opt=1k-4k,4k-8k)",
		"integer value (opt=100)",
		"boolean value (opt=1)",
		"no argument (opt)",
	};

	if (o->alias)
		fprintf(out, "%20s: %s\n", "alias", o->alias);

	fprintf(out, "%20s: %s\n", "type", typehelp[o->type]);
	fprintf(out, "%20s: %s\n", "default", o->def ? o->def : "no default");
	show_option_range(o, stdout);
	show_option_values(o);
}

static unsigned long get_mult_time(char c)
{
	switch (c) {
	case 'm':
	case 'M':
		return 60;
	case 'h':
	case 'H':
		return 60 * 60;
	case 'd':
	case 'D':
		return 24 * 60 * 60;
	default:
		return 1;
	}
}

static unsigned long long get_mult_bytes(char c, void *data)
{
	unsigned int kb_base = fio_get_kb_base(data);
	unsigned long long ret = 1;

	switch (c) {
	default:
		break;
	case 'p':
	case 'P':
		ret *= (unsigned long long) kb_base;
	case 't':
	case 'T':
		ret *= (unsigned long long) kb_base;
	case 'g':
	case 'G':
		ret *= (unsigned long long) kb_base;
	case 'm':
	case 'M':
		ret *= (unsigned long long) kb_base;
	case 'k':
	case 'K':
		ret *= (unsigned long long) kb_base;
		break;
	}

	return ret;
}

/*
 * convert string into decimal value, noting any size suffix
 */
int str_to_decimal(const char *str, long long *val, int kilo, void *data)
{
	int len, base;

	len = strlen(str);
	if (!len)
		return 1;

	if (strstr(str, "0x") || strstr(str, "0X"))
		base = 16;
	else
		base = 10;

	*val = strtoll(str, NULL, base);
	if (*val == LONG_MAX && errno == ERANGE)
		return 1;

	if (kilo) {
		const char *p;
		/*
		 * if the last char is 'b' or 'B', the user likely used
		 * "1gb" instead of just "1g". If the second to last is also
		 * a letter, adjust.
		 */
		p = str + len - 1;
		if ((*p == 'b' || *p == 'B') && isalpha(*(p - 1)))
			--p;

		*val *= get_mult_bytes(*p, data);
	} else
		*val *= get_mult_time(str[len - 1]);

	return 0;
}

static int check_str_bytes(const char *p, long long *val, void *data)
{
	return str_to_decimal(p, val, 1, data);
}

static int check_str_time(const char *p, long long *val)
{
	return str_to_decimal(p, val, 0, NULL);
}

void strip_blank_front(char **p)
{
	char *s = *p;

	while (isspace(*s))
		s++;

	*p = s;
}

void strip_blank_end(char *p)
{
	char *start = p, *s;

	s = strchr(p, ';');
	if (s)
		*s = '\0';
	s = strchr(p, '#');
	if (s)
		*s = '\0';
	if (s)
		p = s;

	s = p + strlen(p);
	while ((isspace(*s) || iscntrl(*s)) && (s > start))
		s--;

	*(s + 1) = '\0';
}

static int check_range_bytes(const char *str, long *val, void *data)
{
	char suffix;

	if (!strlen(str))
		return 1;

	if (sscanf(str, "%lu%c", val, &suffix) == 2) {
		*val *= get_mult_bytes(suffix, data);
		return 0;
	}

	if (sscanf(str, "%lu", val) == 1)
		return 0;

	return 1;
}

static int check_int(const char *p, int *val)
{
	if (!strlen(p))
		return 1;
	if (strstr(p, "0x") || strstr(p, "0X")) {
		if (sscanf(p, "%x", val) == 1)
			return 0;
	} else {
		if (sscanf(p, "%u", val) == 1)
			return 0;
	}

	return 1;
}

static inline int o_match(struct fio_option *o, const char *opt)
{
	if (!strcmp(o->name, opt))
		return 1;
	else if (o->alias && !strcmp(o->alias, opt))
		return 1;

	return 0;
}

static struct fio_option *find_option(struct fio_option *options,
				      struct flist_head *eops, const char *opt)
{
	struct flist_head *n;
	struct fio_option *o;

	for (o = &options[0]; o->name; o++)
		if (o_match(o, opt))
			return o;

	if (!eops)
		return NULL;

	flist_for_each(n, eops) {
		struct ext_option *eopt;

		eopt = flist_entry(n, struct ext_option, list);
		if (o_match(&eopt->o, opt))
			return &eopt->o;
	}

	return NULL;
}

#define val_store(ptr, val, off, data)			\
	do {						\
		ptr = td_var((data), (off));		\
		*ptr = (val);				\
	} while (0)

static int __handle_option(struct fio_option *o, const char *ptr, void *data,
			   int first, int more)
{
	int il, *ilp;
	long long ull, *ullp;
	long ul1, ul2;
	char **cp;
	int ret = 0, is_time = 0;

	dprint(FD_PARSE, "__handle_option=%s, type=%d, ptr=%s\n", o->name,
							o->type, ptr);

	if (!ptr && o->type != FIO_OPT_STR_SET && o->type != FIO_OPT_STR) {
		fprintf(stderr, "Option %s requires an argument\n", o->name);
		return 1;
	}

	switch (o->type) {
	case FIO_OPT_STR: {
		fio_opt_str_fn *fn = o->cb;
		const struct value_pair *vp;
		struct value_pair posval[PARSE_MAX_VP];
		int i;

		posval_sort(o, posval);

		for (i = 0; i < PARSE_MAX_VP; i++) {
			vp = &posval[i];
			if (!vp->ival || vp->ival[0] == '\0')
				break;
			ret = 1;
			if (!strncmp(vp->ival, ptr, strlen(vp->ival))) {
				ret = 0;
				if (o->roff1)
					*(unsigned int *) o->roff1 = vp->oval;
				else {
					if (!o->off1)
						break;
					val_store(ilp, vp->oval, o->off1, data);
				}
				break;
			}
		}

		if (ret)
			show_option_values(o);
		else if (fn)
			ret = fn(data, ptr);
		break;
	}
	case FIO_OPT_STR_VAL_TIME:
		is_time = 1;
	case FIO_OPT_INT:
	case FIO_OPT_STR_VAL: {
		fio_opt_str_val_fn *fn = o->cb;

		if (is_time)
			ret = check_str_time(ptr, &ull);
		else
			ret = check_str_bytes(ptr, &ull, data);

		if (ret)
			break;

		if (o->maxval && ull > o->maxval) {
			fprintf(stderr, "max value out of range: %lld"
					" (%d max)\n", ull, o->maxval);
			return 1;
		}
		if (o->minval && ull < o->minval) {
			fprintf(stderr, "min value out of range: %lld"
					" (%d min)\n", ull, o->minval);
			return 1;
		}

		if (fn)
			ret = fn(data, &ull);
		else {
			if (o->type == FIO_OPT_INT) {
				if (first) {
					if (o->roff1)
						*(unsigned long long *) o->roff1 = ull;
					else
						val_store(ilp, ull, o->off1, data);
				}
				if (!more) {
					if (o->roff2)
						*(unsigned long long *) o->roff2 = ull;
					else if (o->off2)
						val_store(ilp, ull, o->off2, data);
				}
			} else {
				if (first) {
					if (o->roff1)
						*(unsigned long long *) o->roff1 = ull;
					else
						val_store(ullp, ull, o->off1, data);
				}
				if (!more) {
					if (o->roff2)
						*(unsigned long long *) o->roff2 =  ull;
					else if (o->off2)
						val_store(ullp, ull, o->off2, data);
				}
			}
		}
		break;
	}
	case FIO_OPT_STR_STORE: {
		fio_opt_str_fn *fn = o->cb;

		if (o->roff1)
			cp = (char **) o->roff1;
		else
			cp = td_var(data, o->off1);

		*cp = strdup(ptr);
		if (fn) {
			ret = fn(data, ptr);
			if (ret) {
				free(*cp);
				*cp = NULL;
			}
		}
		break;
	}
	case FIO_OPT_RANGE: {
		char tmp[128];
		char *p1, *p2;

		strncpy(tmp, ptr, sizeof(tmp) - 1);

		p1 = strchr(tmp, '-');
		if (!p1) {
			p1 = strchr(tmp, ':');
			if (!p1) {
				ret = 1;
				break;
			}
		}

		p2 = p1 + 1;
		*p1 = '\0';
		p1 = tmp;

		ret = 1;
		if (!check_range_bytes(p1, &ul1, data) &&
		    !check_range_bytes(p2, &ul2, data)) {
			ret = 0;
			if (ul1 > ul2) {
				unsigned long foo = ul1;

				ul1 = ul2;
				ul2 = foo;
			}

			if (first) {
				if (o->roff1)
					*(unsigned long *) o->roff1 = ul1;
				else
					val_store(ilp, ul1, o->off1, data);
				if (o->roff2)
					*(unsigned long *) o->roff2 = ul2;
				else
					val_store(ilp, ul2, o->off2, data);
			}
			if (o->roff3 && o->roff4) {
				*(unsigned long *) o->roff3 = ul1;
				*(unsigned long *) o->roff4 = ul2;
			} else if (o->off3 && o->off4) {
				val_store(ilp, ul1, o->off3, data);
				val_store(ilp, ul2, o->off4, data);
			}
		}

		break;
	}
	case FIO_OPT_BOOL: {
		fio_opt_int_fn *fn = o->cb;

		ret = check_int(ptr, &il);
		if (ret)
			break;

		if (o->maxval && il > (int) o->maxval) {
			fprintf(stderr, "max value out of range: %d (%d max)\n",
								il, o->maxval);
			return 1;
		}
		if (o->minval && il < o->minval) {
			fprintf(stderr, "min value out of range: %d (%d min)\n",
								il, o->minval);
			return 1;
		}

		if (o->neg)
			il = !il;

		if (fn)
			ret = fn(data, &il);
		else {
			if (first) {
				if (o->roff1)
					*(unsigned int *)o->roff1 = il;
				else
					val_store(ilp, il, o->off1, data);
			}
			if (!more) {
				if (o->roff2)
					*(unsigned int *) o->roff2 = il;
				else if (o->off2)
					val_store(ilp, il, o->off2, data);
			}
		}
		break;
	}
	case FIO_OPT_STR_SET: {
		fio_opt_str_set_fn *fn = o->cb;

		if (fn)
			ret = fn(data);
		else {
			if (first) {
				if (o->roff1)
					*(unsigned int *) o->roff1 = 1;
				else
					val_store(ilp, 1, o->off1, data);
			}
			if (!more) {
				if (o->roff2)
					*(unsigned int *) o->roff2 = 1;
				else if (o->off2)
					val_store(ilp, 1, o->off2, data);
			}
		}
		break;
	}
	case FIO_OPT_DEPRECATED:
		fprintf(stdout, "Option %s is deprecated\n", o->name);
		break;
	default:
		fprintf(stderr, "Bad option type %u\n", o->type);
		ret = 1;
	}

	if (ret)
		return ret;

	if (o->verify) {
		ret = o->verify(o, data);
		if (ret) {
			fprintf(stderr,"Correct format for offending option\n");
			fprintf(stderr, "%20s: %s\n", o->name, o->help);
			show_option_help(o, stderr);
		}
	}

	return ret;
}

static int handle_option(struct fio_option *o, const char *__ptr, void *data)
{
	char *ptr, *ptr2 = NULL;
	int r1, r2;

	dprint(FD_PARSE, "handle_option=%s, ptr=%s\n", o->name, __ptr);

	ptr = NULL;
	if (__ptr)
		ptr = strdup(__ptr);

	/*
	 * See if we have a second set of parameters, hidden after a comma.
	 * Do this before parsing the first round, to check if we should
	 * copy set 1 options to set 2.
	 */
	if (ptr &&
	    (o->type != FIO_OPT_STR_STORE) &&
	    (o->type != FIO_OPT_STR)) {
		ptr2 = strchr(ptr, ',');
		if (ptr2 && *(ptr2 + 1) == '\0')
			*ptr2 = '\0';
		if (!ptr2)
			ptr2 = strchr(ptr, ':');
		if (!ptr2)
			ptr2 = strchr(ptr, '-');
	}

	/*
	 * Don't return early if parsing the first option fails - if
	 * we are doing multiple arguments, we can allow the first one
	 * being empty.
	 */
	r1 = __handle_option(o, ptr, data, 1, !!ptr2);

	if (!ptr2) {
		if (ptr)
			free(ptr);
		return r1;
	}

	ptr2++;
	r2 = __handle_option(o, ptr2, data, 0, 0);

	if (ptr)
		free(ptr);
	return r1 && r2;
}

static struct fio_option *get_option(const char *opt,
				     struct fio_option *options,
				     struct flist_head *eops, char **post)
{
	struct fio_option *o;
	char *ret;

	ret = strchr(opt, '=');
	if (ret) {
		*post = ret;
		*ret = '\0';
		ret = (char *) opt;
		(*post)++;
		strip_blank_end(ret);
		o = find_option(options, eops, ret);
	} else {
		o = find_option(options, eops, opt);
		*post = NULL;
	}

	return o;
}

static int opt_cmp(const void *p1, const void *p2)
{
	struct fio_option *o1, *o2;
	char *s1, *s2, *foo;
	int prio1, prio2;

	s1 = strdup(*((char **) p1));
	s2 = strdup(*((char **) p2));

	o1 = get_option(s1, fio_options, NULL, &foo);
	o2 = get_option(s2, fio_options, NULL, &foo);

	prio1 = prio2 = 0;
	if (o1)
		prio1 = o1->prio;
	if (o2)
		prio2 = o2->prio;

	free(s1);
	free(s2);
	return prio2 - prio1;
}

void sort_options(char **opts, struct fio_option *options, int num_opts)
{
	fio_options = options;
	qsort(opts, num_opts, sizeof(char *), opt_cmp);
	fio_options = NULL;
}

int parse_cmd_option(const char *opt, const char *val,
		     struct fio_option *options, struct flist_head *eops,
		     void *data)
{
	struct fio_option *o;

	o = find_option(options, eops, opt);
	if (!o) {
		fprintf(stderr, "Bad option <%s>\n", opt);
		return 1;
	}

	if (!handle_option(o, val, data))
		return 0;

	fprintf(stderr, "fio: failed parsing %s=%s\n", opt, val);
	return 1;
}

/*
 * Return a copy of the input string with substrings of the form ${VARNAME}
 * substituted with the value of the environment variable VARNAME.  The
 * substitution always occurs, even if VARNAME is empty or the corresponding
 * environment variable undefined.
 */
static char *option_dup_subs(const char *opt)
{
	char out[OPT_LEN_MAX+1];
	char in[OPT_LEN_MAX+1];
	char *outptr = out;
	char *inptr = in;
	char *ch1, *ch2, *env;
	ssize_t nchr = OPT_LEN_MAX;
	size_t envlen;

	if (strlen(in) + 1 > OPT_LEN_MAX) {
		fprintf(stderr, "OPT_LEN_MAX (%d) is too small\n", OPT_LEN_MAX);
		return NULL;
	}

	in[OPT_LEN_MAX] = '\0';
	strncpy(in, opt, OPT_LEN_MAX);

	while (*inptr && nchr > 0) {
		if (inptr[0] == '$' && inptr[1] == '{') {
			ch2 = strchr(inptr, '}');
			if (ch2 && inptr+1 < ch2) {
				ch1 = inptr+2;
				inptr = ch2+1;
				*ch2 = '\0';

				env = getenv(ch1);
				if (env) {
					envlen = strlen(env);
					if (envlen <= nchr) {
						memcpy(outptr, env, envlen);
						outptr += envlen;
						nchr -= envlen;
					}
				}

				continue;
			}
		}

		*outptr++ = *inptr++;
		--nchr;
	}

	*outptr = '\0';
	return strdup(out);
}

int parse_option(const char *opt, struct fio_option *options,
		 struct flist_head *ext_opt_list, void *data)
{
	struct fio_option *o;
	char *post, *tmp;

	tmp = option_dup_subs(opt);
	if (!tmp)
		return 1;

	o = get_option(tmp, options, ext_opt_list, &post);
	if (!o) {
		fprintf(stderr, "Bad option <%s>\n", tmp);
		free(tmp);
		return 1;
	}

	if (!handle_option(o, post, data)) {
		free(tmp);
		return 0;
	}

	fprintf(stderr, "fio: failed parsing %s\n", opt);
	free(tmp);
	return 1;
}

/*
 * Option match, levenshtein distance. Handy for not quite remembering what
 * the option name is.
 */
static int string_distance(const char *s1, const char *s2)
{
	unsigned int s1_len = strlen(s1);
	unsigned int s2_len = strlen(s2);
	unsigned int *p, *q, *r;
	unsigned int i, j;

	p = malloc(sizeof(unsigned int) * (s2_len + 1));
	q = malloc(sizeof(unsigned int) * (s2_len + 1));

	p[0] = 0;
	for (i = 1; i <= s2_len; i++)
		p[i] = p[i - 1] + 1;

	for (i = 1; i <= s1_len; i++) {
		q[0] = p[0] + 1;
		for (j = 1; j <= s2_len; j++) {
			unsigned int sub = p[j - 1];

			if (s1[i - 1] != s2[j - 1])
				sub++;

			q[j] = min(p[j] + 1, min(q[j - 1] + 1, sub));
		}
		r = p;
		p = q;
		q = r;
	}

	i = p[s2_len];
	free(p);
	free(q);
	return i;
}

static struct fio_option *find_child(struct fio_option *options,
				     struct fio_option *o)
{
	struct fio_option *__o;

	for (__o = options + 1; __o->name; __o++)
		if (__o->parent && !strcmp(__o->parent, o->name))
			return __o;

	return NULL;
}

static void __print_option(struct fio_option *o, struct fio_option *org,
			   int level)
{
	char name[256], *p;
	int depth;

	if (!o)
		return;
	if (!org)
		org = o;

	p = name;
	depth = level;
	while (depth--)
		p += sprintf(p, "%s", "  ");

	sprintf(p, "%s", o->name);

	printf("%-24s: %s\n", name, o->help);
}

static void print_option(struct fio_option *o)
{
	struct fio_option *parent;
	struct fio_option *__o;
	unsigned int printed;
	unsigned int level;

	__print_option(o, NULL, 0);
	parent = o;
	level = 0;
	do {
		level++;
		printed = 0;

		while ((__o = find_child(o, parent)) != NULL) {
			__print_option(__o, o, level);
			o = __o;
			printed++;
		}

		parent = o;
	} while (printed);
}

int show_cmd_help(struct fio_option *options, struct flist_head *ext_opts,
		  const char *name)
{
	struct flist_head *n;
	struct ext_option *eo;
	struct fio_option *o, *closest;
	unsigned int best_dist;
	int found = 0;
	int show_all = 0;

	if (!name || !strcmp(name, "all"))
		show_all = 1;

	closest = NULL;
	best_dist = -1;
	for (o = &options[0]; o->name; o++) {
		int match = 0;

		if (o->type == FIO_OPT_DEPRECATED)
			continue;

		if (name) {
			if (!strcmp(name, o->name) ||
			    (o->alias && !strcmp(name, o->alias)))
				match = 1;
			else {
				unsigned int dist;

				dist = string_distance(name, o->name);
				if (dist < best_dist) {
					best_dist = dist;
					closest = o;
				}
			}
		}

		if (show_all || match) {
			found = 1;
			if (match)
				printf("%24s: %s\n", o->name, o->help);
			if (show_all) {
				if (!o->parent)
					print_option(o);
				continue;
			}
		}

		if (!match)
			continue;

		show_option_help(o, stdout);
	}

	if (found)
		return 0;

	flist_for_each(n, ext_opts) {
		eo = flist_entry(n, struct ext_option, list);
		o = &eo->o;
		if (!strcmp(name, o->name) ||
		    (o->alias && !strcmp(name, o->alias))) {
			printf("%20s: %s\n", o->name, o->help);
			show_option_help(o, stdout);
			printf("%20s: External, valid for '%s'\n", "Restriction", eo->prof_name);
			return 0;
		}
	}

	printf("No such command: %s", name);
	if (closest) {
		printf(" - showing closest match\n");
		printf("%20s: %s\n", closest->name, closest->help);
		show_option_help(closest, stdout);
	} else
		printf("\n");

	return 1;
}

/*
 * Handle parsing of default parameters.
 */
void fill_default_options(void *data, struct fio_option *options)
{
	struct fio_option *o;

	dprint(FD_PARSE, "filling default options\n");

	for (o = &options[0]; o->name; o++)
		if (o->def)
			handle_option(o, o->def, data);
}

void option_init(struct fio_option *o)
{
	if (o->type == FIO_OPT_DEPRECATED)
		return;
	if (o->type == FIO_OPT_BOOL) {
		o->minval = 0;
		o->maxval = 1;
	}
	if (o->type == FIO_OPT_STR_SET && o->def) {
		fprintf(stderr, "Option %s: string set option with"
				" default will always be true\n", o->name);
	}
	if (!o->cb && (!o->off1 && !o->roff1)) {
		fprintf(stderr, "Option %s: neither cb nor offset given\n",
							o->name);
	}
	if (o->type == FIO_OPT_STR || o->type == FIO_OPT_STR_STORE)
		return;
	if (o->cb && ((o->off1 || o->off2 || o->off3 || o->off4) ||
		      (o->roff1 || o->roff2 || o->roff3 || o->roff4))) {
		fprintf(stderr, "Option %s: both cb and offset given\n",
							 o->name);
	}
}

/*
 * Sanitize the options structure. For now it just sets min/max for bool
 * values and whether both callback and offsets are given.
 */
void options_init(struct fio_option *options)
{
	struct fio_option *o;

	dprint(FD_PARSE, "init options\n");

	for (o = &options[0]; o->name; o++)
		option_init(o);
}
Commit	Line	Data
	1	/*
	2	* This file contains the ini and command liner parser main.
	3	*/
	4	#include <stdio.h>
	5	#include <stdlib.h>
	6	#include <unistd.h>
	7	#include <ctype.h>
	8	#include <string.h>
	9	#include <errno.h>
	10	#include <limits.h>
	11	#include <stdlib.h>
	12
	13	#include "parse.h"
	14	#include "debug.h"
	15	#include "options.h"
	16
	17	static struct fio_option *fio_options;
	18	extern unsigned int fio_get_kb_base(void *);
	19
	20	static int vp_cmp(const void p1, const void p2)
	21	{
	22	const struct value_pair *vp1 = p1;
	23	const struct value_pair *vp2 = p2;
	24
	25	return strlen(vp2->ival) - strlen(vp1->ival);
	26	}
	27
	28	static void posval_sort(struct fio_option o, struct value_pair vpmap)
	29	{
	30	const struct value_pair *vp;
	31	int entries;
	32
	33	memset(vpmap, 0, PARSE_MAX_VP * sizeof(struct value_pair));
	34
	35	for (entries = 0; entries < PARSE_MAX_VP; entries++) {
	36	vp = &o->posval[entries];
	37	if (!vp->ival \|\| vp->ival[0] == '\0')
	38	break;
	39
	40	memcpy(&vpmap[entries], vp, sizeof(*vp));
	41	}
	42
	43	qsort(vpmap, entries, sizeof(struct value_pair), vp_cmp);
	44	}
	45
	46	static void show_option_range(struct fio_option o, FILE out)
	47	{
	48	if (!o->minval && !o->maxval)
	49	return;
	50
	51	fprintf(out, "%20s: min=%d", "range", o->minval);
	52	if (o->maxval)
	53	fprintf(out, ", max=%d", o->maxval);
	54	fprintf(out, "\n");
	55	}
	56
	57	static void show_option_values(struct fio_option *o)
	58	{
	59	int i = 0;
	60
	61	do {
	62	const struct value_pair *vp = &o->posval[i];
	63
	64	if (!vp->ival)
	65	break;
	66
	67	printf("%20s: %-10s", i == 0 ? "valid values" : "", vp->ival);
	68	if (vp->help)
	69	printf(" %s", vp->help);
	70	printf("\n");
	71	i++;
	72	} while (i < PARSE_MAX_VP);
	73
	74	if (i)
	75	printf("\n");
	76	}
	77
	78	static void show_option_help(struct fio_option o, FILE out)
	79	{
	80	const char *typehelp[] = {
	81	"string (opt=bla)",
	82	"string with possible k/m/g postfix (opt=4k)",
	83	"string with time postfix (opt=10s)",
	84	"string (opt=bla)",
	85	"string with dual range (opt=1k-4k,4k-8k)",
	86	"integer value (opt=100)",
	87	"boolean value (opt=1)",
	88	"no argument (opt)",
	89	};
	90
	91	if (o->alias)
	92	fprintf(out, "%20s: %s\n", "alias", o->alias);
	93
	94	fprintf(out, "%20s: %s\n", "type", typehelp[o->type]);
	95	fprintf(out, "%20s: %s\n", "default", o->def ? o->def : "no default");
	96	show_option_range(o, stdout);
	97	show_option_values(o);
	98	}
	99
	100	static unsigned long get_mult_time(char c)
	101	{
	102	switch (c) {
	103	case 'm':
	104	case 'M':
	105	return 60;
	106	case 'h':
	107	case 'H':
	108	return 60 * 60;
	109	case 'd':
	110	case 'D':
	111	return 24 * 60 * 60;
	112	default:
	113	return 1;
	114	}
	115	}
	116
	117	static unsigned long long get_mult_bytes(char c, void *data)
	118	{
	119	unsigned int kb_base = fio_get_kb_base(data);
	120	unsigned long long ret = 1;
	121
	122	switch (c) {
	123	default:
	124	break;
	125	case 'p':
	126	case 'P':
	127	ret *= (unsigned long long) kb_base;
	128	case 't':
	129	case 'T':
	130	ret *= (unsigned long long) kb_base;
	131	case 'g':
	132	case 'G':
	133	ret *= (unsigned long long) kb_base;
	134	case 'm':
	135	case 'M':
	136	ret *= (unsigned long long) kb_base;
	137	case 'k':
	138	case 'K':
	139	ret *= (unsigned long long) kb_base;
	140	break;
	141	}
	142
	143	return ret;
	144	}
	145
	146	/*
	147	* convert string into decimal value, noting any size suffix
	148	*/
	149	int str_to_decimal(const char str, long long val, int kilo, void *data)
	150	{
	151	int len, base;
	152
	153	len = strlen(str);
	154	if (!len)
	155	return 1;
	156
	157	if (strstr(str, "0x") \|\| strstr(str, "0X"))
	158	base = 16;
	159	else
	160	base = 10;
	161
	162	*val = strtoll(str, NULL, base);
	163	if (*val == LONG_MAX && errno == ERANGE)
	164	return 1;
	165
	166	if (kilo) {
	167	const char *p;
	168	/*
	169	* if the last char is 'b' or 'B', the user likely used
	170	* "1gb" instead of just "1g". If the second to last is also
	171	* a letter, adjust.
	172	*/
	173	p = str + len - 1;
	174	if ((p == 'b' \|\| p == 'B') && isalpha(*(p - 1)))
	175	--p;
	176
	177	val = get_mult_bytes(*p, data);
	178	} else
	179	val = get_mult_time(str[len - 1]);
	180
	181	return 0;
	182	}
	183
	184	static int check_str_bytes(const char p, long long val, void *data)
	185	{
	186	return str_to_decimal(p, val, 1, data);
	187	}
	188
	189	static int check_str_time(const char p, long long val)
	190	{
	191	return str_to_decimal(p, val, 0, NULL);
	192	}
	193
	194	void strip_blank_front(char **p)
	195	{
	196	char s = p;
	197
	198	while (isspace(*s))
	199	s++;
	200
	201	*p = s;
	202	}
	203
	204	void strip_blank_end(char *p)
	205	{
	206	char start = p, s;
	207
	208	s = strchr(p, ';');
	209	if (s)
	210	*s = '\0';
	211	s = strchr(p, '#');
	212	if (s)
	213	*s = '\0';
	214	if (s)
	215	p = s;
	216
	217	s = p + strlen(p);
	218	while ((isspace(s) \|\| iscntrl(s)) && (s > start))
	219	s--;
	220
	221	*(s + 1) = '\0';
	222	}
	223
	224	static int check_range_bytes(const char str, long val, void *data)
	225	{
	226	char suffix;
	227
	228	if (!strlen(str))
	229	return 1;
	230
	231	if (sscanf(str, "%lu%c", val, &suffix) == 2) {
	232	val = get_mult_bytes(suffix, data);
	233	return 0;
	234	}
	235
	236	if (sscanf(str, "%lu", val) == 1)
	237	return 0;
	238
	239	return 1;
	240	}
	241
	242	static int check_int(const char p, int val)
	243	{
	244	if (!strlen(p))
	245	return 1;
	246	if (strstr(p, "0x") \|\| strstr(p, "0X")) {
	247	if (sscanf(p, "%x", val) == 1)
	248	return 0;
	249	} else {
	250	if (sscanf(p, "%u", val) == 1)
	251	return 0;
	252	}
	253
	254	return 1;
	255	}
	256
	257	static inline int o_match(struct fio_option o, const char opt)
	258	{
	259	if (!strcmp(o->name, opt))
	260	return 1;
	261	else if (o->alias && !strcmp(o->alias, opt))
	262	return 1;
	263
	264	return 0;
	265	}
	266
	267	static struct fio_option find_option(struct fio_option options,
	268	struct flist_head eops, const char opt)
	269	{
	270	struct flist_head *n;
	271	struct fio_option *o;
	272
	273	for (o = &options[0]; o->name; o++)
	274	if (o_match(o, opt))
	275	return o;
	276
	277	if (!eops)
	278	return NULL;
	279
	280	flist_for_each(n, eops) {
	281	struct ext_option *eopt;
	282
	283	eopt = flist_entry(n, struct ext_option, list);
	284	if (o_match(&eopt->o, opt))
	285	return &eopt->o;
	286	}
	287
	288	return NULL;
	289	}
	290
	291	#define val_store(ptr, val, off, data) \
	292	do { \
	293	ptr = td_var((data), (off)); \
	294	*ptr = (val); \
	295	} while (0)
	296
	297	static int __handle_option(struct fio_option o, const char ptr, void *data,
	298	int first, int more)
	299	{
	300	int il, *ilp;
	301	long long ull, *ullp;
	302	long ul1, ul2;
	303	char **cp;
	304	int ret = 0, is_time = 0;
	305
	306	dprint(FD_PARSE, "__handle_option=%s, type=%d, ptr=%s\n", o->name,
	307	o->type, ptr);
	308
	309	if (!ptr && o->type != FIO_OPT_STR_SET && o->type != FIO_OPT_STR) {
	310	fprintf(stderr, "Option %s requires an argument\n", o->name);
	311	return 1;
	312	}
	313
	314	switch (o->type) {
	315	case FIO_OPT_STR: {
	316	fio_opt_str_fn *fn = o->cb;
	317	const struct value_pair *vp;
	318	struct value_pair posval[PARSE_MAX_VP];
	319	int i;
	320
	321	posval_sort(o, posval);
	322
	323	for (i = 0; i < PARSE_MAX_VP; i++) {
	324	vp = &posval[i];
	325	if (!vp->ival \|\| vp->ival[0] == '\0')
	326	break;
	327	ret = 1;
	328	if (!strncmp(vp->ival, ptr, strlen(vp->ival))) {
	329	ret = 0;
	330	if (o->roff1)
	331	(unsigned int ) o->roff1 = vp->oval;
	332	else {
	333	if (!o->off1)
	334	break;
	335	val_store(ilp, vp->oval, o->off1, data);
	336	}
	337	break;
	338	}
	339	}
	340
	341	if (ret)
	342	show_option_values(o);
	343	else if (fn)
	344	ret = fn(data, ptr);
	345	break;
	346	}
	347	case FIO_OPT_STR_VAL_TIME:
	348	is_time = 1;
	349	case FIO_OPT_INT:
	350	case FIO_OPT_STR_VAL: {
	351	fio_opt_str_val_fn *fn = o->cb;
	352
	353	if (is_time)
	354	ret = check_str_time(ptr, &ull);
	355	else
	356	ret = check_str_bytes(ptr, &ull, data);
	357
	358	if (ret)
	359	break;
	360
	361	if (o->maxval && ull > o->maxval) {
	362	fprintf(stderr, "max value out of range: %lld"
	363	" (%d max)\n", ull, o->maxval);
	364	return 1;
	365	}
	366	if (o->minval && ull < o->minval) {
	367	fprintf(stderr, "min value out of range: %lld"
	368	" (%d min)\n", ull, o->minval);
	369	return 1;
	370	}
	371
	372	if (fn)
	373	ret = fn(data, &ull);
	374	else {
	375	if (o->type == FIO_OPT_INT) {
	376	if (first) {
	377	if (o->roff1)
	378	(unsigned long long ) o->roff1 = ull;
	379	else
	380	val_store(ilp, ull, o->off1, data);
	381	}
	382	if (!more) {
	383	if (o->roff2)
	384	(unsigned long long ) o->roff2 = ull;
	385	else if (o->off2)
	386	val_store(ilp, ull, o->off2, data);
	387	}
	388	} else {
	389	if (first) {
	390	if (o->roff1)
	391	(unsigned long long ) o->roff1 = ull;
	392	else
	393	val_store(ullp, ull, o->off1, data);
	394	}
	395	if (!more) {
	396	if (o->roff2)
	397	(unsigned long long ) o->roff2 = ull;
	398	else if (o->off2)
	399	val_store(ullp, ull, o->off2, data);
	400	}
	401	}
	402	}
	403	break;
	404	}
	405	case FIO_OPT_STR_STORE: {
	406	fio_opt_str_fn *fn = o->cb;
	407
	408	if (o->roff1)
	409	cp = (char **) o->roff1;
	410	else
	411	cp = td_var(data, o->off1);
	412
	413	*cp = strdup(ptr);
	414	if (fn) {
	415	ret = fn(data, ptr);
	416	if (ret) {
	417	free(*cp);
	418	*cp = NULL;
	419	}
	420	}
	421	break;
	422	}
	423	case FIO_OPT_RANGE: {
	424	char tmp[128];
	425	char p1, p2;
	426
	427	strncpy(tmp, ptr, sizeof(tmp) - 1);
	428
	429	p1 = strchr(tmp, '-');
	430	if (!p1) {
	431	p1 = strchr(tmp, ':');
	432	if (!p1) {
	433	ret = 1;
	434	break;
	435	}
	436	}
	437
	438	p2 = p1 + 1;
	439	*p1 = '\0';
	440	p1 = tmp;
	441
	442	ret = 1;
	443	if (!check_range_bytes(p1, &ul1, data) &&
	444	!check_range_bytes(p2, &ul2, data)) {
	445	ret = 0;
	446	if (ul1 > ul2) {
	447	unsigned long foo = ul1;
	448
	449	ul1 = ul2;
	450	ul2 = foo;
	451	}
	452
	453	if (first) {
	454	if (o->roff1)
	455	(unsigned long ) o->roff1 = ul1;
	456	else
	457	val_store(ilp, ul1, o->off1, data);
	458	if (o->roff2)
	459	(unsigned long ) o->roff2 = ul2;
	460	else
	461	val_store(ilp, ul2, o->off2, data);
	462	}
	463	if (o->roff3 && o->roff4) {
	464	(unsigned long ) o->roff3 = ul1;
	465	(unsigned long ) o->roff4 = ul2;
	466	} else if (o->off3 && o->off4) {
	467	val_store(ilp, ul1, o->off3, data);
	468	val_store(ilp, ul2, o->off4, data);
	469	}
	470	}
	471
	472	break;
	473	}
	474	case FIO_OPT_BOOL: {
	475	fio_opt_int_fn *fn = o->cb;
	476
	477	ret = check_int(ptr, &il);
	478	if (ret)
	479	break;
	480
	481	if (o->maxval && il > (int) o->maxval) {
	482	fprintf(stderr, "max value out of range: %d (%d max)\n",
	483	il, o->maxval);
	484	return 1;
	485	}
	486	if (o->minval && il < o->minval) {
	487	fprintf(stderr, "min value out of range: %d (%d min)\n",
	488	il, o->minval);
	489	return 1;
	490	}
	491
	492	if (o->neg)
	493	il = !il;
	494
	495	if (fn)
	496	ret = fn(data, &il);
	497	else {
	498	if (first) {
	499	if (o->roff1)
	500	(unsigned int )o->roff1 = il;
	501	else
	502	val_store(ilp, il, o->off1, data);
	503	}
	504	if (!more) {
	505	if (o->roff2)
	506	(unsigned int ) o->roff2 = il;
	507	else if (o->off2)
	508	val_store(ilp, il, o->off2, data);
	509	}
	510	}
	511	break;
	512	}
	513	case FIO_OPT_STR_SET: {
	514	fio_opt_str_set_fn *fn = o->cb;
	515
	516	if (fn)
	517	ret = fn(data);
	518	else {
	519	if (first) {
	520	if (o->roff1)
	521	(unsigned int ) o->roff1 = 1;
	522	else
	523	val_store(ilp, 1, o->off1, data);
	524	}
	525	if (!more) {
	526	if (o->roff2)
	527	(unsigned int ) o->roff2 = 1;
	528	else if (o->off2)
	529	val_store(ilp, 1, o->off2, data);
	530	}
	531	}
	532	break;
	533	}
	534	case FIO_OPT_DEPRECATED:
	535	fprintf(stdout, "Option %s is deprecated\n", o->name);
	536	break;
	537	default:
	538	fprintf(stderr, "Bad option type %u\n", o->type);
	539	ret = 1;
	540	}
	541
	542	if (ret)
	543	return ret;
	544
	545	if (o->verify) {
	546	ret = o->verify(o, data);
	547	if (ret) {
	548	fprintf(stderr,"Correct format for offending option\n");
	549	fprintf(stderr, "%20s: %s\n", o->name, o->help);
	550	show_option_help(o, stderr);
	551	}
	552	}
	553
	554	return ret;
	555	}
	556
	557	static int handle_option(struct fio_option o, const char __ptr, void *data)
	558	{
	559	char ptr, ptr2 = NULL;
	560	int r1, r2;
	561
	562	dprint(FD_PARSE, "handle_option=%s, ptr=%s\n", o->name, __ptr);
	563
	564	ptr = NULL;
	565	if (__ptr)
	566	ptr = strdup(__ptr);
	567
	568	/*
	569	* See if we have a second set of parameters, hidden after a comma.
	570	* Do this before parsing the first round, to check if we should
	571	* copy set 1 options to set 2.
	572	*/
	573	if (ptr &&
	574	(o->type != FIO_OPT_STR_STORE) &&
	575	(o->type != FIO_OPT_STR)) {
	576	ptr2 = strchr(ptr, ',');
	577	if (ptr2 && *(ptr2 + 1) == '\0')
	578	*ptr2 = '\0';
	579	if (!ptr2)
	580	ptr2 = strchr(ptr, ':');
	581	if (!ptr2)
	582	ptr2 = strchr(ptr, '-');
	583	}
	584
	585	/*
	586	* Don't return early if parsing the first option fails - if
	587	* we are doing multiple arguments, we can allow the first one
	588	* being empty.
	589	*/
	590	r1 = __handle_option(o, ptr, data, 1, !!ptr2);
	591
	592	if (!ptr2) {
	593	if (ptr)
	594	free(ptr);
	595	return r1;
	596	}
	597
	598	ptr2++;
	599	r2 = __handle_option(o, ptr2, data, 0, 0);
	600
	601	if (ptr)
	602	free(ptr);
	603	return r1 && r2;
	604	}
	605
	606	static struct fio_option get_option(const char opt,
	607	struct fio_option *options,
	608	struct flist_head eops, char *post)
	609	{
	610	struct fio_option *o;
	611	char *ret;
	612
	613	ret = strchr(opt, '=');
	614	if (ret) {
	615	*post = ret;
	616	*ret = '\0';
	617	ret = (char *) opt;
	618	(*post)++;
	619	strip_blank_end(ret);
	620	o = find_option(options, eops, ret);
	621	} else {
	622	o = find_option(options, eops, opt);
	623	*post = NULL;
	624	}
	625
	626	return o;
	627	}
	628
	629	static int opt_cmp(const void p1, const void p2)
	630	{
	631	struct fio_option o1, o2;
	632	char s1, s2, *foo;
	633	int prio1, prio2;
	634
	635	s1 = strdup(((char *) p1));
	636	s2 = strdup(((char *) p2));
	637
	638	o1 = get_option(s1, fio_options, NULL, &foo);
	639	o2 = get_option(s2, fio_options, NULL, &foo);
	640
	641	prio1 = prio2 = 0;
	642	if (o1)
	643	prio1 = o1->prio;
	644	if (o2)
	645	prio2 = o2->prio;
	646
	647	free(s1);
	648	free(s2);
	649	return prio2 - prio1;
	650	}
	651
	652	void sort_options(char *opts, struct fio_option options, int num_opts)
	653	{
	654	fio_options = options;
	655	qsort(opts, num_opts, sizeof(char *), opt_cmp);
	656	fio_options = NULL;
	657	}
	658
	659	int parse_cmd_option(const char opt, const char val,
	660	struct fio_option options, struct flist_head eops,
	661	void *data)
	662	{
	663	struct fio_option *o;
	664
	665	o = find_option(options, eops, opt);
	666	if (!o) {
	667	fprintf(stderr, "Bad option <%s>\n", opt);
	668	return 1;
	669	}
	670
	671	if (!handle_option(o, val, data))
	672	return 0;
	673
	674	fprintf(stderr, "fio: failed parsing %s=%s\n", opt, val);
	675	return 1;
	676	}
	677
	678	/*
	679	* Return a copy of the input string with substrings of the form ${VARNAME}
	680	* substituted with the value of the environment variable VARNAME. The
	681	* substitution always occurs, even if VARNAME is empty or the corresponding
	682	* environment variable undefined.
	683	*/
	684	static char option_dup_subs(const char opt)
	685	{
	686	char out[OPT_LEN_MAX+1];
	687	char in[OPT_LEN_MAX+1];
	688	char *outptr = out;
	689	char *inptr = in;
	690	char ch1, ch2, *env;
	691	ssize_t nchr = OPT_LEN_MAX;
	692	size_t envlen;
	693
	694	if (strlen(in) + 1 > OPT_LEN_MAX) {
	695	fprintf(stderr, "OPT_LEN_MAX (%d) is too small\n", OPT_LEN_MAX);
	696	return NULL;
	697	}
	698
	699	in[OPT_LEN_MAX] = '\0';
	700	strncpy(in, opt, OPT_LEN_MAX);
	701
	702	while (*inptr && nchr > 0) {
	703	if (inptr[0] == '$' && inptr[1] == '{') {
	704	ch2 = strchr(inptr, '}');
	705	if (ch2 && inptr+1 < ch2) {
	706	ch1 = inptr+2;
	707	inptr = ch2+1;
	708	*ch2 = '\0';
	709
	710	env = getenv(ch1);
	711	if (env) {
	712	envlen = strlen(env);
	713	if (envlen <= nchr) {
	714	memcpy(outptr, env, envlen);
	715	outptr += envlen;
	716	nchr -= envlen;
	717	}
	718	}
	719
	720	continue;
	721	}
	722	}
	723
	724	outptr++ = inptr++;
	725	--nchr;
	726	}
	727
	728	*outptr = '\0';
	729	return strdup(out);
	730	}
	731
	732	int parse_option(const char opt, struct fio_option options,
	733	struct flist_head ext_opt_list, void data)
	734	{
	735	struct fio_option *o;
	736	char post, tmp;
	737
	738	tmp = option_dup_subs(opt);
	739	if (!tmp)
	740	return 1;
	741
	742	o = get_option(tmp, options, ext_opt_list, &post);
	743	if (!o) {
	744	fprintf(stderr, "Bad option <%s>\n", tmp);
	745	free(tmp);
	746	return 1;
	747	}
	748
	749	if (!handle_option(o, post, data)) {
	750	free(tmp);
	751	return 0;
	752	}
	753
	754	fprintf(stderr, "fio: failed parsing %s\n", opt);
	755	free(tmp);
	756	return 1;
	757	}
	758
	759	/*
	760	* Option match, levenshtein distance. Handy for not quite remembering what
	761	* the option name is.
	762	*/
	763	static int string_distance(const char s1, const char s2)
	764	{
	765	unsigned int s1_len = strlen(s1);
	766	unsigned int s2_len = strlen(s2);
	767	unsigned int p, q, *r;
	768	unsigned int i, j;
	769
	770	p = malloc(sizeof(unsigned int) * (s2_len + 1));
	771	q = malloc(sizeof(unsigned int) * (s2_len + 1));
	772
	773	p[0] = 0;
	774	for (i = 1; i <= s2_len; i++)
	775	p[i] = p[i - 1] + 1;
	776
	777	for (i = 1; i <= s1_len; i++) {
	778	q[0] = p[0] + 1;
	779	for (j = 1; j <= s2_len; j++) {
	780	unsigned int sub = p[j - 1];
	781
	782	if (s1[i - 1] != s2[j - 1])
	783	sub++;
	784
	785	q[j] = min(p[j] + 1, min(q[j - 1] + 1, sub));
	786	}
	787	r = p;
	788	p = q;
	789	q = r;
	790	}
	791
	792	i = p[s2_len];
	793	free(p);
	794	free(q);
	795	return i;
	796	}
	797
	798	static struct fio_option find_child(struct fio_option options,
	799	struct fio_option *o)
	800	{
	801	struct fio_option *__o;
	802
	803	for (__o = options + 1; __o->name; __o++)
	804	if (__o->parent && !strcmp(__o->parent, o->name))
	805	return __o;
	806
	807	return NULL;
	808	}
	809
	810	static void __print_option(struct fio_option o, struct fio_option org,
	811	int level)
	812	{
	813	char name[256], *p;
	814	int depth;
	815
	816	if (!o)
	817	return;
	818	if (!org)
	819	org = o;
	820
	821	p = name;
	822	depth = level;
	823	while (depth--)
	824	p += sprintf(p, "%s", " ");
	825
	826	sprintf(p, "%s", o->name);
	827
	828	printf("%-24s: %s\n", name, o->help);
	829	}
	830
	831	static void print_option(struct fio_option *o)
	832	{
	833	struct fio_option *parent;
	834	struct fio_option *__o;
	835	unsigned int printed;
	836	unsigned int level;
	837
	838	__print_option(o, NULL, 0);
	839	parent = o;
	840	level = 0;
	841	do {
	842	level++;
	843	printed = 0;
	844
	845	while ((__o = find_child(o, parent)) != NULL) {
	846	__print_option(__o, o, level);
	847	o = __o;
	848	printed++;
	849	}
	850
	851	parent = o;
	852	} while (printed);
	853	}
	854
	855	int show_cmd_help(struct fio_option options, struct flist_head ext_opts,
	856	const char *name)
	857	{
	858	struct flist_head *n;
	859	struct ext_option *eo;
	860	struct fio_option o, closest;
	861	unsigned int best_dist;
	862	int found = 0;
	863	int show_all = 0;
	864
	865	if (!name \|\| !strcmp(name, "all"))
	866	show_all = 1;
	867
	868	closest = NULL;
	869	best_dist = -1;
	870	for (o = &options[0]; o->name; o++) {
	871	int match = 0;
	872
	873	if (o->type == FIO_OPT_DEPRECATED)
	874	continue;
	875
	876	if (name) {
	877	if (!strcmp(name, o->name) \|\|
	878	(o->alias && !strcmp(name, o->alias)))
	879	match = 1;
	880	else {
	881	unsigned int dist;
	882
	883	dist = string_distance(name, o->name);
	884	if (dist < best_dist) {
	885	best_dist = dist;
	886	closest = o;
	887	}
	888	}
	889	}
	890
	891	if (show_all \|\| match) {
	892	found = 1;
	893	if (match)
	894	printf("%24s: %s\n", o->name, o->help);
	895	if (show_all) {
	896	if (!o->parent)
	897	print_option(o);
	898	continue;
	899	}
	900	}
	901
	902	if (!match)
	903	continue;
	904
	905	show_option_help(o, stdout);
	906	}
	907
	908	if (found)
	909	return 0;
	910
	911	flist_for_each(n, ext_opts) {
	912	eo = flist_entry(n, struct ext_option, list);
	913	o = &eo->o;
	914	if (!strcmp(name, o->name) \|\|
	915	(o->alias && !strcmp(name, o->alias))) {
	916	printf("%20s: %s\n", o->name, o->help);
	917	show_option_help(o, stdout);
	918	printf("%20s: External, valid for '%s'\n", "Restriction", eo->prof_name);
	919	return 0;
	920	}
	921	}
	922
	923	printf("No such command: %s", name);
	924	if (closest) {
	925	printf(" - showing closest match\n");
	926	printf("%20s: %s\n", closest->name, closest->help);
	927	show_option_help(closest, stdout);
	928	} else
	929	printf("\n");
	930
	931	return 1;
	932	}
	933
	934	/*
	935	* Handle parsing of default parameters.
	936	*/
	937	void fill_default_options(void data, struct fio_option options)
	938	{
	939	struct fio_option *o;
	940
	941	dprint(FD_PARSE, "filling default options\n");
	942
	943	for (o = &options[0]; o->name; o++)
	944	if (o->def)
	945	handle_option(o, o->def, data);
	946	}
	947
	948	void option_init(struct fio_option *o)
	949	{
	950	if (o->type == FIO_OPT_DEPRECATED)
	951	return;
	952	if (o->type == FIO_OPT_BOOL) {
	953	o->minval = 0;
	954	o->maxval = 1;
	955	}
	956	if (o->type == FIO_OPT_STR_SET && o->def) {
	957	fprintf(stderr, "Option %s: string set option with"
	958	" default will always be true\n", o->name);
	959	}
	960	if (!o->cb && (!o->off1 && !o->roff1)) {
	961	fprintf(stderr, "Option %s: neither cb nor offset given\n",
	962	o->name);
	963	}
	964	if (o->type == FIO_OPT_STR \|\| o->type == FIO_OPT_STR_STORE)
	965	return;
	966	if (o->cb && ((o->off1 \|\| o->off2 \|\| o->off3 \|\| o->off4) \|\|
	967	(o->roff1 \|\| o->roff2 \|\| o->roff3 \|\| o->roff4))) {
	968	fprintf(stderr, "Option %s: both cb and offset given\n",
	969	o->name);
	970	}
	971	}
	972
	973	/*
	974	* Sanitize the options structure. For now it just sets min/max for bool
	975	* values and whether both callback and offsets are given.
	976	*/
	977	void options_init(struct fio_option *options)
	978	{
	979	struct fio_option *o;
	980
	981	dprint(FD_PARSE, "init options\n");
	982
	983	for (o = &options[0]; o->name; o++)
	984	option_init(o);
	985	}