parse.c revision 64c9d60b95a121b4d7a4ca3b0fdf2390236d17b2
1/* 2 * This file contains the ini and command liner parser main. 3 */ 4#include <stdio.h> 5#include <stdlib.h> 6#include <unistd.h> 7#include <ctype.h> 8#include <string.h> 9#include <errno.h> 10#include <limits.h> 11#include <stdlib.h> 12#include <math.h> 13#include <float.h> 14 15#include "parse.h" 16#include "debug.h" 17#include "options.h" 18#include "minmax.h" 19#include "lib/ieee754.h" 20 21#ifdef CONFIG_ARITHMETIC 22#include "y.tab.h" 23#endif 24 25static struct fio_option *__fio_options; 26 27static int vp_cmp(const void *p1, const void *p2) 28{ 29 const struct value_pair *vp1 = p1; 30 const struct value_pair *vp2 = p2; 31 32 return strlen(vp2->ival) - strlen(vp1->ival); 33} 34 35static void posval_sort(struct fio_option *o, struct value_pair *vpmap) 36{ 37 const struct value_pair *vp; 38 int entries; 39 40 memset(vpmap, 0, PARSE_MAX_VP * sizeof(struct value_pair)); 41 42 for (entries = 0; entries < PARSE_MAX_VP; entries++) { 43 vp = &o->posval[entries]; 44 if (!vp->ival || vp->ival[0] == '\0') 45 break; 46 47 memcpy(&vpmap[entries], vp, sizeof(*vp)); 48 } 49 50 qsort(vpmap, entries, sizeof(struct value_pair), vp_cmp); 51} 52 53static void show_option_range(struct fio_option *o, 54 int (*logger)(const char *format, ...)) 55{ 56 if (o->type == FIO_OPT_FLOAT_LIST) { 57 if (o->minfp == DBL_MIN && o->maxfp == DBL_MAX) 58 return; 59 60 logger("%20s: min=%f", "range", o->minfp); 61 if (o->maxfp != DBL_MAX) 62 logger(", max=%f", o->maxfp); 63 logger("\n"); 64 } else if (!o->posval[0].ival) { 65 if (!o->minval && !o->maxval) 66 return; 67 68 logger("%20s: min=%d", "range", o->minval); 69 if (o->maxval) 70 logger(", max=%d", o->maxval); 71 logger("\n"); 72 } 73} 74 75static void show_option_values(struct fio_option *o) 76{ 77 int i; 78 79 for (i = 0; i < PARSE_MAX_VP; i++) { 80 const struct value_pair *vp = &o->posval[i]; 81 82 if (!vp->ival) 83 continue; 84 85 log_info("%20s: %-10s", i == 0 ? "valid values" : "", vp->ival); 86 if (vp->help) 87 log_info(" %s", vp->help); 88 log_info("\n"); 89 } 90 91 if (i) 92 log_info("\n"); 93} 94 95static void show_option_help(struct fio_option *o, int is_err) 96{ 97 const char *typehelp[] = { 98 "invalid", 99 "string (opt=bla)", 100 "string (opt=bla)", 101 "string with possible k/m/g postfix (opt=4k)", 102 "string with time postfix (opt=10s)", 103 "string (opt=bla)", 104 "string with dual range (opt=1k-4k,4k-8k)", 105 "integer value (opt=100)", 106 "boolean value (opt=1)", 107 "list of floating point values separated by ':' (opt=5.9:7.8)", 108 "no argument (opt)", 109 "deprecated", 110 }; 111 int (*logger)(const char *format, ...); 112 113 if (is_err) 114 logger = log_err; 115 else 116 logger = log_info; 117 118 if (o->alias) 119 logger("%20s: %s\n", "alias", o->alias); 120 121 logger("%20s: %s\n", "type", typehelp[o->type]); 122 logger("%20s: %s\n", "default", o->def ? o->def : "no default"); 123 if (o->prof_name) 124 logger("%20s: only for profile '%s'\n", "valid", o->prof_name); 125 show_option_range(o, logger); 126 show_option_values(o); 127} 128 129static unsigned long long get_mult_time(const char *str, int len, 130 int is_seconds) 131{ 132 const char *p = str; 133 char *c; 134 unsigned long long mult = 1; 135 136 /* 137 * Go forward until we hit a non-digit, or +/- sign 138 */ 139 while ((p - str) <= len) { 140 if (!isdigit((int) *p) && (*p != '+') && (*p != '-')) 141 break; 142 p++; 143 } 144 145 if (!isalpha((int) *p)) { 146 if (is_seconds) 147 return 1000000UL; 148 else 149 return 1; 150 } 151 152 c = strdup(p); 153 for (int i = 0; i < strlen(c); i++) 154 c[i] = tolower(c[i]); 155 156 if (!strncmp("us", c, 2) || !strncmp("usec", c, 4)) 157 mult = 1; 158 else if (!strncmp("ms", c, 2) || !strncmp("msec", c, 4)) 159 mult = 1000; 160 else if (!strcmp("s", c)) 161 mult = 1000000; 162 else if (!strcmp("m", c)) 163 mult = 60 * 1000000UL; 164 else if (!strcmp("h", c)) 165 mult = 60 * 60 * 1000000UL; 166 else if (!strcmp("d", c)) 167 mult = 24 * 60 * 60 * 1000000UL; 168 169 free(c); 170 return mult; 171} 172 173static int is_separator(char c) 174{ 175 switch (c) { 176 case ':': 177 case '-': 178 case ',': 179 case '/': 180 return 1; 181 default: 182 return 0; 183 } 184} 185 186static unsigned long long __get_mult_bytes(const char *p, void *data, 187 int *percent) 188{ 189 unsigned int kb_base = fio_get_kb_base(data); 190 unsigned long long ret = 1; 191 unsigned int i, pow = 0, mult = kb_base; 192 char *c; 193 194 if (!p) 195 return 1; 196 197 c = strdup(p); 198 199 for (i = 0; i < strlen(c); i++) { 200 c[i] = tolower(c[i]); 201 if (is_separator(c[i])) { 202 c[i] = '\0'; 203 break; 204 } 205 } 206 207 if (!strncmp("pib", c, 3)) { 208 pow = 5; 209 mult = 1000; 210 } else if (!strncmp("tib", c, 3)) { 211 pow = 4; 212 mult = 1000; 213 } else if (!strncmp("gib", c, 3)) { 214 pow = 3; 215 mult = 1000; 216 } else if (!strncmp("mib", c, 3)) { 217 pow = 2; 218 mult = 1000; 219 } else if (!strncmp("kib", c, 3)) { 220 pow = 1; 221 mult = 1000; 222 } else if (!strncmp("p", c, 1) || !strncmp("pb", c, 2)) 223 pow = 5; 224 else if (!strncmp("t", c, 1) || !strncmp("tb", c, 2)) 225 pow = 4; 226 else if (!strncmp("g", c, 1) || !strncmp("gb", c, 2)) 227 pow = 3; 228 else if (!strncmp("m", c, 1) || !strncmp("mb", c, 2)) 229 pow = 2; 230 else if (!strncmp("k", c, 1) || !strncmp("kb", c, 2)) 231 pow = 1; 232 else if (!strncmp("%", c, 1)) { 233 *percent = 1; 234 free(c); 235 return ret; 236 } 237 238 while (pow--) 239 ret *= (unsigned long long) mult; 240 241 free(c); 242 return ret; 243} 244 245static unsigned long long get_mult_bytes(const char *str, int len, void *data, 246 int *percent) 247{ 248 const char *p = str; 249 int digit_seen = 0; 250 251 if (len < 2) 252 return __get_mult_bytes(str, data, percent); 253 254 /* 255 * Go forward until we hit a non-digit, or +/- sign 256 */ 257 while ((p - str) <= len) { 258 if (!isdigit((int) *p) && 259 (((*p != '+') && (*p != '-')) || digit_seen)) 260 break; 261 digit_seen |= isdigit((int) *p); 262 p++; 263 } 264 265 if (!isalpha((int) *p) && (*p != '%')) 266 p = NULL; 267 268 return __get_mult_bytes(p, data, percent); 269} 270 271extern int evaluate_arithmetic_expression(const char *buffer, long long *ival, 272 double *dval, double implied_units); 273 274#ifdef CONFIG_ARITHMETIC 275/* 276 * These two verification functions are just to gain confidence that 277 * the arithmetic processing code is always getting the same answer as the 278 * original number parsing code. Once sufficiently sure that the arithmetic 279 * code is always getting the right answers, these can be removed. 280 */ 281static void verify_exp_parser_float(const char *str, double implied_units) 282{ 283 long long ival; 284 double dval, tmpval; 285 286 if (sscanf(str, "%lf", &tmpval) != 1) 287 return; 288 289 if (evaluate_arithmetic_expression(str, &ival, &dval, implied_units) != 0) { 290 log_info("Arithmetic failed on '%s'\n", str); 291 return; 292 } 293 if (dval != tmpval) { 294 log_info("Arithmetic failed on: '%s' got %lf, expected %lf\n", 295 str, dval, tmpval); 296 } 297} 298 299static void verify_exp_parser_decimal(const char *str, long long val, int kilo, int is_seconds) 300{ 301 int rc; 302 long long ival; 303 double dval; 304 double implied_units = 1.0; 305 306 if (is_seconds) 307 implied_units = 1000000.0; 308 309 rc = evaluate_arithmetic_expression(str, &ival, &dval, implied_units); 310 if (!rc) { 311 if (ival != val) 312 log_info("Arithmetic failed on '%s', expected %lld, got %lld\n", 313 str, val, ival); 314 } else { 315 log_info("Arithmetic failed on '%s'\n", str); 316 } 317} 318#endif 319 320/* 321 * Convert string into a floating number. Return 1 for success and 0 otherwise. 322 */ 323int str_to_float(const char *str, double *val) 324{ 325#ifdef CONFIG_ARITHMETIC 326 int rc; 327 long long ival; 328 double dval; 329 330 if (str[0] == '(') { 331 rc = evaluate_arithmetic_expression(str, &ival, &dval, 1.0); 332 if (!rc) { 333 *val = dval; 334 return 1; 335 } 336 } else { 337 verify_exp_parser_float(str, 1.0); 338 } 339#endif 340 return 1 == sscanf(str, "%lf", val); 341} 342 343/* 344 * convert string into decimal value, noting any size suffix 345 */ 346int str_to_decimal(const char *str, long long *val, int kilo, void *data, 347 int is_seconds) 348{ 349 int len, base; 350 int rc = 1; 351#ifdef CONFIG_ARITHMETIC 352 long long ival; 353 double dval; 354 double implied_units = 1.0; 355#endif 356 357 len = strlen(str); 358 if (!len) 359 return 1; 360 361#ifdef CONFIG_ARITHMETIC 362 if (is_seconds) 363 implied_units = 1000000.0; 364 if (str[0] == '(') 365 rc = evaluate_arithmetic_expression(str, &ival, &dval, implied_units); 366 if (str[0] == '(' && !rc) { 367 if (!kilo && is_seconds) 368 *val = ival / 1000000LL; 369 else 370 *val = ival; 371 } 372#endif 373 374 if (rc == 1) { 375 if (strstr(str, "0x") || strstr(str, "0X")) 376 base = 16; 377 else 378 base = 10; 379 380 *val = strtoll(str, NULL, base); 381 if (*val == LONG_MAX && errno == ERANGE) 382 return 1; 383 } 384 385 if (kilo) { 386 unsigned long long mult; 387 int perc = 0; 388 389 mult = get_mult_bytes(str, len, data, &perc); 390 if (perc) 391 *val = -1ULL - *val; 392 else 393 *val *= mult; 394 } else 395 *val *= get_mult_time(str, len, is_seconds); 396#ifdef CONFIG_ARITHMETIC 397 verify_exp_parser_decimal(str, *val, kilo, is_seconds); 398#endif 399 return 0; 400} 401 402int check_str_bytes(const char *p, long long *val, void *data) 403{ 404 return str_to_decimal(p, val, 1, data, 0); 405} 406 407int check_str_time(const char *p, long long *val, int is_seconds) 408{ 409 return str_to_decimal(p, val, 0, NULL, is_seconds); 410} 411 412void strip_blank_front(char **p) 413{ 414 char *s = *p; 415 416 if (!strlen(s)) 417 return; 418 while (isspace((int) *s)) 419 s++; 420 421 *p = s; 422} 423 424void strip_blank_end(char *p) 425{ 426 char *start = p, *s; 427 428 if (!strlen(p)) 429 return; 430 431 s = strchr(p, ';'); 432 if (s) 433 *s = '\0'; 434 s = strchr(p, '#'); 435 if (s) 436 *s = '\0'; 437 if (s) 438 p = s; 439 440 s = p + strlen(p); 441 while ((isspace((int) *s) || iscntrl((int) *s)) && (s > start)) 442 s--; 443 444 *(s + 1) = '\0'; 445} 446 447static int check_range_bytes(const char *str, long *val, void *data) 448{ 449 long long __val; 450 451 if (!str_to_decimal(str, &__val, 1, data, 0)) { 452 *val = __val; 453 return 0; 454 } 455 456 return 1; 457} 458 459static int check_int(const char *p, int *val) 460{ 461 if (!strlen(p)) 462 return 1; 463 if (strstr(p, "0x") || strstr(p, "0X")) { 464 if (sscanf(p, "%x", val) == 1) 465 return 0; 466 } else { 467 if (sscanf(p, "%u", val) == 1) 468 return 0; 469 } 470 471 return 1; 472} 473 474static size_t opt_len(const char *str) 475{ 476 char *postfix; 477 478 postfix = strchr(str, ':'); 479 if (!postfix) 480 return strlen(str); 481 482 return (int)(postfix - str); 483} 484 485static int str_match_len(const struct value_pair *vp, const char *str) 486{ 487 return max(strlen(vp->ival), opt_len(str)); 488} 489 490#define val_store(ptr, val, off, or, data, o) \ 491 do { \ 492 ptr = td_var((data), (o), (off)); \ 493 if ((or)) \ 494 *ptr |= (val); \ 495 else \ 496 *ptr = (val); \ 497 } while (0) 498 499static int __handle_option(struct fio_option *o, const char *ptr, void *data, 500 int first, int more, int curr) 501{ 502 int il=0, *ilp; 503 fio_fp64_t *flp; 504 long long ull, *ullp; 505 long ul1, ul2; 506 double uf; 507 char **cp = NULL; 508 int ret = 0, is_time = 0; 509 const struct value_pair *vp; 510 struct value_pair posval[PARSE_MAX_VP]; 511 int i, all_skipped = 1; 512 513 dprint(FD_PARSE, "__handle_option=%s, type=%d, ptr=%s\n", o->name, 514 o->type, ptr); 515 516 if (!ptr && o->type != FIO_OPT_STR_SET && o->type != FIO_OPT_STR) { 517 log_err("Option %s requires an argument\n", o->name); 518 return 1; 519 } 520 521 switch (o->type) { 522 case FIO_OPT_STR: 523 case FIO_OPT_STR_MULTI: { 524 fio_opt_str_fn *fn = o->cb; 525 526 posval_sort(o, posval); 527 528 ret = 1; 529 for (i = 0; i < PARSE_MAX_VP; i++) { 530 vp = &posval[i]; 531 if (!vp->ival || vp->ival[0] == '\0') 532 continue; 533 all_skipped = 0; 534 if (!strncmp(vp->ival, ptr, str_match_len(vp, ptr))) { 535 ret = 0; 536 if (o->off1) 537 val_store(ilp, vp->oval, o->off1, vp->orval, data, o); 538 continue; 539 } 540 } 541 542 if (ret && !all_skipped) 543 show_option_values(o); 544 else if (fn) 545 ret = fn(data, ptr); 546 break; 547 } 548 case FIO_OPT_STR_VAL_TIME: 549 is_time = 1; 550 case FIO_OPT_INT: 551 case FIO_OPT_STR_VAL: { 552 fio_opt_str_val_fn *fn = o->cb; 553 char tmp[128], *p; 554 555 strncpy(tmp, ptr, sizeof(tmp) - 1); 556 p = strchr(tmp, ','); 557 if (p) 558 *p = '\0'; 559 560 if (is_time) 561 ret = check_str_time(tmp, &ull, o->is_seconds); 562 else 563 ret = check_str_bytes(tmp, &ull, data); 564 565 dprint(FD_PARSE, " ret=%d, out=%llu\n", ret, ull); 566 567 if (ret) 568 break; 569 570 if (o->maxval && ull > o->maxval) { 571 log_err("max value out of range: %llu" 572 " (%u max)\n", ull, o->maxval); 573 return 1; 574 } 575 if (o->minval && ull < o->minval) { 576 log_err("min value out of range: %llu" 577 " (%u min)\n", ull, o->minval); 578 return 1; 579 } 580 if (o->posval[0].ival) { 581 posval_sort(o, posval); 582 583 ret = 1; 584 for (i = 0; i < PARSE_MAX_VP; i++) { 585 vp = &posval[i]; 586 if (!vp->ival || vp->ival[0] == '\0') 587 continue; 588 if (vp->oval == ull) { 589 ret = 0; 590 break; 591 } 592 } 593 if (ret) { 594 log_err("fio: value %llu not allowed:\n", ull); 595 show_option_values(o); 596 return 1; 597 } 598 } 599 600 if (fn) 601 ret = fn(data, &ull); 602 else { 603 if (o->type == FIO_OPT_INT) { 604 if (first) 605 val_store(ilp, ull, o->off1, 0, data, o); 606 if (curr == 1) { 607 if (o->off2) 608 val_store(ilp, ull, o->off2, 0, data, o); 609 } 610 if (curr == 2) { 611 if (o->off3) 612 val_store(ilp, ull, o->off3, 0, data, o); 613 } 614 if (!more) { 615 if (curr < 1) { 616 if (o->off2) 617 val_store(ilp, ull, o->off2, 0, data, o); 618 } 619 if (curr < 2) { 620 if (o->off3) 621 val_store(ilp, ull, o->off3, 0, data, o); 622 } 623 } 624 } else { 625 if (first) 626 val_store(ullp, ull, o->off1, 0, data, o); 627 if (!more) { 628 if (o->off2) 629 val_store(ullp, ull, o->off2, 0, data, o); 630 } 631 } 632 } 633 break; 634 } 635 case FIO_OPT_FLOAT_LIST: { 636 char *cp2; 637 638 if (first) { 639 /* 640 ** Initialize precision to 0 and zero out list 641 ** in case specified list is shorter than default 642 */ 643 if (o->off2) { 644 ul2 = 0; 645 ilp = td_var(data, o, o->off2); 646 *ilp = ul2; 647 } 648 649 flp = td_var(data, o, o->off1); 650 for(i = 0; i < o->maxlen; i++) 651 flp[i].u.f = 0.0; 652 } 653 if (curr >= o->maxlen) { 654 log_err("the list exceeding max length %d\n", 655 o->maxlen); 656 return 1; 657 } 658 if (!str_to_float(ptr, &uf)) { 659 log_err("not a floating point value: %s\n", ptr); 660 return 1; 661 } 662 if (uf > o->maxfp) { 663 log_err("value out of range: %f" 664 " (range max: %f)\n", uf, o->maxfp); 665 return 1; 666 } 667 if (uf < o->minfp) { 668 log_err("value out of range: %f" 669 " (range min: %f)\n", uf, o->minfp); 670 return 1; 671 } 672 673 flp = td_var(data, o, o->off1); 674 flp[curr].u.f = uf; 675 676 dprint(FD_PARSE, " out=%f\n", uf); 677 678 /* 679 ** Calculate precision for output by counting 680 ** number of digits after period. Find first 681 ** period in entire remaining list each time 682 */ 683 cp2 = strchr(ptr, '.'); 684 if (cp2 != NULL) { 685 int len = 0; 686 687 while (*++cp2 != '\0' && *cp2 >= '0' && *cp2 <= '9') 688 len++; 689 690 if (o->off2) { 691 ilp = td_var(data, o, o->off2); 692 if (len > *ilp) 693 *ilp = len; 694 } 695 } 696 697 break; 698 } 699 case FIO_OPT_STR_STORE: { 700 fio_opt_str_fn *fn = o->cb; 701 702 if (!strlen(ptr)) 703 return 1; 704 705 if (o->off1) { 706 cp = td_var(data, o, o->off1); 707 *cp = strdup(ptr); 708 } 709 710 if (fn) 711 ret = fn(data, ptr); 712 else if (o->posval[0].ival) { 713 posval_sort(o, posval); 714 715 ret = 1; 716 for (i = 0; i < PARSE_MAX_VP; i++) { 717 vp = &posval[i]; 718 if (!vp->ival || vp->ival[0] == '\0' || !cp) 719 continue; 720 all_skipped = 0; 721 if (!strncmp(vp->ival, ptr, str_match_len(vp, ptr))) { 722 char *rest; 723 724 ret = 0; 725 if (vp->cb) 726 fn = vp->cb; 727 rest = strstr(*cp ?: ptr, ":"); 728 if (rest) { 729 if (*cp) 730 *rest = '\0'; 731 ptr = rest + 1; 732 } else 733 ptr = NULL; 734 break; 735 } 736 } 737 } 738 739 if (!all_skipped) { 740 if (ret && !*cp) 741 show_option_values(o); 742 else if (ret && *cp) 743 ret = 0; 744 else if (fn && ptr) 745 ret = fn(data, ptr); 746 } 747 748 break; 749 } 750 case FIO_OPT_RANGE: { 751 char tmp[128]; 752 char *p1, *p2; 753 754 strncpy(tmp, ptr, sizeof(tmp) - 1); 755 756 /* Handle bsrange with separate read,write values: */ 757 p1 = strchr(tmp, ','); 758 if (p1) 759 *p1 = '\0'; 760 761 p1 = strchr(tmp, '-'); 762 if (!p1) { 763 p1 = strchr(tmp, ':'); 764 if (!p1) { 765 ret = 1; 766 break; 767 } 768 } 769 770 p2 = p1 + 1; 771 *p1 = '\0'; 772 p1 = tmp; 773 774 ret = 1; 775 if (!check_range_bytes(p1, &ul1, data) && 776 !check_range_bytes(p2, &ul2, data)) { 777 ret = 0; 778 if (ul1 > ul2) { 779 unsigned long foo = ul1; 780 781 ul1 = ul2; 782 ul2 = foo; 783 } 784 785 if (first) { 786 val_store(ilp, ul1, o->off1, 0, data, o); 787 val_store(ilp, ul2, o->off2, 0, data, o); 788 } 789 if (curr == 1) { 790 if (o->off3 && o->off4) { 791 val_store(ilp, ul1, o->off3, 0, data, o); 792 val_store(ilp, ul2, o->off4, 0, data, o); 793 } 794 } 795 if (curr == 2) { 796 if (o->off5 && o->off6) { 797 val_store(ilp, ul1, o->off5, 0, data, o); 798 val_store(ilp, ul2, o->off6, 0, data, o); 799 } 800 } 801 if (!more) { 802 if (curr < 1) { 803 if (o->off3 && o->off4) { 804 val_store(ilp, ul1, o->off3, 0, data, o); 805 val_store(ilp, ul2, o->off4, 0, data, o); 806 } 807 } 808 if (curr < 2) { 809 if (o->off5 && o->off6) { 810 val_store(ilp, ul1, o->off5, 0, data, o); 811 val_store(ilp, ul2, o->off6, 0, data, o); 812 } 813 } 814 } 815 } 816 817 break; 818 } 819 case FIO_OPT_BOOL: 820 case FIO_OPT_STR_SET: { 821 fio_opt_int_fn *fn = o->cb; 822 823 if (ptr) 824 ret = check_int(ptr, &il); 825 else if (o->type == FIO_OPT_BOOL) 826 ret = 1; 827 else 828 il = 1; 829 830 dprint(FD_PARSE, " ret=%d, out=%d\n", ret, il); 831 832 if (ret) 833 break; 834 835 if (o->maxval && il > (int) o->maxval) { 836 log_err("max value out of range: %d (%d max)\n", 837 il, o->maxval); 838 return 1; 839 } 840 if (o->minval && il < o->minval) { 841 log_err("min value out of range: %d (%d min)\n", 842 il, o->minval); 843 return 1; 844 } 845 846 if (o->neg) 847 il = !il; 848 849 if (fn) 850 ret = fn(data, &il); 851 else { 852 if (first) 853 val_store(ilp, il, o->off1, 0, data, o); 854 if (!more) { 855 if (o->off2) 856 val_store(ilp, il, o->off2, 0, data, o); 857 } 858 } 859 break; 860 } 861 case FIO_OPT_DEPRECATED: 862 log_info("Option %s is deprecated\n", o->name); 863 ret = 1; 864 break; 865 default: 866 log_err("Bad option type %u\n", o->type); 867 ret = 1; 868 } 869 870 if (ret) 871 return ret; 872 873 if (o->verify) { 874 ret = o->verify(o, data); 875 if (ret) { 876 log_err("Correct format for offending option\n"); 877 log_err("%20s: %s\n", o->name, o->help); 878 show_option_help(o, 1); 879 } 880 } 881 882 return ret; 883} 884 885static int handle_option(struct fio_option *o, const char *__ptr, void *data) 886{ 887 char *o_ptr, *ptr, *ptr2; 888 int ret, done; 889 890 dprint(FD_PARSE, "handle_option=%s, ptr=%s\n", o->name, __ptr); 891 892 o_ptr = ptr = NULL; 893 if (__ptr) 894 o_ptr = ptr = strdup(__ptr); 895 896 /* 897 * See if we have another set of parameters, hidden after a comma. 898 * Do this before parsing this round, to check if we should 899 * copy set 1 options to set 2. 900 */ 901 done = 0; 902 ret = 1; 903 do { 904 int __ret; 905 906 ptr2 = NULL; 907 if (ptr && 908 (o->type != FIO_OPT_STR_STORE) && 909 (o->type != FIO_OPT_STR) && 910 (o->type != FIO_OPT_FLOAT_LIST)) { 911 ptr2 = strchr(ptr, ','); 912 if (ptr2 && *(ptr2 + 1) == '\0') 913 *ptr2 = '\0'; 914 if (o->type != FIO_OPT_STR_MULTI && o->type != FIO_OPT_RANGE) { 915 if (!ptr2) 916 ptr2 = strchr(ptr, ':'); 917 if (!ptr2) 918 ptr2 = strchr(ptr, '-'); 919 } 920 } else if (ptr && o->type == FIO_OPT_FLOAT_LIST) { 921 ptr2 = strchr(ptr, ':'); 922 } 923 924 /* 925 * Don't return early if parsing the first option fails - if 926 * we are doing multiple arguments, we can allow the first one 927 * being empty. 928 */ 929 __ret = __handle_option(o, ptr, data, !done, !!ptr2, done); 930 if (ret) 931 ret = __ret; 932 933 if (!ptr2) 934 break; 935 936 ptr = ptr2 + 1; 937 done++; 938 } while (1); 939 940 if (o_ptr) 941 free(o_ptr); 942 return ret; 943} 944 945static struct fio_option *get_option(char *opt, 946 struct fio_option *options, char **post) 947{ 948 struct fio_option *o; 949 char *ret; 950 951 ret = strchr(opt, '='); 952 if (ret) { 953 *post = ret; 954 *ret = '\0'; 955 ret = opt; 956 (*post)++; 957 strip_blank_end(ret); 958 o = find_option(options, ret); 959 } else { 960 o = find_option(options, opt); 961 *post = NULL; 962 } 963 964 return o; 965} 966 967static int opt_cmp(const void *p1, const void *p2) 968{ 969 struct fio_option *o; 970 char *s, *foo; 971 int prio1, prio2; 972 973 prio1 = prio2 = 0; 974 975 if (*(char **)p1) { 976 s = strdup(*((char **) p1)); 977 o = get_option(s, __fio_options, &foo); 978 if (o) 979 prio1 = o->prio; 980 free(s); 981 } 982 if (*(char **)p2) { 983 s = strdup(*((char **) p2)); 984 o = get_option(s, __fio_options, &foo); 985 if (o) 986 prio2 = o->prio; 987 free(s); 988 } 989 990 return prio2 - prio1; 991} 992 993void sort_options(char **opts, struct fio_option *options, int num_opts) 994{ 995 __fio_options = options; 996 qsort(opts, num_opts, sizeof(char *), opt_cmp); 997 __fio_options = NULL; 998} 999 1000int parse_cmd_option(const char *opt, const char *val, 1001 struct fio_option *options, void *data) 1002{ 1003 struct fio_option *o; 1004 1005 o = find_option(options, opt); 1006 if (!o) { 1007 log_err("Bad option <%s>\n", opt); 1008 return 1; 1009 } 1010 1011 if (!handle_option(o, val, data)) 1012 return 0; 1013 1014 log_err("fio: failed parsing %s=%s\n", opt, val); 1015 return 1; 1016} 1017 1018int parse_option(char *opt, const char *input, 1019 struct fio_option *options, struct fio_option **o, void *data, 1020 int dump_cmdline) 1021{ 1022 char *post; 1023 1024 if (!opt) { 1025 log_err("fio: failed parsing %s\n", input); 1026 *o = NULL; 1027 return 1; 1028 } 1029 1030 *o = get_option(opt, options, &post); 1031 if (!*o) { 1032 if (post) { 1033 int len = strlen(opt); 1034 if (opt + len + 1 != post) 1035 memmove(opt + len + 1, post, strlen(post)); 1036 opt[len] = '='; 1037 } 1038 return 1; 1039 } 1040 1041 if (handle_option(*o, post, data)) { 1042 log_err("fio: failed parsing %s\n", input); 1043 return 1; 1044 } 1045 1046 if (dump_cmdline) { 1047 const char *delim; 1048 1049 if (!strcmp("description", (*o)->name)) 1050 delim = "\""; 1051 else 1052 delim = ""; 1053 1054 log_info("--%s%s", (*o)->name, post ? "" : " "); 1055 if (post) 1056 log_info("=%s%s%s ", delim, post, delim); 1057 } 1058 1059 return 0; 1060} 1061 1062/* 1063 * Option match, levenshtein distance. Handy for not quite remembering what 1064 * the option name is. 1065 */ 1066static int string_distance(const char *s1, const char *s2) 1067{ 1068 unsigned int s1_len = strlen(s1); 1069 unsigned int s2_len = strlen(s2); 1070 unsigned int *p, *q, *r; 1071 unsigned int i, j; 1072 1073 p = malloc(sizeof(unsigned int) * (s2_len + 1)); 1074 q = malloc(sizeof(unsigned int) * (s2_len + 1)); 1075 1076 p[0] = 0; 1077 for (i = 1; i <= s2_len; i++) 1078 p[i] = p[i - 1] + 1; 1079 1080 for (i = 1; i <= s1_len; i++) { 1081 q[0] = p[0] + 1; 1082 for (j = 1; j <= s2_len; j++) { 1083 unsigned int sub = p[j - 1]; 1084 1085 if (s1[i - 1] != s2[j - 1]) 1086 sub++; 1087 1088 q[j] = min(p[j] + 1, min(q[j - 1] + 1, sub)); 1089 } 1090 r = p; 1091 p = q; 1092 q = r; 1093 } 1094 1095 i = p[s2_len]; 1096 free(p); 1097 free(q); 1098 return i; 1099} 1100 1101static struct fio_option *find_child(struct fio_option *options, 1102 struct fio_option *o) 1103{ 1104 struct fio_option *__o; 1105 1106 for (__o = options + 1; __o->name; __o++) 1107 if (__o->parent && !strcmp(__o->parent, o->name)) 1108 return __o; 1109 1110 return NULL; 1111} 1112 1113static void __print_option(struct fio_option *o, struct fio_option *org, 1114 int level) 1115{ 1116 char name[256], *p; 1117 int depth; 1118 1119 if (!o) 1120 return; 1121 if (!org) 1122 org = o; 1123 1124 p = name; 1125 depth = level; 1126 while (depth--) 1127 p += sprintf(p, "%s", " "); 1128 1129 sprintf(p, "%s", o->name); 1130 1131 log_info("%-24s: %s\n", name, o->help); 1132} 1133 1134static void print_option(struct fio_option *o) 1135{ 1136 struct fio_option *parent; 1137 struct fio_option *__o; 1138 unsigned int printed; 1139 unsigned int level; 1140 1141 __print_option(o, NULL, 0); 1142 parent = o; 1143 level = 0; 1144 do { 1145 level++; 1146 printed = 0; 1147 1148 while ((__o = find_child(o, parent)) != NULL) { 1149 __print_option(__o, o, level); 1150 o = __o; 1151 printed++; 1152 } 1153 1154 parent = o; 1155 } while (printed); 1156} 1157 1158int show_cmd_help(struct fio_option *options, const char *name) 1159{ 1160 struct fio_option *o, *closest; 1161 unsigned int best_dist = -1U; 1162 int found = 0; 1163 int show_all = 0; 1164 1165 if (!name || !strcmp(name, "all")) 1166 show_all = 1; 1167 1168 closest = NULL; 1169 best_dist = -1; 1170 for (o = &options[0]; o->name; o++) { 1171 int match = 0; 1172 1173 if (o->type == FIO_OPT_DEPRECATED) 1174 continue; 1175 if (!exec_profile && o->prof_name) 1176 continue; 1177 if (exec_profile && !(o->prof_name && !strcmp(exec_profile, o->prof_name))) 1178 continue; 1179 1180 if (name) { 1181 if (!strcmp(name, o->name) || 1182 (o->alias && !strcmp(name, o->alias))) 1183 match = 1; 1184 else { 1185 unsigned int dist; 1186 1187 dist = string_distance(name, o->name); 1188 if (dist < best_dist) { 1189 best_dist = dist; 1190 closest = o; 1191 } 1192 } 1193 } 1194 1195 if (show_all || match) { 1196 found = 1; 1197 if (match) 1198 log_info("%20s: %s\n", o->name, o->help); 1199 if (show_all) { 1200 if (!o->parent) 1201 print_option(o); 1202 continue; 1203 } 1204 } 1205 1206 if (!match) 1207 continue; 1208 1209 show_option_help(o, 0); 1210 } 1211 1212 if (found) 1213 return 0; 1214 1215 log_err("No such command: %s", name); 1216 1217 /* 1218 * Only print an appropriately close option, one where the edit 1219 * distance isn't too big. Otherwise we get crazy matches. 1220 */ 1221 if (closest && best_dist < 3) { 1222 log_info(" - showing closest match\n"); 1223 log_info("%20s: %s\n", closest->name, closest->help); 1224 show_option_help(closest, 0); 1225 } else 1226 log_info("\n"); 1227 1228 return 1; 1229} 1230 1231/* 1232 * Handle parsing of default parameters. 1233 */ 1234void fill_default_options(void *data, struct fio_option *options) 1235{ 1236 struct fio_option *o; 1237 1238 dprint(FD_PARSE, "filling default options\n"); 1239 1240 for (o = &options[0]; o->name; o++) 1241 if (o->def) 1242 handle_option(o, o->def, data); 1243} 1244 1245void option_init(struct fio_option *o) 1246{ 1247 if (o->type == FIO_OPT_DEPRECATED) 1248 return; 1249 if (o->type == FIO_OPT_BOOL) { 1250 o->minval = 0; 1251 o->maxval = 1; 1252 } 1253 if (o->type == FIO_OPT_INT) { 1254 if (!o->maxval) 1255 o->maxval = UINT_MAX; 1256 } 1257 if (o->type == FIO_OPT_FLOAT_LIST) { 1258 o->minfp = DBL_MIN; 1259 o->maxfp = DBL_MAX; 1260 } 1261 if (o->type == FIO_OPT_STR_SET && o->def && !o->no_warn_def) { 1262 log_err("Option %s: string set option with" 1263 " default will always be true\n", o->name); 1264 } 1265 if (!o->cb && !o->off1) 1266 log_err("Option %s: neither cb nor offset given\n", o->name); 1267 if (!o->category) { 1268 log_info("Option %s: no category defined. Setting to misc\n", o->name); 1269 o->category = FIO_OPT_C_GENERAL; 1270 o->group = FIO_OPT_G_INVALID; 1271 } 1272 if (o->type == FIO_OPT_STR || o->type == FIO_OPT_STR_STORE || 1273 o->type == FIO_OPT_STR_MULTI) 1274 return; 1275 if (o->cb && (o->off1 || o->off2 || o->off3 || o->off4)) 1276 log_err("Option %s: both cb and offset given\n", o->name); 1277} 1278 1279/* 1280 * Sanitize the options structure. For now it just sets min/max for bool 1281 * values and whether both callback and offsets are given. 1282 */ 1283void options_init(struct fio_option *options) 1284{ 1285 struct fio_option *o; 1286 1287 dprint(FD_PARSE, "init options\n"); 1288 1289 for (o = &options[0]; o->name; o++) { 1290 option_init(o); 1291 if (o->inverse) 1292 o->inv_opt = find_option(options, o->inverse); 1293 } 1294} 1295 1296void options_free(struct fio_option *options, void *data) 1297{ 1298 struct fio_option *o; 1299 char **ptr; 1300 1301 dprint(FD_PARSE, "free options\n"); 1302 1303 for (o = &options[0]; o->name; o++) { 1304 if (o->type != FIO_OPT_STR_STORE || !o->off1) 1305 continue; 1306 1307 ptr = td_var(data, o, o->off1); 1308 if (*ptr) { 1309 free(*ptr); 1310 *ptr = NULL; 1311 } 1312 } 1313} 1314