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