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