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