3c203121711dcb9595bea3b1b6e517dad3d76abb
[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
12 #include "parse.h"
13 #include "debug.h"
14
15 static int vp_cmp(const void *p1, const void *p2)
16 {
17         const struct value_pair *vp1 = p1;
18         const struct value_pair *vp2 = p2;
19
20         return strlen(vp2->ival) - strlen(vp1->ival);
21 }
22
23 static void posval_sort(struct fio_option *o, struct value_pair *vpmap)
24 {
25         const struct value_pair *vp;
26         int entries;
27
28         memset(vpmap, 0, PARSE_MAX_VP * sizeof(struct value_pair));
29
30         for (entries = 0; entries < PARSE_MAX_VP; entries++) {
31                 vp = &o->posval[entries];
32                 if (!vp->ival || vp->ival[0] == '\0')
33                         break;
34
35                 memcpy(&vpmap[entries], vp, sizeof(*vp));
36         }
37
38         qsort(vpmap, entries, sizeof(struct value_pair), vp_cmp);
39 }
40
41 static void show_option_range(struct fio_option *o)
42 {
43         if (!o->minval && !o->maxval)
44                 return;
45
46         printf("%20s: min=%d, max=%d\n", "range", o->minval, o->maxval);
47 }
48
49 static void show_option_values(struct fio_option *o)
50 {
51         int i = 0;
52
53         do {
54                 const struct value_pair *vp = &o->posval[i];
55
56                 if (!vp->ival)
57                         break;
58
59                 printf("%20s: %-10s", i == 0 ? "valid values" : "", vp->ival);
60                 if (vp->help)
61                         printf(" %s", vp->help);
62                 printf("\n");
63                 i++;
64         } while (i < PARSE_MAX_VP);
65
66         if (i)
67                 printf("\n");
68 }
69
70 static unsigned long get_mult_time(char c)
71 {
72         switch (c) {
73                 case 'm':
74                 case 'M':
75                         return 60;
76                 case 'h':
77                 case 'H':
78                         return 60 * 60;
79                 case 'd':
80                 case 'D':
81                         return 24 * 60 * 60;
82                 default:
83                         return 1;
84         }
85 }
86
87 static unsigned long get_mult_bytes(char c)
88 {
89         switch (c) {
90                 case 'k':
91                 case 'K':
92                         return 1024;
93                 case 'm':
94                 case 'M':
95                         return 1024 * 1024;
96                 case 'g':
97                 case 'G':
98                         return 1024 * 1024 * 1024;
99                 case 'e':
100                 case 'E':
101                         return 1024 * 1024 * 1024 * 1024UL;
102                 default:
103                         return 1;
104         }
105 }
106
107 /*
108  * convert string into decimal value, noting any size suffix
109  */
110 int str_to_decimal(const char *str, long long *val, int kilo)
111 {
112         int len;
113
114         len = strlen(str);
115         if (!len)
116                 return 1;
117
118         *val = strtoll(str, NULL, 10);
119         if (*val == LONG_MAX && errno == ERANGE)
120                 return 1;
121
122         if (kilo)
123                 *val *= get_mult_bytes(str[len - 1]);
124         else
125                 *val *= get_mult_time(str[len - 1]);
126
127         return 0;
128 }
129
130 static int check_str_bytes(const char *p, long long *val)
131 {
132         return str_to_decimal(p, val, 1);
133 }
134
135 static int check_str_time(const char *p, long long *val)
136 {
137         return str_to_decimal(p, val, 0);
138 }
139
140 void strip_blank_front(char **p)
141 {
142         char *s = *p;
143
144         while (isspace(*s))
145                 s++;
146
147         *p = s;
148 }
149
150 void strip_blank_end(char *p)
151 {
152         char *s;
153
154         s = strchr(p, ';');
155         if (s)
156                 *s = '\0';
157         s = strchr(p, '#');
158         if (s)
159                 *s = '\0';
160         if (s)
161                 p = s;
162
163         s = p + strlen(p);
164         while ((isspace(*s) || iscntrl(*s)) && (s > p))
165                 s--;
166
167         *(s + 1) = '\0';
168 }
169
170 static int check_range_bytes(const char *str, long *val)
171 {
172         char suffix;
173
174         if (!strlen(str))
175                 return 1;
176
177         if (sscanf(str, "%lu%c", val, &suffix) == 2) {
178                 *val *= get_mult_bytes(suffix);
179                 return 0;
180         }
181
182         if (sscanf(str, "%lu", val) == 1)
183                 return 0;
184
185         return 1;
186 }
187
188 static int check_int(const char *p, int *val)
189 {
190         if (!strlen(p))
191                 return 1;
192         if (strstr(p, "0x") || strstr(p, "0X")) {
193                 if (sscanf(p, "%x", val) == 1)
194                         return 0;
195         } else {
196                 if (sscanf(p, "%u", val) == 1)
197                         return 0;
198         }
199
200         return 1;
201 }
202
203 static struct fio_option *find_option(struct fio_option *options,
204                                       const char *opt)
205 {
206         struct fio_option *o;
207
208         for (o = &options[0]; o->name; o++) {
209                 if (!strcmp(o->name, opt))
210                         return o;
211                 else if (o->alias && !strcmp(o->alias, opt))
212                         return o;
213         }
214
215         return NULL;
216 }
217
218 #define val_store(ptr, val, off, data)                  \
219         do {                                            \
220                 ptr = td_var((data), (off));            \
221                 *ptr = (val);                           \
222         } while (0)
223
224 static int __handle_option(struct fio_option *o, const char *ptr, void *data,
225                            int first, int more)
226 {
227         int il, *ilp;
228         long long ull, *ullp;
229         long ul1, ul2;
230         char **cp;
231         int ret = 0, is_time = 0;
232
233         dprint(FD_PARSE, "__handle_option=%s, type=%d, ptr=%s\n", o->name,
234                                                         o->type, ptr);
235
236         if (!ptr && o->type != FIO_OPT_STR_SET) {
237                 fprintf(stderr, "Option %s requires an argument\n", o->name);
238                 return 1;
239         }
240
241         switch (o->type) {
242         case FIO_OPT_STR: {
243                 fio_opt_str_fn *fn = o->cb;
244                 const struct value_pair *vp;
245                 struct value_pair posval[PARSE_MAX_VP];
246                 int i;
247
248                 posval_sort(o, posval);
249
250                 for (i = 0; i < PARSE_MAX_VP; i++) {
251                         vp = &posval[i];
252                         if (!vp->ival || vp->ival[0] == '\0')
253                                 break;
254                         ret = 1;
255                         if (!strncmp(vp->ival, ptr, strlen(vp->ival))) {
256                                 ret = 0;
257                                 if (!o->off1)
258                                         break;
259                                 val_store(ilp, vp->oval, o->off1, data);
260                                 break;
261                         }
262                 }
263
264                 if (ret)
265                         show_option_values(o);
266                 else if (fn)
267                         ret = fn(data, ptr);
268                 break;
269         }
270         case FIO_OPT_STR_VAL_TIME:
271                 is_time = 1;
272         case FIO_OPT_STR_VAL:
273         case FIO_OPT_STR_VAL_INT: {
274                 fio_opt_str_val_fn *fn = o->cb;
275
276                 if (is_time)
277                         ret = check_str_time(ptr, &ull);
278                 else
279                         ret = check_str_bytes(ptr, &ull);
280
281                 if (ret)
282                         break;
283
284                 if (o->maxval && ull > o->maxval) {
285                         fprintf(stderr, "max value out of range: %lld (%d max)\n", ull, o->maxval);
286                         return 1;
287                 }
288                 if (o->minval && ull < o->minval) {
289                         fprintf(stderr, "min value out of range: %lld (%d min)\n", ull, o->minval);
290                         return 1;
291                 }
292
293                 if (fn)
294                         ret = fn(data, &ull);
295                 else {
296                         if (o->type == FIO_OPT_STR_VAL_INT) {
297                                 if (first)
298                                         val_store(ilp, ull, o->off1, data);
299                                 if (!more && o->off2)
300                                         val_store(ilp, ull, o->off2, data);
301                         } else {
302                                 if (first)
303                                         val_store(ullp, ull, o->off1, data);
304                                 if (!more && o->off2)
305                                         val_store(ullp, ull, o->off2, data);
306                         }
307                 }
308                 break;
309         }
310         case FIO_OPT_STR_STORE: {
311                 fio_opt_str_fn *fn = o->cb;
312
313                 cp = td_var(data, o->off1);
314                 *cp = strdup(ptr);
315                 if (fn) {
316                         ret = fn(data, ptr);
317                         if (ret) {
318                                 free(*cp);
319                                 *cp = NULL;
320                         }
321                 }
322                 break;
323         }
324         case FIO_OPT_RANGE: {
325                 char tmp[128];
326                 char *p1, *p2;
327
328                 strncpy(tmp, ptr, sizeof(tmp) - 1);
329
330                 p1 = strchr(tmp, '-');
331                 if (!p1) {
332                         p1 = strchr(tmp, ':');
333                         if (!p1) {
334                                 ret = 1;
335                                 break;
336                         }
337                 }
338
339                 p2 = p1 + 1;
340                 *p1 = '\0';
341                 p1 = tmp;
342
343                 ret = 1;
344                 if (!check_range_bytes(p1, &ul1) && !check_range_bytes(p2, &ul2)) {
345                         ret = 0;
346                         if (ul1 > ul2) {
347                                 unsigned long foo = ul1;
348
349                                 ul1 = ul2;
350                                 ul2 = foo;
351                         }
352
353                         if (first) {
354                                 val_store(ilp, ul1, o->off1, data);
355                                 val_store(ilp, ul2, o->off2, data);
356                         }
357                         if (o->off3 && o->off4) {
358                                 val_store(ilp, ul1, o->off3, data);
359                                 val_store(ilp, ul2, o->off4, data);
360                         }
361                 }
362
363                 break;
364         }
365         case FIO_OPT_INT:
366         case FIO_OPT_BOOL: {
367                 fio_opt_int_fn *fn = o->cb;
368
369                 ret = check_int(ptr, &il);
370                 if (ret)
371                         break;
372
373                 if (o->maxval && il > (int) o->maxval) {
374                         fprintf(stderr, "max value out of range: %d (%d max)\n", il, o->maxval);
375                         return 1;
376                 }
377                 if (o->minval && il < o->minval) {
378                         fprintf(stderr, "min value out of range: %d (%d min)\n", il, o->minval);
379                         return 1;
380                 }
381
382                 if (o->neg)
383                         il = !il;
384
385                 if (fn)
386                         ret = fn(data, &il);
387                 else {
388                         if (first)
389                                 val_store(ilp, il, o->off1, data);
390                         if (!more && o->off2)
391                                 val_store(ilp, il, o->off2, data);
392                 }
393                 break;
394         }
395         case FIO_OPT_STR_SET: {
396                 fio_opt_str_set_fn *fn = o->cb;
397
398                 if (fn)
399                         ret = fn(data);
400                 else {
401                         if (first)
402                                 val_store(ilp, 1, o->off1, data);
403                         if (!more && o->off2)
404                                 val_store(ilp, 1, o->off2, data);
405                 }
406                 break;
407         }
408         default:
409                 fprintf(stderr, "Bad option type %u\n", o->type);
410                 ret = 1;
411         }
412
413         return ret;
414 }
415
416 static int handle_option(struct fio_option *o, const char *ptr, void *data)
417 {
418         const char *ptr2 = NULL;
419         int r1, r2;
420
421         dprint(FD_PARSE, "handle_option=%s, ptr=%s\n", o->name, ptr);
422
423         /*
424          * See if we have a second set of parameters, hidden after a comma.
425          * Do this before parsing the first round, to check if we should
426          * copy set 1 options to set 2.
427          */
428         if (ptr &&
429             (o->type != FIO_OPT_STR_STORE) &&
430             (o->type != FIO_OPT_STR)) {
431                 ptr2 = strchr(ptr, ',');
432                 if (!ptr2)
433                         ptr2 = strchr(ptr, ':');
434                 if (!ptr2)
435                         ptr2 = strchr(ptr, '-');
436         }
437
438         /*
439          * Don't return early if parsing the first option fails - if
440          * we are doing multiple arguments, we can allow the first one
441          * being empty.
442          */
443         r1 = __handle_option(o, ptr, data, 1, !!ptr2);
444
445         if (!ptr2)
446                 return r1;
447
448         ptr2++;
449         r2 = __handle_option(o, ptr2, data, 0, 0);
450
451         return r1 && r2;
452 }
453
454 int parse_cmd_option(const char *opt, const char *val,
455                      struct fio_option *options, void *data)
456 {
457         struct fio_option *o;
458
459         o = find_option(options, opt);
460         if (!o) {
461                 fprintf(stderr, "Bad option %s\n", opt);
462                 return 1;
463         }
464
465         if (!handle_option(o, val, data))
466                 return 0;
467
468         fprintf(stderr, "fio: failed parsing %s=%s\n", opt, val);
469         return 1;
470 }
471
472 int parse_option(const char *opt, struct fio_option *options, void *data)
473 {
474         struct fio_option *o;
475         char *pre, *post;
476         char *tmp;
477
478         tmp = strdup(opt);
479
480         pre = strchr(tmp, '=');
481         if (pre) {
482                 post = pre;
483                 *pre = '\0';
484                 pre = tmp;
485                 post++;
486                 o = find_option(options, pre);
487         } else {
488                 o = find_option(options, tmp);
489                 post = NULL;
490         }
491
492         if (!o) {
493                 fprintf(stderr, "Bad option %s\n", tmp);
494                 free(tmp);
495                 return 1;
496         }
497
498         if (!handle_option(o, post, data)) {
499                 free(tmp);
500                 return 0;
501         }
502
503         fprintf(stderr, "fio: failed parsing %s\n", opt);
504         free(tmp);
505         return 1;
506 }
507
508 /*
509  * Option match, levenshtein distance. Handy for not quite remembering what
510  * the option name is.
511  */
512 static int string_distance(const char *s1, const char *s2)
513 {
514         unsigned int s1_len = strlen(s1);
515         unsigned int s2_len = strlen(s2);
516         unsigned int *p, *q, *r;
517         unsigned int i, j;
518
519         p = malloc(sizeof(unsigned int) * (s2_len + 1));
520         q = malloc(sizeof(unsigned int) * (s2_len + 1));
521
522         p[0] = 0;
523         for (i = 1; i <= s2_len; i++)
524                 p[i] = p[i - 1] + 1;
525
526         for (i = 1; i <= s1_len; i++) {
527                 q[0] = p[0] + 1;
528                 for (j = 1; j <= s2_len; j++) {
529                         unsigned int sub = p[j - 1];
530
531                         if (s1[i - 1] != s2[j - 1])
532                                 sub++;
533
534                         q[j] = min(p[j] + 1, min(q[j - 1] + 1, sub));
535                 }
536                 r = p;
537                 p = q;
538                 q = r;
539         }
540
541         i = p[s2_len];
542         free(p);
543         free(q);
544         return i;
545 }
546
547 static void show_option_help(struct fio_option *o)
548 {
549         const char *typehelp[] = {
550                 "string (opt=bla)",
551                 "string with possible k/m/g postfix (opt=4k)",
552                 "string with range and postfix (opt=1k-4k)",
553                 "string with time postfix (opt=10s)",
554                 "string (opt=bla)",
555                 "string with dual range (opt=1k-4k,4k-8k)",
556                 "integer value (opt=100)",
557                 "boolean value (opt=1)",
558                 "no argument (opt)",
559         };
560
561         if (o->alias)
562                 printf("%20s: %s\n", "alias", o->alias);
563
564         printf("%20s: %s\n", "type", typehelp[o->type]);
565         printf("%20s: %s\n", "default", o->def ? o->def : "no default");
566         show_option_range(o);
567         show_option_values(o);
568 }
569
570 static struct fio_option *find_child(struct fio_option *options,
571                                      struct fio_option *o)
572 {
573         struct fio_option *__o;
574
575         for (__o = options + 1; __o->name; __o++)
576                 if (__o->parent && !strcmp(__o->parent, o->name))
577                         return __o;
578
579         return NULL;
580 }
581
582 static void print_option(struct fio_option *o, struct fio_option *org,
583                          int level)
584 {
585         char name[256], *p;
586
587         if (!o)
588                 return;
589         if (!org)
590                 org = o;
591         
592         p = name;
593         if (level)
594                 p += sprintf(p, "%s", "    ");
595
596         sprintf(p, "%s", o->name);
597
598         printf("%-24s: %s\n", name, o->help);
599         print_option(find_child(o, org), org, level + 1);
600 }
601
602 int show_cmd_help(struct fio_option *options, const char *name)
603 {
604         struct fio_option *o, *closest;
605         unsigned int best_dist;
606         int found = 0;
607         int show_all = 0;
608
609         if (!name || !strcmp(name, "all"))
610                 show_all = 1;
611
612         closest = NULL;
613         best_dist = -1;
614         for (o = &options[0]; o->name; o++) {
615                 int match = 0;
616
617                 if (name) {
618                         if (!strcmp(name, o->name) ||
619                             (o->alias && !strcmp(name, o->alias)))
620                                 match = 1;
621                         else {
622                                 unsigned int dist;
623
624                                 dist = string_distance(name, o->name);
625                                 if (dist < best_dist) {
626                                         best_dist = dist;
627                                         closest = o;
628                                 }
629                         }
630                 }
631
632                 if (show_all || match) {
633                         found = 1;
634                         if (match)
635                                 printf("%24s: %s\n", o->name, o->help);
636                         if (show_all) {
637                                 if (!o->parent)
638                                         print_option(o, NULL, 0);
639                                 continue;
640                         }
641                 }
642
643                 if (!match)
644                         continue;
645
646                 show_option_help(o);
647         }
648
649         if (found)
650                 return 0;
651
652         printf("No such command: %s", name);
653         if (closest) {
654                 printf(" - showing closest match\n");
655                 printf("%20s: %s\n", closest->name, closest->help);
656                 show_option_help(closest);
657         } else
658                 printf("\n");
659
660         return 1;
661 }
662
663 /*
664  * Handle parsing of default parameters.
665  */
666 void fill_default_options(void *data, struct fio_option *options)
667 {
668         struct fio_option *o;
669
670         dprint(FD_PARSE, "filling default options\n");
671
672         for (o = &options[0]; o->name; o++)
673                 if (o->def)
674                         handle_option(o, o->def, data);
675 }
676
677 /*
678  * Sanitize the options structure. For now it just sets min/max for bool
679  * values and whether both callback and offsets are given.
680  */
681 void options_init(struct fio_option *options)
682 {
683         struct fio_option *o;
684
685         dprint(FD_PARSE, "init options\n");
686
687         for (o = &options[0]; o->name; o++) {
688                 if (o->type == FIO_OPT_BOOL) {
689                         o->minval = 0;
690                         o->maxval = 1;
691                 }
692                 if (o->type == FIO_OPT_STR_SET && o->def)
693                         fprintf(stderr, "Option %s: string set option with default will always be true\n", o->name);
694                 if (!o->cb && !o->off1)
695                         fprintf(stderr, "Option %s: neither cb nor offset given\n", o->name);
696                 if (o->type == FIO_OPT_STR || o->type == FIO_OPT_STR_STORE)
697                         continue;
698                 if (o->cb && (o->off1 || o->off2 || o->off3 || o->off4))
699                         fprintf(stderr, "Option %s: both cb and offset given\n", o->name);
700         }
701 }