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