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