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