92501338d456fde659af69beb8066ce239f39a8a
[fio.git] / parse.c
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
21 static struct fio_option *__fio_options;
22
23 static int vp_cmp(const void *p1, const void *p2)
24 {
25         const struct value_pair *vp1 = p1;
26         const struct value_pair *vp2 = p2;
27
28         return strlen(vp2->ival) - strlen(vp1->ival);
29 }
30
31 static void posval_sort(struct fio_option *o, struct value_pair *vpmap)
32 {
33         const struct value_pair *vp;
34         int entries;
35
36         memset(vpmap, 0, PARSE_MAX_VP * sizeof(struct value_pair));
37
38         for (entries = 0; entries < PARSE_MAX_VP; entries++) {
39                 vp = &o->posval[entries];
40                 if (!vp->ival || vp->ival[0] == '\0')
41                         break;
42
43                 memcpy(&vpmap[entries], vp, sizeof(*vp));
44         }
45
46         qsort(vpmap, entries, sizeof(struct value_pair), vp_cmp);
47 }
48
49 static void show_option_range(struct fio_option *o,
50                                 int (*logger)(const char *format, ...))
51 {
52         if (o->type == FIO_OPT_FLOAT_LIST){
53                 if (o->minfp == DBL_MIN && o->maxfp == DBL_MAX)
54                         return;
55
56                 logger("%20s: min=%f", "range", o->minfp);
57                 if (o->maxfp != DBL_MAX)
58                         logger(", max=%f", o->maxfp);
59                 logger("\n");
60         } else {
61                 if (!o->minval && !o->maxval)
62                         return;
63
64                 logger("%20s: min=%d", "range", o->minval);
65                 if (o->maxval)
66                         logger(", max=%d", o->maxval);
67                 logger("\n");
68         }
69 }
70
71 static void show_option_values(struct fio_option *o)
72 {
73         int i;
74
75         for (i = 0; i < PARSE_MAX_VP; i++) {
76                 const struct value_pair *vp = &o->posval[i];
77
78                 if (!vp->ival)
79                         continue;
80
81                 log_info("%20s: %-10s", i == 0 ? "valid values" : "", vp->ival);
82                 if (vp->help)
83                         log_info(" %s", vp->help);
84                 log_info("\n");
85         }
86
87         if (i)
88                 log_info("\n");
89 }
90
91 static void show_option_help(struct fio_option *o, int is_err)
92 {
93         const char *typehelp[] = {
94                 "invalid",
95                 "string (opt=bla)",
96                 "string (opt=bla)",
97                 "string with possible k/m/g postfix (opt=4k)",
98                 "string with time postfix (opt=10s)",
99                 "string (opt=bla)",
100                 "string with dual range (opt=1k-4k,4k-8k)",
101                 "integer value (opt=100)",
102                 "boolean value (opt=1)",
103                 "list of floating point values separated by ':' (opt=5.9:7.8)",
104                 "no argument (opt)",
105                 "deprecated",
106         };
107         int (*logger)(const char *format, ...);
108
109         if (is_err)
110                 logger = log_err;
111         else
112                 logger = log_info;
113
114         if (o->alias)
115                 logger("%20s: %s\n", "alias", o->alias);
116
117         logger("%20s: %s\n", "type", typehelp[o->type]);
118         logger("%20s: %s\n", "default", o->def ? o->def : "no default");
119         if (o->prof_name)
120                 logger("%20s: only for profile '%s'\n", "valid", o->prof_name);
121         show_option_range(o, logger);
122         show_option_values(o);
123 }
124
125 static unsigned long get_mult_time(char c)
126 {
127         switch (c) {
128         case 'm':
129         case 'M':
130                 return 60;
131         case 'h':
132         case 'H':
133                 return 60 * 60;
134         case 'd':
135         case 'D':
136                 return 24 * 60 * 60;
137         default:
138                 return 1;
139         }
140 }
141
142 static unsigned long long __get_mult_bytes(const char *p, void *data,
143                                            int *percent)
144 {
145         unsigned int kb_base = fio_get_kb_base(data);
146         unsigned long long ret = 1;
147         unsigned int i, pow = 0, mult = kb_base;
148         char *c;
149
150         if (!p)
151                 return 1;
152
153         c = strdup(p);
154
155         for (i = 0; i < strlen(c); i++)
156                 c[i] = tolower(c[i]);
157
158         if (!strncmp("pib", c, 3)) {
159                 pow = 5;
160                 mult = 1000;
161         } else if (!strncmp("tib", c, 3)) {
162                 pow = 4;
163                 mult = 1000;
164         } else if (!strncmp("gib", c, 3)) {
165                 pow = 3;
166                 mult = 1000;
167         } else if (!strncmp("mib", c, 3)) {
168                 pow = 2;
169                 mult = 1000;
170         } else if (!strncmp("kib", c, 3)) {
171                 pow = 1;
172                 mult = 1000;
173         } else if (!strncmp("p", c, 1) || !strncmp("pb", c, 2))
174                 pow = 5;
175         else if (!strncmp("t", c, 1) || !strncmp("tb", c, 2))
176                 pow = 4;
177         else if (!strncmp("g", c, 1) || !strncmp("gb", c, 2))
178                 pow = 3;
179         else if (!strncmp("m", c, 1) || !strncmp("mb", c, 2))
180                 pow = 2;
181         else if (!strncmp("k", c, 1) || !strncmp("kb", c, 2))
182                 pow = 1;
183         else if (!strncmp("%", c, 1)) {
184                 *percent = 1;
185                 free(c);
186                 return ret;
187         }
188
189         while (pow--)
190                 ret *= (unsigned long long) mult;
191
192         free(c);
193         return ret;
194 }
195
196 static unsigned long long get_mult_bytes(const char *str, int len, void *data,
197                                          int *percent)
198 {
199         const char *p = str;
200         int digit_seen = 0;
201
202         if (len < 2)
203                 return __get_mult_bytes(str, data, percent);
204
205         /*
206          * Go forward until we hit a non-digit, or +/- sign
207          */
208         while ((p - str) <= len) {
209                 if (!isdigit((int) *p) &&
210                     (((*p != '+') && (*p != '-')) || digit_seen))
211                         break;
212                 digit_seen |= isdigit((int) *p);
213                 p++;
214         }
215
216         if (!isalpha((int) *p) && (*p != '%'))
217                 p = NULL;
218
219         return __get_mult_bytes(p, data, percent);
220 }
221
222 /*
223  * Convert string into a floating number. Return 1 for success and 0 otherwise.
224  */
225 int str_to_float(const char *str, double *val)
226 {
227         return (1 == sscanf(str, "%lf", val));
228 }
229
230 /*
231  * convert string into decimal value, noting any size suffix
232  */
233 int str_to_decimal(const char *str, long long *val, int kilo, void *data)
234 {
235         int len, base;
236
237         len = strlen(str);
238         if (!len)
239                 return 1;
240
241         if (strstr(str, "0x") || strstr(str, "0X"))
242                 base = 16;
243         else
244                 base = 10;
245
246         *val = strtoll(str, NULL, base);
247         if (*val == LONG_MAX && errno == ERANGE)
248                 return 1;
249
250         if (kilo) {
251                 unsigned long long mult;
252                 int perc = 0;
253
254                 mult = get_mult_bytes(str, len, data, &perc);
255                 if (perc)
256                         *val = -1ULL - *val;
257                 else
258                         *val *= mult;
259         } else
260                 *val *= get_mult_time(str[len - 1]);
261
262         return 0;
263 }
264
265 int check_str_bytes(const char *p, long long *val, void *data)
266 {
267         return str_to_decimal(p, val, 1, data);
268 }
269
270 static int check_str_time(const char *p, long long *val)
271 {
272         return str_to_decimal(p, val, 0, NULL);
273 }
274
275 void strip_blank_front(char **p)
276 {
277         char *s = *p;
278
279         if (!strlen(s))
280                 return;
281         while (isspace((int) *s))
282                 s++;
283
284         *p = s;
285 }
286
287 void strip_blank_end(char *p)
288 {
289         char *start = p, *s;
290
291         if (!strlen(p))
292                 return;
293
294         s = strchr(p, ';');
295         if (s)
296                 *s = '\0';
297         s = strchr(p, '#');
298         if (s)
299                 *s = '\0';
300         if (s)
301                 p = s;
302
303         s = p + strlen(p);
304         while ((isspace((int) *s) || iscntrl((int) *s)) && (s > start))
305                 s--;
306
307         *(s + 1) = '\0';
308 }
309
310 static int check_range_bytes(const char *str, long *val, void *data)
311 {
312         long long __val;
313
314         if (!str_to_decimal(str, &__val, 1, data)) {
315                 *val = __val;
316                 return 0;
317         }
318
319         return 1;
320 }
321
322 static int check_int(const char *p, int *val)
323 {
324         if (!strlen(p))
325                 return 1;
326         if (strstr(p, "0x") || strstr(p, "0X")) {
327                 if (sscanf(p, "%x", val) == 1)
328                         return 0;
329         } else {
330                 if (sscanf(p, "%u", val) == 1)
331                         return 0;
332         }
333
334         return 1;
335 }
336
337 static int opt_len(const char *str)
338 {
339         char *postfix;
340
341         postfix = strchr(str, ':');
342         if (!postfix)
343                 return strlen(str);
344
345         return (int)(postfix - str);
346 }
347
348 static int str_match_len(const struct value_pair *vp, const char *str)
349 {
350         return max(strlen(vp->ival), opt_len(str));
351 }
352
353 #define val_store(ptr, val, off, or, data)              \
354         do {                                            \
355                 ptr = td_var((data), (off));            \
356                 if ((or))                               \
357                         *ptr |= (val);                  \
358                 else                                    \
359                         *ptr = (val);                   \
360         } while (0)
361
362 static int __handle_option(struct fio_option *o, const char *ptr, void *data,
363                            int first, int more, int curr)
364 {
365         int il, *ilp;
366         fio_fp64_t *flp;
367         long long ull, *ullp;
368         long ul1, ul2;
369         double uf;
370         char **cp = NULL;
371         int ret = 0, is_time = 0;
372         const struct value_pair *vp;
373         struct value_pair posval[PARSE_MAX_VP];
374         int i, all_skipped = 1;
375
376         dprint(FD_PARSE, "__handle_option=%s, type=%d, ptr=%s\n", o->name,
377                                                         o->type, ptr);
378
379         if (!ptr && o->type != FIO_OPT_STR_SET && o->type != FIO_OPT_STR) {
380                 log_err("Option %s requires an argument\n", o->name);
381                 return 1;
382         }
383
384         switch (o->type) {
385         case FIO_OPT_STR:
386         case FIO_OPT_STR_MULTI: {
387                 fio_opt_str_fn *fn = o->cb;
388
389                 posval_sort(o, posval);
390
391                 ret = 1;
392                 for (i = 0; i < PARSE_MAX_VP; i++) {
393                         vp = &posval[i];
394                         if (!vp->ival || vp->ival[0] == '\0')
395                                 continue;
396                         all_skipped = 0;
397                         if (!strncmp(vp->ival, ptr, str_match_len(vp, ptr))) {
398                                 ret = 0;
399                                 if (o->roff1) {
400                                         if (vp->or)
401                                                 *(unsigned int *) o->roff1 |= vp->oval;
402                                         else
403                                                 *(unsigned int *) o->roff1 = vp->oval;
404                                 } else {
405                                         if (!o->off1)
406                                                 continue;
407                                         val_store(ilp, vp->oval, o->off1, vp->or, data);
408                                 }
409                                 continue;
410                         }
411                 }
412
413                 if (ret && !all_skipped)
414                         show_option_values(o);
415                 else if (fn)
416                         ret = fn(data, ptr);
417                 break;
418         }
419         case FIO_OPT_STR_VAL_TIME:
420                 is_time = 1;
421         case FIO_OPT_INT:
422         case FIO_OPT_STR_VAL: {
423                 fio_opt_str_val_fn *fn = o->cb;
424                 char tmp[128], *p;
425
426                 strncpy(tmp, ptr, sizeof(tmp) - 1);
427                 p = strchr(tmp, ',');
428                 if (p)
429                         *p = '\0';
430
431                 if (is_time)
432                         ret = check_str_time(tmp, &ull);
433                 else
434                         ret = check_str_bytes(tmp, &ull, data);
435
436                 if (ret)
437                         break;
438
439                 if (o->maxval && ull > o->maxval) {
440                         log_err("max value out of range: %llu"
441                                         " (%u max)\n", ull, o->maxval);
442                         return 1;
443                 }
444                 if (o->minval && ull < o->minval) {
445                         log_err("min value out of range: %llu"
446                                         " (%u min)\n", ull, o->minval);
447                         return 1;
448                 }
449
450                 if (fn)
451                         ret = fn(data, &ull);
452                 else {
453                         if (o->type == FIO_OPT_INT) {
454                                 if (first) {
455                                         if (o->roff1)
456                                                 *(unsigned int *) o->roff1 = ull;
457                                         else
458                                                 val_store(ilp, ull, o->off1, 0, data);
459                                 }
460                                 if (curr == 1) {
461                                         if (o->roff2)
462                                                 *(unsigned int *) o->roff2 = ull;
463                                         else if (o->off2)
464                                                 val_store(ilp, ull, o->off2, 0, data);
465                                 }
466                                 if (curr == 2) {
467                                         if (o->roff3)
468                                                 *(unsigned int *) o->roff3 = ull;
469                                         else if (o->off3)
470                                                 val_store(ilp, ull, o->off3, 0, data);
471                                 }
472                                 if (!more) {
473                                         if (curr < 1) {
474                                                 if (o->roff2)
475                                                         *(unsigned int *) o->roff2 = ull;
476                                                 else if (o->off2)
477                                                         val_store(ilp, ull, o->off2, 0, data);
478                                         }
479                                         if (curr < 2) {
480                                                 if (o->roff3)
481                                                         *(unsigned int *) o->roff3 = ull;
482                                                 else if (o->off3)
483                                                         val_store(ilp, ull, o->off3, 0, data);
484                                         }
485                                 }
486                         } else {
487                                 if (first) {
488                                         if (o->roff1)
489                                                 *(unsigned long long *) o->roff1 = ull;
490                                         else
491                                                 val_store(ullp, ull, o->off1, 0, data);
492                                 }
493                                 if (!more) {
494                                         if (o->roff2)
495                                                 *(unsigned long long *) o->roff2 =  ull;
496                                         else if (o->off2)
497                                                 val_store(ullp, ull, o->off2, 0, data);
498                                 }
499                         }
500                 }
501                 break;
502         }
503         case FIO_OPT_FLOAT_LIST: {
504                 char *cp2;
505
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                         int 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
769 static 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
829 static 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
851 static 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
877 void 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
884 int 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
902 int 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         log_err("fio: failed parsing %s\n", input);
928         return 1;
929 }
930
931 /*
932  * Option match, levenshtein distance. Handy for not quite remembering what
933  * the option name is.
934  */
935 static int string_distance(const char *s1, const char *s2)
936 {
937         unsigned int s1_len = strlen(s1);
938         unsigned int s2_len = strlen(s2);
939         unsigned int *p, *q, *r;
940         unsigned int i, j;
941
942         p = malloc(sizeof(unsigned int) * (s2_len + 1));
943         q = malloc(sizeof(unsigned int) * (s2_len + 1));
944
945         p[0] = 0;
946         for (i = 1; i <= s2_len; i++)
947                 p[i] = p[i - 1] + 1;
948
949         for (i = 1; i <= s1_len; i++) {
950                 q[0] = p[0] + 1;
951                 for (j = 1; j <= s2_len; j++) {
952                         unsigned int sub = p[j - 1];
953
954                         if (s1[i - 1] != s2[j - 1])
955                                 sub++;
956
957                         q[j] = min(p[j] + 1, min(q[j - 1] + 1, sub));
958                 }
959                 r = p;
960                 p = q;
961                 q = r;
962         }
963
964         i = p[s2_len];
965         free(p);
966         free(q);
967         return i;
968 }
969
970 static struct fio_option *find_child(struct fio_option *options,
971                                      struct fio_option *o)
972 {
973         struct fio_option *__o;
974
975         for (__o = options + 1; __o->name; __o++)
976                 if (__o->parent && !strcmp(__o->parent, o->name))
977                         return __o;
978
979         return NULL;
980 }
981
982 static void __print_option(struct fio_option *o, struct fio_option *org,
983                            int level)
984 {
985         char name[256], *p;
986         int depth;
987
988         if (!o)
989                 return;
990         if (!org)
991                 org = o;
992
993         p = name;
994         depth = level;
995         while (depth--)
996                 p += sprintf(p, "%s", "  ");
997
998         sprintf(p, "%s", o->name);
999
1000         log_info("%-24s: %s\n", name, o->help);
1001 }
1002
1003 static void print_option(struct fio_option *o)
1004 {
1005         struct fio_option *parent;
1006         struct fio_option *__o;
1007         unsigned int printed;
1008         unsigned int level;
1009
1010         __print_option(o, NULL, 0);
1011         parent = o;
1012         level = 0;
1013         do {
1014                 level++;
1015                 printed = 0;
1016
1017                 while ((__o = find_child(o, parent)) != NULL) {
1018                         __print_option(__o, o, level);
1019                         o = __o;
1020                         printed++;
1021                 }
1022
1023                 parent = o;
1024         } while (printed);
1025 }
1026
1027 int show_cmd_help(struct fio_option *options, const char *name)
1028 {
1029         struct fio_option *o, *closest;
1030         unsigned int best_dist = -1U;
1031         int found = 0;
1032         int show_all = 0;
1033
1034         if (!name || !strcmp(name, "all"))
1035                 show_all = 1;
1036
1037         closest = NULL;
1038         best_dist = -1;
1039         for (o = &options[0]; o->name; o++) {
1040                 int match = 0;
1041
1042                 if (o->type == FIO_OPT_DEPRECATED)
1043                         continue;
1044                 if (!exec_profile && o->prof_name)
1045                         continue;
1046
1047                 if (name) {
1048                         if (!strcmp(name, o->name) ||
1049                             (o->alias && !strcmp(name, o->alias)))
1050                                 match = 1;
1051                         else {
1052                                 unsigned int dist;
1053
1054                                 dist = string_distance(name, o->name);
1055                                 if (dist < best_dist) {
1056                                         best_dist = dist;
1057                                         closest = o;
1058                                 }
1059                         }
1060                 }
1061
1062                 if (show_all || match) {
1063                         found = 1;
1064                         if (match)
1065                                 log_info("%20s: %s\n", o->name, o->help);
1066                         if (show_all) {
1067                                 if (!o->parent)
1068                                         print_option(o);
1069                                 continue;
1070                         }
1071                 }
1072
1073                 if (!match)
1074                         continue;
1075
1076                 show_option_help(o, 0);
1077         }
1078
1079         if (found)
1080                 return 0;
1081
1082         log_err("No such command: %s", name);
1083
1084         /*
1085          * Only print an appropriately close option, one where the edit
1086          * distance isn't too big. Otherwise we get crazy matches.
1087          */
1088         if (closest && best_dist < 3) {
1089                 log_info(" - showing closest match\n");
1090                 log_info("%20s: %s\n", closest->name, closest->help);
1091                 show_option_help(closest, 0);
1092         } else
1093                 log_info("\n");
1094
1095         return 1;
1096 }
1097
1098 /*
1099  * Handle parsing of default parameters.
1100  */
1101 void fill_default_options(void *data, struct fio_option *options)
1102 {
1103         struct fio_option *o;
1104
1105         dprint(FD_PARSE, "filling default options\n");
1106
1107         for (o = &options[0]; o->name; o++)
1108                 if (o->def)
1109                         handle_option(o, o->def, data);
1110 }
1111
1112 void option_init(struct fio_option *o)
1113 {
1114         if (o->type == FIO_OPT_DEPRECATED)
1115                 return;
1116         if (o->type == FIO_OPT_BOOL) {
1117                 o->minval = 0;
1118                 o->maxval = 1;
1119         }
1120         if (o->type == FIO_OPT_INT) {
1121                 if (!o->maxval)
1122                         o->maxval = UINT_MAX;
1123         }
1124         if (o->type == FIO_OPT_FLOAT_LIST) {
1125                 o->minfp = DBL_MIN;
1126                 o->maxfp = DBL_MAX;
1127         }
1128         if (o->type == FIO_OPT_STR_SET && o->def) {
1129                 log_err("Option %s: string set option with"
1130                                 " default will always be true\n", o->name);
1131         }
1132         if (!o->cb && (!o->off1 && !o->roff1))
1133                 log_err("Option %s: neither cb nor offset given\n", o->name);
1134         if (o->type == FIO_OPT_STR || o->type == FIO_OPT_STR_STORE ||
1135             o->type == FIO_OPT_STR_MULTI)
1136                 return;
1137         if (o->cb && ((o->off1 || o->off2 || o->off3 || o->off4) ||
1138                       (o->roff1 || o->roff2 || o->roff3 || o->roff4))) {
1139                 log_err("Option %s: both cb and offset given\n", o->name);
1140         }
1141         if (!o->category) {
1142                 log_info("Options %s: no category defined. Setting to misc\n", o->name);
1143                 o->category = FIO_OPT_C_GENERAL;
1144         }
1145 }
1146
1147 /*
1148  * Sanitize the options structure. For now it just sets min/max for bool
1149  * values and whether both callback and offsets are given.
1150  */
1151 void options_init(struct fio_option *options)
1152 {
1153         struct fio_option *o;
1154
1155         dprint(FD_PARSE, "init options\n");
1156
1157         for (o = &options[0]; o->name; o++) {
1158                 option_init(o);
1159                 if (o->inverse)
1160                         o->inv_opt = find_option(options, o->inverse);
1161         }
1162 }
1163
1164 void options_free(struct fio_option *options, void *data)
1165 {
1166         struct fio_option *o;
1167         char **ptr;
1168
1169         dprint(FD_PARSE, "free options\n");
1170
1171         for (o = &options[0]; o->name; o++) {
1172                 if (o->type != FIO_OPT_STR_STORE || !o->off1)
1173                         continue;
1174
1175                 ptr = td_var(data, o->off1);
1176                 if (*ptr) {
1177                         free(*ptr);
1178                         *ptr = NULL;
1179                 }
1180         }
1181 }