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