stat: ensure we align correctly
[fio.git] / parse.c
CommitLineData
cb2c86fd
JA
1/*
2 * This file contains the ini and command liner parser main.
3 */
4#include <stdio.h>
5#include <stdlib.h>
cb2c86fd
JA
6#include <ctype.h>
7#include <string.h>
8#include <errno.h>
9#include <limits.h>
ab9461ea 10#include <float.h>
cb2c86fd 11
c26438ad 12#include "compiler/compiler.h"
cb2c86fd 13#include "parse.h"
a3d741fa 14#include "debug.h"
3d2d14bc 15#include "log.h"
9f988e2e 16#include "options.h"
d220c761 17#include "optgroup.h"
e25839d4 18#include "minmax.h"
fd112d34 19#include "lib/ieee754.h"
0f38bbef 20#include "lib/pow2.h"
cb2c86fd 21
b470a02c
SC
22#ifdef CONFIG_ARITHMETIC
23#include "y.tab.h"
24#endif
25
c26438ad
JA
26static const char *opt_type_names[] = {
27 "OPT_INVALID",
28 "OPT_STR",
5fff9543 29 "OPT_STR_ULL",
c26438ad
JA
30 "OPT_STR_MULTI",
31 "OPT_STR_VAL",
32 "OPT_STR_VAL_TIME",
33 "OPT_STR_STORE",
34 "OPT_RANGE",
35 "OPT_INT",
5fff9543 36 "OPT_ULL",
c26438ad
JA
37 "OPT_BOOL",
38 "OPT_FLOAT_LIST",
39 "OPT_STR_SET",
40 "OPT_DEPRECATED",
c47537ee 41 "OPT_SOFT_DEPRECATED",
c26438ad
JA
42 "OPT_UNSUPPORTED",
43};
44
9109883a 45static const struct fio_option *__fio_options;
3b8b7135 46
f085737f
JA
47static int vp_cmp(const void *p1, const void *p2)
48{
49 const struct value_pair *vp1 = p1;
50 const struct value_pair *vp2 = p2;
51
52 return strlen(vp2->ival) - strlen(vp1->ival);
53}
54
9109883a 55static void posval_sort(const struct fio_option *o, struct value_pair *vpmap)
f085737f
JA
56{
57 const struct value_pair *vp;
58 int entries;
59
60 memset(vpmap, 0, PARSE_MAX_VP * sizeof(struct value_pair));
61
62 for (entries = 0; entries < PARSE_MAX_VP; entries++) {
63 vp = &o->posval[entries];
64 if (!vp->ival || vp->ival[0] == '\0')
65 break;
66
67 memcpy(&vpmap[entries], vp, sizeof(*vp));
68 }
69
70 qsort(vpmap, entries, sizeof(struct value_pair), vp_cmp);
71}
72
9109883a 73static void show_option_range(const struct fio_option *o,
34a3a855 74 ssize_t (*logger)(const char *format, ...))
b1ec1da6 75{
3c037bcf 76 if (o->type == FIO_OPT_FLOAT_LIST) {
a1e070c8 77 const char *sep = "";
45b3e8d7 78 if (!o->minfp && !o->maxfp)
83349190
YH
79 return;
80
a1e070c8
BVA
81 logger("%20s: ", "range");
82 if (o->minfp != DBL_MIN) {
83 logger("min=%f", o->minfp);
84 sep = ", ";
85 }
ab9461ea 86 if (o->maxfp != DBL_MAX)
a1e070c8 87 logger("%smax=%f", sep, o->maxfp);
06b0be6e 88 logger("\n");
3c037bcf 89 } else if (!o->posval[0].ival) {
83349190
YH
90 if (!o->minval && !o->maxval)
91 return;
b1ec1da6 92
06b0be6e 93 logger("%20s: min=%d", "range", o->minval);
83349190 94 if (o->maxval)
06b0be6e
JA
95 logger(", max=%d", o->maxval);
96 logger("\n");
83349190 97 }
b1ec1da6
JA
98}
99
9109883a 100static void show_option_values(const struct fio_option *o)
b1ec1da6 101{
a3073f4a 102 int i;
b1ec1da6 103
a3073f4a 104 for (i = 0; i < PARSE_MAX_VP; i++) {
7837213b 105 const struct value_pair *vp = &o->posval[i];
b1ec1da6 106
7837213b 107 if (!vp->ival)
a3073f4a 108 continue;
b1ec1da6 109
06b0be6e 110 log_info("%20s: %-10s", i == 0 ? "valid values" : "", vp->ival);
7837213b 111 if (vp->help)
06b0be6e
JA
112 log_info(" %s", vp->help);
113 log_info("\n");
a3073f4a 114 }
b1ec1da6
JA
115
116 if (i)
06b0be6e 117 log_info("\n");
b1ec1da6
JA
118}
119
9109883a 120static void show_option_help(const struct fio_option *o, int is_err)
d447a8c2
JA
121{
122 const char *typehelp[] = {
cbd6ce9c
BVA
123 [FIO_OPT_INVALID] = "invalid",
124 [FIO_OPT_STR] = "string (opt=bla)",
125 [FIO_OPT_STR_ULL] = "string (opt=bla)",
126 [FIO_OPT_STR_MULTI] = "string with possible k/m/g postfix (opt=4k)",
127 [FIO_OPT_STR_VAL] = "string (opt=bla)",
128 [FIO_OPT_STR_VAL_TIME] = "string with time postfix (opt=10s)",
129 [FIO_OPT_STR_STORE] = "string (opt=bla)",
130 [FIO_OPT_RANGE] = "one to three ranges (opt=1k-4k[,4k-8k[,1k-8k]])",
131 [FIO_OPT_INT] = "integer value (opt=100)",
132 [FIO_OPT_ULL] = "integer value (opt=100)",
133 [FIO_OPT_BOOL] = "boolean value (opt=1)",
134 [FIO_OPT_FLOAT_LIST] = "list of floating point values separated by ':' (opt=5.9:7.8)",
135 [FIO_OPT_STR_SET] = "empty or boolean value ([0|1])",
136 [FIO_OPT_DEPRECATED] = "deprecated",
137 [FIO_OPT_SOFT_DEPRECATED] = "deprecated",
138 [FIO_OPT_UNSUPPORTED] = "unsupported",
d447a8c2 139 };
34a3a855 140 ssize_t (*logger)(const char *format, ...);
06b0be6e
JA
141
142 if (is_err)
143 logger = log_err;
144 else
145 logger = log_info;
d447a8c2
JA
146
147 if (o->alias)
06b0be6e 148 logger("%20s: %s\n", "alias", o->alias);
d447a8c2 149
06b0be6e
JA
150 logger("%20s: %s\n", "type", typehelp[o->type]);
151 logger("%20s: %s\n", "default", o->def ? o->def : "no default");
07b3232d 152 if (o->prof_name)
06b0be6e
JA
153 logger("%20s: only for profile '%s'\n", "valid", o->prof_name);
154 show_option_range(o, logger);
d447a8c2
JA
155 show_option_values(o);
156}
157
0de5b26f
JA
158static unsigned long long get_mult_time(const char *str, int len,
159 int is_seconds)
cb2c86fd 160{
74454ce4
CE
161 const char *p = str;
162 char *c;
e4668264 163 unsigned long long mult = 1;
1c9f0761 164 int i;
74454ce4
CE
165
166 /*
167 * Go forward until we hit a non-digit, or +/- sign
168 */
169 while ((p - str) <= len) {
170 if (!isdigit((int) *p) && (*p != '+') && (*p != '-'))
171 break;
172 p++;
cb2c86fd 173 }
74454ce4 174
0de5b26f
JA
175 if (!isalpha((int) *p)) {
176 if (is_seconds)
177 return 1000000UL;
178 else
179 return 1;
180 }
74454ce4
CE
181
182 c = strdup(p);
1c9f0761 183 for (i = 0; i < strlen(c); i++)
e99161b4 184 c[i] = tolower((unsigned char)c[i]);
74454ce4 185
e4668264 186 if (!strncmp("us", c, 2) || !strncmp("usec", c, 4))
74454ce4 187 mult = 1;
e4668264 188 else if (!strncmp("ms", c, 2) || !strncmp("msec", c, 4))
74454ce4 189 mult = 1000;
e4668264
JA
190 else if (!strcmp("s", c))
191 mult = 1000000;
74454ce4 192 else if (!strcmp("m", c))
e4668264 193 mult = 60 * 1000000UL;
74454ce4 194 else if (!strcmp("h", c))
e4668264 195 mult = 60 * 60 * 1000000UL;
74454ce4 196 else if (!strcmp("d", c))
4ed22fe5 197 mult = 24 * 60 * 60 * 1000000ULL;
74454ce4
CE
198
199 free(c);
200 return mult;
cb2c86fd
JA
201}
202
a03fb65f
JA
203static int is_separator(char c)
204{
205 switch (c) {
206 case ':':
207 case '-':
208 case ',':
209 case '/':
210 return 1;
211 default:
212 return 0;
213 }
214}
215
7bb59102
JA
216static unsigned long long __get_mult_bytes(const char *p, void *data,
217 int *percent)
cb2c86fd 218{
d6978a32 219 unsigned int kb_base = fio_get_kb_base(data);
a639f0bb 220 unsigned long long ret = 1;
57fc29fa
JA
221 unsigned int i, pow = 0, mult = kb_base;
222 char *c;
a639f0bb 223
57fc29fa
JA
224 if (!p)
225 return 1;
a639f0bb 226
57fc29fa
JA
227 c = strdup(p);
228
a03fb65f 229 for (i = 0; i < strlen(c); i++) {
e99161b4 230 c[i] = tolower((unsigned char)c[i]);
a03fb65f
JA
231 if (is_separator(c[i])) {
232 c[i] = '\0';
233 break;
234 }
235 }
57fc29fa 236
d694a6a7
RE
237 /* If kb_base is 1000, use true units.
238 * If kb_base is 1024, use opposite units.
239 */
a04f158d 240 if (!strncmp("pib", c, 3)) {
57fc29fa 241 pow = 5;
d694a6a7
RE
242 if (kb_base == 1000)
243 mult = 1024;
244 else if (kb_base == 1024)
245 mult = 1000;
a04f158d 246 } else if (!strncmp("tib", c, 3)) {
57fc29fa 247 pow = 4;
d694a6a7
RE
248 if (kb_base == 1000)
249 mult = 1024;
250 else if (kb_base == 1024)
251 mult = 1000;
a04f158d 252 } else if (!strncmp("gib", c, 3)) {
57fc29fa 253 pow = 3;
d694a6a7
RE
254 if (kb_base == 1000)
255 mult = 1024;
256 else if (kb_base == 1024)
257 mult = 1000;
a04f158d 258 } else if (!strncmp("mib", c, 3)) {
57fc29fa 259 pow = 2;
d694a6a7
RE
260 if (kb_base == 1000)
261 mult = 1024;
262 else if (kb_base == 1024)
263 mult = 1000;
a04f158d 264 } else if (!strncmp("kib", c, 3)) {
57fc29fa 265 pow = 1;
d694a6a7
RE
266 if (kb_base == 1000)
267 mult = 1024;
268 else if (kb_base == 1024)
269 mult = 1000;
270 } else if (!strncmp("p", c, 1) || !strncmp("pb", c, 2)) {
57fc29fa 271 pow = 5;
d694a6a7 272 } else if (!strncmp("t", c, 1) || !strncmp("tb", c, 2)) {
57fc29fa 273 pow = 4;
d694a6a7 274 } else if (!strncmp("g", c, 1) || !strncmp("gb", c, 2)) {
57fc29fa 275 pow = 3;
d694a6a7 276 } else if (!strncmp("m", c, 1) || !strncmp("mb", c, 2)) {
57fc29fa 277 pow = 2;
d694a6a7 278 } else if (!strncmp("k", c, 1) || !strncmp("kb", c, 2)) {
57fc29fa 279 pow = 1;
d694a6a7 280 } else if (!strncmp("%", c, 1)) {
7bb59102 281 *percent = 1;
e721c57f 282 free(c);
7bb59102
JA
283 return ret;
284 }
57fc29fa
JA
285
286 while (pow--)
287 ret *= (unsigned long long) mult;
288
289 free(c);
a639f0bb 290 return ret;
cb2c86fd
JA
291}
292
7bb59102 293static unsigned long long get_mult_bytes(const char *str, int len, void *data,
6925dd35 294 int *percent)
57fc29fa 295{
55ed9636 296 const char *p = str;
ba4ddd69 297 int digit_seen = 0;
57fc29fa 298
1d1c187b 299 if (len < 2)
7bb59102 300 return __get_mult_bytes(str, data, percent);
1d1c187b 301
d0c814ec
SL
302 /*
303 * Go forward until we hit a non-digit, or +/- sign
304 */
55ed9636 305 while ((p - str) <= len) {
ba4ddd69
JA
306 if (!isdigit((int) *p) &&
307 (((*p != '+') && (*p != '-')) || digit_seen))
55ed9636 308 break;
3c703d13 309 digit_seen |= isdigit((int) *p);
55ed9636
JA
310 p++;
311 }
312
7bb59102 313 if (!isalpha((int) *p) && (*p != '%'))
57fc29fa
JA
314 p = NULL;
315
7bb59102 316 return __get_mult_bytes(p, data, percent);
57fc29fa
JA
317}
318
b470a02c 319extern int evaluate_arithmetic_expression(const char *buffer, long long *ival,
88038bc7
SC
320 double *dval, double implied_units,
321 int is_time);
b470a02c 322
83349190
YH
323/*
324 * Convert string into a floating number. Return 1 for success and 0 otherwise.
325 */
88038bc7 326int str_to_float(const char *str, double *val, int is_time)
83349190 327{
b470a02c
SC
328#ifdef CONFIG_ARITHMETIC
329 int rc;
330 long long ival;
331 double dval;
332
333 if (str[0] == '(') {
88038bc7 334 rc = evaluate_arithmetic_expression(str, &ival, &dval, 1.0, is_time);
b470a02c
SC
335 if (!rc) {
336 *val = dval;
337 return 1;
338 }
339 }
340#endif
341 return 1 == sscanf(str, "%lf", val);
83349190
YH
342}
343
cb2c86fd 344/*
e1f36503 345 * convert string into decimal value, noting any size suffix
cb2c86fd 346 */
0de5b26f 347int str_to_decimal(const char *str, long long *val, int kilo, void *data,
88038bc7 348 int is_seconds, int is_time)
cb2c86fd 349{
b347f9da 350 int len, base;
b470a02c
SC
351 int rc = 1;
352#ifdef CONFIG_ARITHMETIC
353 long long ival;
354 double dval;
8e2c678f 355 double implied_units = 1.0;
b470a02c 356#endif
cb2c86fd 357
cb2c86fd 358 len = strlen(str);
f90eff5a
JA
359 if (!len)
360 return 1;
cb2c86fd 361
b470a02c 362#ifdef CONFIG_ARITHMETIC
8e2c678f
SC
363 if (is_seconds)
364 implied_units = 1000000.0;
b470a02c 365 if (str[0] == '(')
88038bc7 366 rc = evaluate_arithmetic_expression(str, &ival, &dval, implied_units, is_time);
18722a18
SC
367 if (str[0] == '(' && !rc) {
368 if (!kilo && is_seconds)
369 *val = ival / 1000000LL;
370 else
371 *val = ival;
372 }
b470a02c 373#endif
b347f9da 374
b470a02c 375 if (rc == 1) {
5cd4efe9
JA
376 char *endptr;
377
b470a02c
SC
378 if (strstr(str, "0x") || strstr(str, "0X"))
379 base = 16;
380 else
381 base = 10;
382
5cd4efe9
JA
383 *val = strtoll(str, &endptr, base);
384 if (*val == 0 && endptr == str)
385 return 1;
b470a02c
SC
386 if (*val == LONG_MAX && errno == ERANGE)
387 return 1;
388 }
cb2c86fd 389
7bb59102
JA
390 if (kilo) {
391 unsigned long long mult;
392 int perc = 0;
393
6925dd35 394 mult = get_mult_bytes(str, len, data, &perc);
7bb59102
JA
395 if (perc)
396 *val = -1ULL - *val;
397 else
398 *val *= mult;
399 } else
0de5b26f 400 *val *= get_mult_time(str, len, is_seconds);
1d31d1bc 401
cb2c86fd
JA
402 return 0;
403}
404
9af4a244 405int check_str_bytes(const char *p, long long *val, void *data)
cb2c86fd 406{
88038bc7 407 return str_to_decimal(p, val, 1, data, 0, 0);
cb2c86fd
JA
408}
409
0de5b26f 410int check_str_time(const char *p, long long *val, int is_seconds)
cb2c86fd 411{
88038bc7 412 return str_to_decimal(p, val, 0, NULL, is_seconds, 1);
cb2c86fd
JA
413}
414
415void strip_blank_front(char **p)
416{
417 char *s = *p;
418
4c8e9640
JA
419 if (!strlen(s))
420 return;
76cd9378 421 while (isspace((int) *s))
cb2c86fd 422 s++;
4d651dad
JA
423
424 *p = s;
cb2c86fd
JA
425}
426
427void strip_blank_end(char *p)
428{
853ee7fc 429 char *start = p, *s;
523bfadb 430
4c8e9640
JA
431 if (!strlen(p))
432 return;
433
523bfadb
JA
434 s = strchr(p, ';');
435 if (s)
436 *s = '\0';
437 s = strchr(p, '#');
438 if (s)
439 *s = '\0';
440 if (s)
441 p = s;
442
7f7e6e59 443 s = p + strlen(p);
76cd9378 444 while ((isspace((int) *s) || iscntrl((int) *s)) && (s > start))
cb2c86fd
JA
445 s--;
446
447 *(s + 1) = '\0';
448}
449
5fff9543 450static int check_range_bytes(const char *str, long long *val, void *data)
cb2c86fd 451{
57fc29fa 452 long long __val;
cb2c86fd 453
88038bc7 454 if (!str_to_decimal(str, &__val, 1, data, 0, 0)) {
57fc29fa 455 *val = __val;
cb2c86fd
JA
456 return 0;
457 }
458
cb2c86fd
JA
459 return 1;
460}
461
63f29372 462static int check_int(const char *p, int *val)
cb2c86fd 463{
787f7e95
JA
464 if (!strlen(p))
465 return 1;
d78ee463 466 if (strstr(p, "0x") || strstr(p, "0X")) {
a61bdfd8
JA
467 if (sscanf(p, "%x", val) == 1)
468 return 0;
469 } else {
470 if (sscanf(p, "%u", val) == 1)
471 return 0;
472 }
cb2c86fd 473
e1f36503
JA
474 return 1;
475}
cb2c86fd 476
e6f735f0 477static size_t opt_len(const char *str)
808def70
JA
478{
479 char *postfix;
480
481 postfix = strchr(str, ':');
482 if (!postfix)
483 return strlen(str);
484
485 return (int)(postfix - str);
486}
487
119cd939
JA
488static int str_match_len(const struct value_pair *vp, const char *str)
489{
490 return max(strlen(vp->ival), opt_len(str));
491}
492
f0fdbcaf
JA
493#define val_store(ptr, val, off, or, data, o) \
494 do { \
495 ptr = td_var((data), (o), (off)); \
496 if ((or)) \
497 *ptr |= (val); \
498 else \
499 *ptr = (val); \
17abbe89
JA
500 } while (0)
501
9109883a 502static const char *opt_type_name(const struct fio_option *o)
c26438ad
JA
503{
504 compiletime_assert(ARRAY_SIZE(opt_type_names) - 1 == FIO_OPT_UNSUPPORTED,
505 "opt_type_names[] index");
506
47844764 507 if (o->type <= FIO_OPT_UNSUPPORTED)
c26438ad
JA
508 return opt_type_names[o->type];
509
510 return "OPT_UNKNOWN?";
511}
512
5d2788d5
JA
513static bool val_too_large(const struct fio_option *o, unsigned long long val,
514 bool is_uint)
515{
516 if (!o->maxval)
517 return false;
518
7676a1c2
JA
519 if (is_uint) {
520 if ((int) val < 0)
521 return (int) val > (int) o->maxval;
b6c01983 522 return (unsigned int) val > o->maxval;
7676a1c2 523 }
5d2788d5
JA
524
525 return val > o->maxval;
526}
527
528static bool val_too_small(const struct fio_option *o, unsigned long long val,
529 bool is_uint)
530{
531 if (!o->minval)
532 return false;
533
b6c01983
JA
534 if (is_uint)
535 return (int) val < o->minval;
5d2788d5
JA
536
537 return val < o->minval;
538}
539
9109883a
BVA
540static int __handle_option(const struct fio_option *o, const char *ptr,
541 void *data, int first, int more, int curr)
cb2c86fd 542{
2fdbefdd 543 int il=0, *ilp;
fd112d34 544 fio_fp64_t *flp;
63f29372 545 long long ull, *ullp;
5fff9543
JF
546 long ul2;
547 long long ull1, ull2;
83349190 548 double uf;
bfe1d592 549 char **cp = NULL;
e42b01eb 550 int ret = 0, is_time = 0;
c44b1ff5
JA
551 const struct value_pair *vp;
552 struct value_pair posval[PARSE_MAX_VP];
553 int i, all_skipped = 1;
cb2c86fd 554
c26438ad
JA
555 dprint(FD_PARSE, "__handle_option=%s, type=%s, ptr=%s\n", o->name,
556 opt_type_name(o), ptr);
a3d741fa 557
e3cedca7 558 if (!ptr && o->type != FIO_OPT_STR_SET && o->type != FIO_OPT_STR) {
28d7c363 559 log_err("Option %s requires an argument\n", o->name);
08e26e35
JA
560 return 1;
561 }
562
e1f36503 563 switch (o->type) {
5f6ddf1e 564 case FIO_OPT_STR:
5fff9543 565 case FIO_OPT_STR_ULL:
5f6ddf1e 566 case FIO_OPT_STR_MULTI: {
e1f36503 567 fio_opt_str_fn *fn = o->cb;
b1ec1da6 568
f085737f
JA
569 posval_sort(o, posval);
570
5f6ddf1e 571 ret = 1;
b1ec1da6 572 for (i = 0; i < PARSE_MAX_VP; i++) {
f085737f 573 vp = &posval[i];
b1ec1da6 574 if (!vp->ival || vp->ival[0] == '\0')
a3073f4a 575 continue;
ae2ddba4 576 all_skipped = 0;
078b46d1
JA
577 if (!ptr)
578 break;
119cd939 579 if (!strncmp(vp->ival, ptr, str_match_len(vp, ptr))) {
b1ec1da6 580 ret = 0;
5fff9543
JF
581 if (!o->off1)
582 continue;
583 if (o->type == FIO_OPT_STR_ULL)
584 val_store(ullp, vp->oval, o->off1, vp->orval, data, o);
585 else
ebadc0ce 586 val_store(ilp, vp->oval, o->off1, vp->orval, data, o);
5f6ddf1e 587 continue;
b1ec1da6
JA
588 }
589 }
cb2c86fd 590
ae2ddba4 591 if (ret && !all_skipped)
b1ec1da6
JA
592 show_option_values(o);
593 else if (fn)
594 ret = fn(data, ptr);
e1f36503
JA
595 break;
596 }
e42b01eb
JA
597 case FIO_OPT_STR_VAL_TIME:
598 is_time = 1;
9854d2e3 599 /* fall through */
5fff9543 600 case FIO_OPT_ULL:
1a1137d9 601 case FIO_OPT_INT:
e42b01eb
JA
602 case FIO_OPT_STR_VAL: {
603 fio_opt_str_val_fn *fn = o->cb;
6eaf09d6
SL
604 char tmp[128], *p;
605
88038bc7
SC
606 if (!is_time && o->is_time)
607 is_time = o->is_time;
608
36833fb0 609 snprintf(tmp, sizeof(tmp), "%s", ptr);
6eaf09d6
SL
610 p = strchr(tmp, ',');
611 if (p)
612 *p = '\0';
e42b01eb
JA
613
614 if (is_time)
0de5b26f 615 ret = check_str_time(tmp, &ull, o->is_seconds);
e42b01eb 616 else
6eaf09d6 617 ret = check_str_bytes(tmp, &ull, data);
e1f36503 618
ae3fcb5a
JA
619 dprint(FD_PARSE, " ret=%d, out=%llu\n", ret, ull);
620
e1f36503
JA
621 if (ret)
622 break;
0f38bbef
JA
623 if (o->pow2 && !is_power_of_2(ull)) {
624 log_err("%s: must be a power-of-2\n", o->name);
625 return 1;
626 }
e1f36503 627
5d2788d5 628 if (val_too_large(o, ull, o->type == FIO_OPT_INT)) {
a69c9b57
JA
629 log_err("%s: max value out of range: %llu"
630 " (%llu max)\n", o->name, ull, o->maxval);
db8e0165
JA
631 return 1;
632 }
5d2788d5 633 if (val_too_small(o, ull, o->type == FIO_OPT_INT)) {
a69c9b57
JA
634 log_err("%s: min value out of range: %lld"
635 " (%d min)\n", o->name, ull, o->minval);
db8e0165
JA
636 return 1;
637 }
d926d535
JA
638 if (o->posval[0].ival) {
639 posval_sort(o, posval);
640
641 ret = 1;
642 for (i = 0; i < PARSE_MAX_VP; i++) {
643 vp = &posval[i];
644 if (!vp->ival || vp->ival[0] == '\0')
645 continue;
646 if (vp->oval == ull) {
647 ret = 0;
648 break;
649 }
650 }
651 if (ret) {
128e4caf
JA
652 log_err("fio: value %llu not allowed:\n", ull);
653 show_option_values(o);
d926d535
JA
654 return 1;
655 }
656 }
e1f36503
JA
657
658 if (fn)
659 ret = fn(data, &ull);
660 else {
e01b22b8 661 if (o->type == FIO_OPT_INT) {
7b504edd
JA
662 if (first)
663 val_store(ilp, ull, o->off1, 0, data, o);
6eaf09d6 664 if (curr == 1) {
7b504edd
JA
665 if (o->off2)
666 val_store(ilp, ull, o->off2, 0, data, o);
02c6aad5 667 }
6eaf09d6 668 if (curr == 2) {
7b504edd
JA
669 if (o->off3)
670 val_store(ilp, ull, o->off3, 0, data, o);
6eaf09d6
SL
671 }
672 if (!more) {
673 if (curr < 1) {
7b504edd
JA
674 if (o->off2)
675 val_store(ilp, ull, o->off2, 0, data, o);
6eaf09d6
SL
676 }
677 if (curr < 2) {
7b504edd
JA
678 if (o->off3)
679 val_store(ilp, ull, o->off3, 0, data, o);
6eaf09d6
SL
680 }
681 }
5fff9543
JF
682 } else if (o->type == FIO_OPT_ULL) {
683 if (first)
684 val_store(ullp, ull, o->off1, 0, data, o);
685 if (curr == 1) {
686 if (o->off2)
687 val_store(ullp, ull, o->off2, 0, data, o);
688 }
689 if (curr == 2) {
690 if (o->off3)
691 val_store(ullp, ull, o->off3, 0, data, o);
692 }
693 if (!more) {
694 if (curr < 1) {
695 if (o->off2)
696 val_store(ullp, ull, o->off2, 0, data, o);
697 }
698 if (curr < 2) {
699 if (o->off3)
700 val_store(ullp, ull, o->off3, 0, data, o);
701 }
702 }
75e6f36f 703 } else {
7b504edd
JA
704 if (first)
705 val_store(ullp, ull, o->off1, 0, data, o);
02c6aad5 706 if (!more) {
7b504edd
JA
707 if (o->off2)
708 val_store(ullp, ull, o->off2, 0, data, o);
02c6aad5 709 }
75e6f36f 710 }
e1f36503
JA
711 }
712 break;
713 }
83349190 714 case FIO_OPT_FLOAT_LIST: {
eef02441
JA
715 char *cp2;
716
435d195a
VKF
717 if (first) {
718 /*
719 ** Initialize precision to 0 and zero out list
720 ** in case specified list is shorter than default
721 */
3e260a46
JA
722 if (o->off2) {
723 ul2 = 0;
f0fdbcaf 724 ilp = td_var(data, o, o->off2);
3e260a46
JA
725 *ilp = ul2;
726 }
435d195a 727
f0fdbcaf 728 flp = td_var(data, o, o->off1);
435d195a
VKF
729 for(i = 0; i < o->maxlen; i++)
730 flp[i].u.f = 0.0;
731 }
83349190 732 if (curr >= o->maxlen) {
28d7c363 733 log_err("the list exceeding max length %d\n",
83349190
YH
734 o->maxlen);
735 return 1;
736 }
88038bc7 737 if (!str_to_float(ptr, &uf, 0)) { /* this breaks if we ever have lists of times */
28d7c363 738 log_err("not a floating point value: %s\n", ptr);
83349190
YH
739 return 1;
740 }
45b3e8d7
BVA
741 if (o->minfp || o->maxfp) {
742 if (uf > o->maxfp) {
743 log_err("value out of range: %f"
744 " (range max: %f)\n", uf, o->maxfp);
745 return 1;
746 }
747 if (uf < o->minfp) {
748 log_err("value out of range: %f"
749 " (range min: %f)\n", uf, o->minfp);
750 return 1;
751 }
83349190
YH
752 }
753
f0fdbcaf 754 flp = td_var(data, o, o->off1);
fd112d34 755 flp[curr].u.f = uf;
83349190 756
ae3fcb5a
JA
757 dprint(FD_PARSE, " out=%f\n", uf);
758
435d195a
VKF
759 /*
760 ** Calculate precision for output by counting
761 ** number of digits after period. Find first
762 ** period in entire remaining list each time
763 */
764 cp2 = strchr(ptr, '.');
765 if (cp2 != NULL) {
eef02441 766 int len = 0;
435d195a
VKF
767
768 while (*++cp2 != '\0' && *cp2 >= '0' && *cp2 <= '9')
769 len++;
770
3e260a46 771 if (o->off2) {
f0fdbcaf 772 ilp = td_var(data, o, o->off2);
3e260a46
JA
773 if (len > *ilp)
774 *ilp = len;
775 }
435d195a
VKF
776 }
777
83349190
YH
778 break;
779 }
af52b345
JA
780 case FIO_OPT_STR_STORE: {
781 fio_opt_str_fn *fn = o->cb;
782
f75c69a1
JA
783 if (!strlen(ptr))
784 return 1;
785
7b504edd 786 if (o->off1) {
f0fdbcaf 787 cp = td_var(data, o, o->off1);
184b4098 788 *cp = strdup(ptr);
1c964ce5 789 }
02c6aad5 790
184b4098
SL
791 if (fn)
792 ret = fn(data, ptr);
793 else if (o->posval[0].ival) {
794 posval_sort(o, posval);
795
796 ret = 1;
797 for (i = 0; i < PARSE_MAX_VP; i++) {
798 vp = &posval[i];
ab50817f 799 if (!vp->ival || vp->ival[0] == '\0' || !cp)
184b4098
SL
800 continue;
801 all_skipped = 0;
119cd939 802 if (!strncmp(vp->ival, ptr, str_match_len(vp, ptr))) {
184b4098
SL
803 char *rest;
804
805 ret = 0;
806 if (vp->cb)
807 fn = vp->cb;
808 rest = strstr(*cp ?: ptr, ":");
809 if (rest) {
810 if (*cp)
811 *rest = '\0';
812 ptr = rest + 1;
813 } else
814 ptr = NULL;
815 break;
816 }
af52b345
JA
817 }
818 }
c44b1ff5 819
184b4098
SL
820 if (!all_skipped) {
821 if (ret && !*cp)
822 show_option_values(o);
823 else if (ret && *cp)
824 ret = 0;
825 else if (fn && ptr)
826 ret = fn(data, ptr);
827 }
c44b1ff5 828
e1f36503 829 break;
af52b345 830 }
e1f36503 831 case FIO_OPT_RANGE: {
b765a372 832 char tmp[128];
e1f36503
JA
833 char *p1, *p2;
834
36833fb0 835 snprintf(tmp, sizeof(tmp), "%s", ptr);
b765a372 836
31d23f47
DE
837 /* Handle bsrange with separate read,write values: */
838 p1 = strchr(tmp, ',');
839 if (p1)
840 *p1 = '\0';
841
b765a372 842 p1 = strchr(tmp, '-');
e1f36503 843 if (!p1) {
0c9baf91
JA
844 p1 = strchr(tmp, ':');
845 if (!p1) {
846 ret = 1;
847 break;
848 }
e1f36503
JA
849 }
850
851 p2 = p1 + 1;
852 *p1 = '\0';
b765a372 853 p1 = tmp;
e1f36503
JA
854
855 ret = 1;
5fff9543
JF
856 if (!check_range_bytes(p1, &ull1, data) &&
857 !check_range_bytes(p2, &ull2, data)) {
e1f36503 858 ret = 0;
5fff9543
JF
859 if (ull1 > ull2) {
860 unsigned long long foo = ull1;
f90eff5a 861
5fff9543
JF
862 ull1 = ull2;
863 ull2 = foo;
f90eff5a
JA
864 }
865
866 if (first) {
5fff9543
JF
867 val_store(ullp, ull1, o->off1, 0, data, o);
868 val_store(ullp, ull2, o->off2, 0, data, o);
17abbe89 869 }
6eaf09d6 870 if (curr == 1) {
7b504edd 871 if (o->off3 && o->off4) {
5fff9543
JF
872 val_store(ullp, ull1, o->off3, 0, data, o);
873 val_store(ullp, ull2, o->off4, 0, data, o);
6eaf09d6
SL
874 }
875 }
876 if (curr == 2) {
7b504edd 877 if (o->off5 && o->off6) {
5fff9543
JF
878 val_store(ullp, ull1, o->off5, 0, data, o);
879 val_store(ullp, ull2, o->off6, 0, data, o);
6eaf09d6
SL
880 }
881 }
882 if (!more) {
883 if (curr < 1) {
7b504edd 884 if (o->off3 && o->off4) {
5fff9543
JF
885 val_store(ullp, ull1, o->off3, 0, data, o);
886 val_store(ullp, ull2, o->off4, 0, data, o);
6eaf09d6
SL
887 }
888 }
889 if (curr < 2) {
7b504edd 890 if (o->off5 && o->off6) {
5fff9543
JF
891 val_store(ullp, ull1, o->off5, 0, data, o);
892 val_store(ullp, ull2, o->off6, 0, data, o);
6eaf09d6
SL
893 }
894 }
e1f36503 895 }
17abbe89
JA
896 }
897
e1f36503
JA
898 break;
899 }
74ba1808
JA
900 case FIO_OPT_BOOL:
901 case FIO_OPT_STR_SET: {
e1f36503
JA
902 fio_opt_int_fn *fn = o->cb;
903
74ba1808
JA
904 if (ptr)
905 ret = check_int(ptr, &il);
906 else if (o->type == FIO_OPT_BOOL)
907 ret = 1;
908 else
909 il = 1;
910
ae3fcb5a
JA
911 dprint(FD_PARSE, " ret=%d, out=%d\n", ret, il);
912
e1f36503
JA
913 if (ret)
914 break;
915
db8e0165 916 if (o->maxval && il > (int) o->maxval) {
5fff9543 917 log_err("max value out of range: %d (%llu max)\n",
5ec10eaa 918 il, o->maxval);
db8e0165
JA
919 return 1;
920 }
921 if (o->minval && il < o->minval) {
28d7c363 922 log_err("min value out of range: %d (%d min)\n",
5ec10eaa 923 il, o->minval);
db8e0165
JA
924 return 1;
925 }
e1f36503 926
76a43db4
JA
927 if (o->neg)
928 il = !il;
929
e1f36503
JA
930 if (fn)
931 ret = fn(data, &il);
932 else {
7b504edd
JA
933 if (first)
934 val_store(ilp, il, o->off1, 0, data, o);
02c6aad5 935 if (!more) {
7b504edd
JA
936 if (o->off2)
937 val_store(ilp, il, o->off2, 0, data, o);
02c6aad5 938 }
e1f36503
JA
939 }
940 break;
941 }
15ca150e 942 case FIO_OPT_DEPRECATED:
d9472271 943 ret = 1;
a8d8f828 944 /* fall through */
c47537ee
JA
945 case FIO_OPT_SOFT_DEPRECATED:
946 log_info("Option %s is deprecated\n", o->name);
15ca150e 947 break;
e1f36503 948 default:
06b0be6e 949 log_err("Bad option type %u\n", o->type);
e1f36503
JA
950 ret = 1;
951 }
cb2c86fd 952
70a4c0c8
JA
953 if (ret)
954 return ret;
955
d447a8c2 956 if (o->verify) {
70a4c0c8 957 ret = o->verify(o, data);
d447a8c2 958 if (ret) {
28d7c363
JA
959 log_err("Correct format for offending option\n");
960 log_err("%20s: %s\n", o->name, o->help);
06b0be6e 961 show_option_help(o, 1);
d447a8c2
JA
962 }
963 }
70a4c0c8 964
e1f36503 965 return ret;
cb2c86fd
JA
966}
967
9109883a
BVA
968static int handle_option(const struct fio_option *o, const char *__ptr,
969 void *data)
f90eff5a 970{
b62bdf2c
JA
971 char *o_ptr, *ptr, *ptr2;
972 int ret, done;
f90eff5a 973
7c8f1a5c
JA
974 dprint(FD_PARSE, "handle_option=%s, ptr=%s\n", o->name, __ptr);
975
b62bdf2c 976 o_ptr = ptr = NULL;
7c8f1a5c 977 if (__ptr)
b62bdf2c 978 o_ptr = ptr = strdup(__ptr);
a3d741fa 979
f90eff5a 980 /*
b62bdf2c
JA
981 * See if we have another set of parameters, hidden after a comma.
982 * Do this before parsing this round, to check if we should
787f7e95 983 * copy set 1 options to set 2.
f90eff5a 984 */
b62bdf2c
JA
985 done = 0;
986 ret = 1;
987 do {
988 int __ret;
989
990 ptr2 = NULL;
991 if (ptr &&
992 (o->type != FIO_OPT_STR_STORE) &&
83349190 993 (o->type != FIO_OPT_STR) &&
e97163ad 994 (o->type != FIO_OPT_STR_ULL) &&
83349190 995 (o->type != FIO_OPT_FLOAT_LIST)) {
b62bdf2c
JA
996 ptr2 = strchr(ptr, ',');
997 if (ptr2 && *(ptr2 + 1) == '\0')
998 *ptr2 = '\0';
6eaf09d6 999 if (o->type != FIO_OPT_STR_MULTI && o->type != FIO_OPT_RANGE) {
b62bdf2c
JA
1000 if (!ptr2)
1001 ptr2 = strchr(ptr, ':');
1002 if (!ptr2)
1003 ptr2 = strchr(ptr, '-');
1004 }
83349190
YH
1005 } else if (ptr && o->type == FIO_OPT_FLOAT_LIST) {
1006 ptr2 = strchr(ptr, ':');
b62bdf2c 1007 }
787f7e95 1008
b62bdf2c
JA
1009 /*
1010 * Don't return early if parsing the first option fails - if
1011 * we are doing multiple arguments, we can allow the first one
1012 * being empty.
1013 */
83349190 1014 __ret = __handle_option(o, ptr, data, !done, !!ptr2, done);
b62bdf2c
JA
1015 if (ret)
1016 ret = __ret;
787f7e95 1017
b62bdf2c
JA
1018 if (!ptr2)
1019 break;
f90eff5a 1020
b62bdf2c
JA
1021 ptr = ptr2 + 1;
1022 done++;
1023 } while (1);
787f7e95 1024
b62bdf2c
JA
1025 if (o_ptr)
1026 free(o_ptr);
1027 return ret;
f90eff5a
JA
1028}
1029
75e6bcba
JA
1030struct fio_option *find_option(struct fio_option *options, const char *opt)
1031{
1032 struct fio_option *o;
1033
1034 for (o = &options[0]; o->name; o++) {
1035 if (!o_match(o, opt))
1036 continue;
1037 if (o->type == FIO_OPT_UNSUPPORTED) {
1038 log_err("Option <%s>: %s\n", o->name, o->help);
1039 continue;
1040 }
1041
1042 return o;
1043 }
1044
1045 return NULL;
1046}
1047
9109883a
BVA
1048const struct fio_option *
1049find_option_c(const struct fio_option *options, const char *opt)
1050{
40938cde
TK
1051 const struct fio_option *o;
1052
1053 for (o = &options[0]; o->name; o++) {
1054 if (!o_match(o, opt))
1055 continue;
1056 if (o->type == FIO_OPT_UNSUPPORTED) {
1057 log_err("Option <%s>: %s\n", o->name, o->help);
1058 continue;
1059 }
1060
1061 return o;
1062 }
1063
1064 return NULL;
9109883a 1065}
75e6bcba 1066
9109883a
BVA
1067static const struct fio_option *
1068get_option(char *opt, const struct fio_option *options, char **post)
3b8b7135 1069{
9109883a 1070 const struct fio_option *o;
3b8b7135
JA
1071 char *ret;
1072
1073 ret = strchr(opt, '=');
1074 if (ret) {
1075 *post = ret;
1076 *ret = '\0';
de890a1e 1077 ret = opt;
3b8b7135 1078 (*post)++;
43c129b4 1079 strip_blank_end(ret);
9109883a 1080 o = find_option_c(options, ret);
3b8b7135 1081 } else {
9109883a 1082 o = find_option_c(options, opt);
3b8b7135
JA
1083 *post = NULL;
1084 }
1085
1086 return o;
1087}
1088
1089static int opt_cmp(const void *p1, const void *p2)
1090{
9109883a 1091 const struct fio_option *o;
de890a1e 1092 char *s, *foo;
8cdabc1d 1093 int prio1, prio2;
3b8b7135 1094
8cdabc1d 1095 prio1 = prio2 = 0;
3b8b7135 1096
de890a1e
SL
1097 if (*(char **)p1) {
1098 s = strdup(*((char **) p1));
9af4a244 1099 o = get_option(s, __fio_options, &foo);
de890a1e
SL
1100 if (o)
1101 prio1 = o->prio;
1102 free(s);
1103 }
1104 if (*(char **)p2) {
1105 s = strdup(*((char **) p2));
9af4a244 1106 o = get_option(s, __fio_options, &foo);
de890a1e
SL
1107 if (o)
1108 prio2 = o->prio;
1109 free(s);
1110 }
1111
8cdabc1d 1112 return prio2 - prio1;
3b8b7135
JA
1113}
1114
9109883a 1115void sort_options(char **opts, const struct fio_option *options, int num_opts)
3b8b7135 1116{
9af4a244 1117 __fio_options = options;
3b8b7135 1118 qsort(opts, num_opts, sizeof(char *), opt_cmp);
9af4a244 1119 __fio_options = NULL;
3b8b7135
JA
1120}
1121
9109883a
BVA
1122static void add_to_dump_list(const struct fio_option *o,
1123 struct flist_head *dump_list, const char *post)
d8b4f395
JA
1124{
1125 struct print_option *p;
1126
1127 if (!dump_list)
1128 return;
1129
1130 p = malloc(sizeof(*p));
1131 p->name = strdup(o->name);
1132 if (post)
1133 p->value = strdup(post);
1134 else
1135 p->value = NULL;
1136
1137 flist_add_tail(&p->list, dump_list);
1138}
1139
b4692828 1140int parse_cmd_option(const char *opt, const char *val,
9109883a 1141 const struct fio_option *options, void *data,
d8b4f395 1142 struct flist_head *dump_list)
b4692828 1143{
9109883a 1144 const struct fio_option *o;
b4692828 1145
9109883a 1146 o = find_option_c(options, opt);
b4692828 1147 if (!o) {
06b0be6e 1148 log_err("Bad option <%s>\n", opt);
b4692828
JA
1149 return 1;
1150 }
1151
d8b4f395
JA
1152 if (handle_option(o, val, data)) {
1153 log_err("fio: failed parsing %s=%s\n", opt, val);
1154 return 1;
1155 }
b1508cf9 1156
d8b4f395
JA
1157 add_to_dump_list(o, dump_list, val);
1158 return 0;
b4692828
JA
1159}
1160
9109883a
BVA
1161int parse_option(char *opt, const char *input, const struct fio_option *options,
1162 const struct fio_option **o, void *data,
c2292325 1163 struct flist_head *dump_list)
cb2c86fd 1164{
d0c814ec 1165 char *post;
e1f36503 1166
d0c814ec
SL
1167 if (!opt) {
1168 log_err("fio: failed parsing %s\n", input);
de890a1e 1169 *o = NULL;
38789b58 1170 return 1;
d0c814ec 1171 }
e1f36503 1172
de890a1e
SL
1173 *o = get_option(opt, options, &post);
1174 if (!*o) {
1175 if (post) {
1176 int len = strlen(opt);
1177 if (opt + len + 1 != post)
1178 memmove(opt + len + 1, post, strlen(post));
1179 opt[len] = '=';
1180 }
e1f36503
JA
1181 return 1;
1182 }
1183
292cc475
JA
1184 if (handle_option(*o, post, data)) {
1185 log_err("fio: failed parsing %s\n", input);
1186 return 1;
1187 }
b1508cf9 1188
d8b4f395 1189 add_to_dump_list(*o, dump_list, post);
292cc475 1190 return 0;
e1f36503 1191}
fd28ca49 1192
0e9f7fac
JA
1193/*
1194 * Option match, levenshtein distance. Handy for not quite remembering what
1195 * the option name is.
1196 */
a893c261 1197int string_distance(const char *s1, const char *s2)
0e9f7fac
JA
1198{
1199 unsigned int s1_len = strlen(s1);
1200 unsigned int s2_len = strlen(s2);
1201 unsigned int *p, *q, *r;
1202 unsigned int i, j;
1203
1204 p = malloc(sizeof(unsigned int) * (s2_len + 1));
1205 q = malloc(sizeof(unsigned int) * (s2_len + 1));
1206
1207 p[0] = 0;
1208 for (i = 1; i <= s2_len; i++)
1209 p[i] = p[i - 1] + 1;
1210
1211 for (i = 1; i <= s1_len; i++) {
1212 q[0] = p[0] + 1;
1213 for (j = 1; j <= s2_len; j++) {
1214 unsigned int sub = p[j - 1];
8a1db9a1 1215 unsigned int pmin;
0e9f7fac
JA
1216
1217 if (s1[i - 1] != s2[j - 1])
1218 sub++;
1219
8a1db9a1
JA
1220 pmin = min(q[j - 1] + 1, sub);
1221 q[j] = min(p[j] + 1, pmin);
0e9f7fac
JA
1222 }
1223 r = p;
1224 p = q;
1225 q = r;
1226 }
1227
1228 i = p[s2_len];
1229 free(p);
1230 free(q);
1231 return i;
1232}
1233
3701636d
JA
1234/*
1235 * Make a guess of whether the distance from 's1' is significant enough
1236 * to warrant printing the guess. We set this to a 1/2 match.
1237 */
1238int string_distance_ok(const char *opt, int distance)
1239{
1240 size_t len;
1241
1242 len = strlen(opt);
1243 len = (len + 1) / 2;
1244 return distance <= len;
1245}
1246
9109883a
BVA
1247static const struct fio_option *find_child(const struct fio_option *options,
1248 const struct fio_option *o)
afdf9352 1249{
9109883a 1250 const struct fio_option *__o;
afdf9352 1251
fdf28744
JA
1252 for (__o = options + 1; __o->name; __o++)
1253 if (__o->parent && !strcmp(__o->parent, o->name))
afdf9352
JA
1254 return __o;
1255
1256 return NULL;
1257}
1258
9109883a
BVA
1259static void __print_option(const struct fio_option *o,
1260 const struct fio_option *org,
323d9113 1261 int level)
afdf9352
JA
1262{
1263 char name[256], *p;
323d9113 1264 int depth;
afdf9352
JA
1265
1266 if (!o)
1267 return;
5ec10eaa 1268
afdf9352 1269 p = name;
323d9113
JA
1270 depth = level;
1271 while (depth--)
1272 p += sprintf(p, "%s", " ");
afdf9352
JA
1273
1274 sprintf(p, "%s", o->name);
1275
28d7c363 1276 log_info("%-24s: %s\n", name, o->help);
323d9113
JA
1277}
1278
9109883a 1279static void print_option(const struct fio_option *o)
323d9113 1280{
9109883a
BVA
1281 const struct fio_option *parent;
1282 const struct fio_option *__o;
323d9113
JA
1283 unsigned int printed;
1284 unsigned int level;
1285
1286 __print_option(o, NULL, 0);
1287 parent = o;
1288 level = 0;
1289 do {
1290 level++;
1291 printed = 0;
1292
1293 while ((__o = find_child(o, parent)) != NULL) {
1294 __print_option(__o, o, level);
1295 o = __o;
1296 printed++;
1297 }
1298
1299 parent = o;
1300 } while (printed);
afdf9352
JA
1301}
1302
9109883a 1303int show_cmd_help(const struct fio_option *options, const char *name)
0e9f7fac 1304{
9109883a 1305 const struct fio_option *o, *closest;
d091d099 1306 unsigned int best_dist = -1U;
29fc6afe 1307 int found = 0;
320beefe
JA
1308 int show_all = 0;
1309
1310 if (!name || !strcmp(name, "all"))
1311 show_all = 1;
fd28ca49 1312
0e9f7fac
JA
1313 closest = NULL;
1314 best_dist = -1;
4945ba12 1315 for (o = &options[0]; o->name; o++) {
320beefe
JA
1316 int match = 0;
1317
c47537ee
JA
1318 if (o->type == FIO_OPT_DEPRECATED ||
1319 o->type == FIO_OPT_SOFT_DEPRECATED)
15ca150e 1320 continue;
07b3232d
JA
1321 if (!exec_profile && o->prof_name)
1322 continue;
4ac23d27
JA
1323 if (exec_profile && !(o->prof_name && !strcmp(exec_profile, o->prof_name)))
1324 continue;
15ca150e 1325
0e9f7fac 1326 if (name) {
7f9348f8
JA
1327 if (!strcmp(name, o->name) ||
1328 (o->alias && !strcmp(name, o->alias)))
0e9f7fac
JA
1329 match = 1;
1330 else {
1331 unsigned int dist;
1332
1333 dist = string_distance(name, o->name);
1334 if (dist < best_dist) {
1335 best_dist = dist;
1336 closest = o;
1337 }
1338 }
1339 }
fd28ca49
JA
1340
1341 if (show_all || match) {
29fc6afe 1342 found = 1;
c167dedc 1343 if (match)
28d7c363 1344 log_info("%20s: %s\n", o->name, o->help);
c167dedc 1345 if (show_all) {
afdf9352 1346 if (!o->parent)
323d9113 1347 print_option(o);
4945ba12 1348 continue;
c167dedc 1349 }
fd28ca49
JA
1350 }
1351
70df2f19
JA
1352 if (!match)
1353 continue;
1354
06b0be6e 1355 show_option_help(o, 0);
fd28ca49
JA
1356 }
1357
29fc6afe
JA
1358 if (found)
1359 return 0;
fd28ca49 1360
28d7c363 1361 log_err("No such command: %s", name);
d091d099
JA
1362
1363 /*
1364 * Only print an appropriately close option, one where the edit
1365 * distance isn't too big. Otherwise we get crazy matches.
1366 */
1367 if (closest && best_dist < 3) {
28d7c363
JA
1368 log_info(" - showing closest match\n");
1369 log_info("%20s: %s\n", closest->name, closest->help);
06b0be6e 1370 show_option_help(closest, 0);
0e9f7fac 1371 } else
28d7c363 1372 log_info("\n");
0e9f7fac 1373
29fc6afe 1374 return 1;
fd28ca49 1375}
ee738499 1376
13335ddb
JA
1377/*
1378 * Handle parsing of default parameters.
1379 */
9109883a 1380void fill_default_options(void *data, const struct fio_option *options)
ee738499 1381{
9109883a 1382 const struct fio_option *o;
ee738499 1383
a3d741fa
JA
1384 dprint(FD_PARSE, "filling default options\n");
1385
4945ba12 1386 for (o = &options[0]; o->name; o++)
ee738499
JA
1387 if (o->def)
1388 handle_option(o, o->def, data);
ee738499 1389}
13335ddb 1390
8aa89d70 1391static void option_init(struct fio_option *o)
9f988e2e 1392{
c47537ee
JA
1393 if (o->type == FIO_OPT_DEPRECATED || o->type == FIO_OPT_UNSUPPORTED ||
1394 o->type == FIO_OPT_SOFT_DEPRECATED)
9f988e2e 1395 return;
bbcacb72
JA
1396 if (o->name && !o->lname)
1397 log_err("Option %s: missing long option name\n", o->name);
9f988e2e
JA
1398 if (o->type == FIO_OPT_BOOL) {
1399 o->minval = 0;
1400 o->maxval = 1;
1401 }
d4fc2f04
JA
1402 if (o->type == FIO_OPT_INT) {
1403 if (!o->maxval)
1404 o->maxval = UINT_MAX;
1405 }
5fff9543
JF
1406 if (o->type == FIO_OPT_ULL) {
1407 if (!o->maxval)
1408 o->maxval = ULLONG_MAX;
1409 }
c8931876 1410 if (o->type == FIO_OPT_STR_SET && o->def && !o->no_warn_def) {
06b0be6e 1411 log_err("Option %s: string set option with"
9f988e2e
JA
1412 " default will always be true\n", o->name);
1413 }
7b504edd 1414 if (!o->cb && !o->off1)
06b0be6e 1415 log_err("Option %s: neither cb nor offset given\n", o->name);
22754746 1416 if (!o->category) {
cca5b5bc 1417 log_info("Option %s: no category defined. Setting to misc\n", o->name);
22754746 1418 o->category = FIO_OPT_C_GENERAL;
ffd7821f 1419 o->group = FIO_OPT_G_INVALID;
22754746 1420 }
9f988e2e
JA
1421}
1422
13335ddb
JA
1423/*
1424 * Sanitize the options structure. For now it just sets min/max for bool
5b0a8880 1425 * values and whether both callback and offsets are given.
13335ddb
JA
1426 */
1427void options_init(struct fio_option *options)
1428{
4945ba12 1429 struct fio_option *o;
13335ddb 1430
a3d741fa
JA
1431 dprint(FD_PARSE, "init options\n");
1432
90265353 1433 for (o = &options[0]; o->name; o++) {
9f988e2e 1434 option_init(o);
90265353
JA
1435 if (o->inverse)
1436 o->inv_opt = find_option(options, o->inverse);
1437 }
13335ddb 1438}
7e356b2d 1439
9109883a 1440void options_mem_dupe(const struct fio_option *options, void *data)
53b5693d 1441{
9109883a 1442 const struct fio_option *o;
53b5693d
TK
1443 char **ptr;
1444
1445 dprint(FD_PARSE, "dup options\n");
1446
1447 for (o = &options[0]; o->name; o++) {
1448 if (o->type != FIO_OPT_STR_STORE)
1449 continue;
1450
1451 ptr = td_var(data, o, o->off1);
1452 if (*ptr)
1453 *ptr = strdup(*ptr);
1454 }
1455}
1456
9109883a 1457void options_free(const struct fio_option *options, void *data)
7e356b2d 1458{
9109883a 1459 const struct fio_option *o;
7e356b2d
JA
1460 char **ptr;
1461
1462 dprint(FD_PARSE, "free options\n");
1463
1464 for (o = &options[0]; o->name; o++) {
43f466e6 1465 if (o->type != FIO_OPT_STR_STORE || !o->off1 || o->no_free)
7e356b2d
JA
1466 continue;
1467
f0fdbcaf 1468 ptr = td_var(data, o, o->off1);
7e356b2d
JA
1469 if (*ptr) {
1470 free(*ptr);
1471 *ptr = NULL;
1472 }
1473 }
1474}