blob: 631701363f13a14989554b4cb9f1f38c7d3bee29 [file] [log] [blame]
Jens Axboecb2c86f2006-10-26 13:48:34 +02001/*
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>
Aaron Carroll88b5a392008-10-07 11:25:20 +020011#include <stdlib.h>
Yu-ju Hong83349192011-08-13 00:53:44 +020012#include <math.h>
Jens Axboecb2c86f2006-10-26 13:48:34 +020013
14#include "parse.h"
Jens Axboea3d741f2008-02-27 18:32:33 +010015#include "debug.h"
Jens Axboe9f988e22010-03-04 10:42:38 +010016#include "options.h"
Jens Axboecb2c86f2006-10-26 13:48:34 +020017
Jens Axboe9af4a242012-03-16 10:13:49 +010018static struct fio_option *__fio_options;
Jens Axboe3b8b7132008-06-10 19:46:23 +020019
Jens Axboef0857372007-03-19 13:15:23 +010020static int vp_cmp(const void *p1, const void *p2)
21{
22 const struct value_pair *vp1 = p1;
23 const struct value_pair *vp2 = p2;
24
25 return strlen(vp2->ival) - strlen(vp1->ival);
26}
27
Jens Axboece952ab2011-08-31 14:29:22 -060028static void posval_sort(struct fio_option *o, struct value_pair *vpmap)
Jens Axboef0857372007-03-19 13:15:23 +010029{
30 const struct value_pair *vp;
31 int entries;
32
33 memset(vpmap, 0, PARSE_MAX_VP * sizeof(struct value_pair));
34
35 for (entries = 0; entries < PARSE_MAX_VP; entries++) {
36 vp = &o->posval[entries];
37 if (!vp->ival || vp->ival[0] == '\0')
38 break;
39
40 memcpy(&vpmap[entries], vp, sizeof(*vp));
41 }
42
43 qsort(vpmap, entries, sizeof(struct value_pair), vp_cmp);
44}
45
Jens Axboe06b0be62011-10-04 10:31:10 +020046static void show_option_range(struct fio_option *o,
47 int (*logger)(const char *format, ...))
Jens Axboeb1ec1da2007-02-23 10:29:16 +010048{
Jens Axboe3c3ed072012-03-27 09:12:39 +020049 if (o->type == FIO_OPT_FLOAT_LIST) {
Yu-ju Hong83349192011-08-13 00:53:44 +020050 if (isnan(o->minfp) && isnan(o->maxfp))
51 return;
Jens Axboeb1ec1da2007-02-23 10:29:16 +010052
Jens Axboe06b0be62011-10-04 10:31:10 +020053 logger("%20s: min=%f", "range", o->minfp);
Yu-ju Hong83349192011-08-13 00:53:44 +020054 if (!isnan(o->maxfp))
Jens Axboe06b0be62011-10-04 10:31:10 +020055 logger(", max=%f", o->maxfp);
56 logger("\n");
Yu-ju Hong83349192011-08-13 00:53:44 +020057 } else {
58 if (!o->minval && !o->maxval)
59 return;
60
Jens Axboe06b0be62011-10-04 10:31:10 +020061 logger("%20s: min=%d", "range", o->minval);
Yu-ju Hong83349192011-08-13 00:53:44 +020062 if (o->maxval)
Jens Axboe06b0be62011-10-04 10:31:10 +020063 logger(", max=%d", o->maxval);
64 logger("\n");
Yu-ju Hong83349192011-08-13 00:53:44 +020065 }
Jens Axboeb1ec1da2007-02-23 10:29:16 +010066}
67
68static void show_option_values(struct fio_option *o)
69{
Jens Axboea3073f42010-03-05 10:06:15 +010070 int i;
Jens Axboeb1ec1da2007-02-23 10:29:16 +010071
Jens Axboea3073f42010-03-05 10:06:15 +010072 for (i = 0; i < PARSE_MAX_VP; i++) {
Jens Axboe78372132007-03-14 13:24:07 +010073 const struct value_pair *vp = &o->posval[i];
74
75 if (!vp->ival)
Jens Axboea3073f42010-03-05 10:06:15 +010076 continue;
Jens Axboeb1ec1da2007-02-23 10:29:16 +010077
Jens Axboe06b0be62011-10-04 10:31:10 +020078 log_info("%20s: %-10s", i == 0 ? "valid values" : "", vp->ival);
Jens Axboe78372132007-03-14 13:24:07 +010079 if (vp->help)
Jens Axboe06b0be62011-10-04 10:31:10 +020080 log_info(" %s", vp->help);
81 log_info("\n");
Jens Axboea3073f42010-03-05 10:06:15 +010082 }
Jens Axboeb1ec1da2007-02-23 10:29:16 +010083
84 if (i)
Jens Axboe06b0be62011-10-04 10:31:10 +020085 log_info("\n");
Jens Axboeb1ec1da2007-02-23 10:29:16 +010086}
87
Jens Axboe06b0be62011-10-04 10:31:10 +020088static void show_option_help(struct fio_option *o, int is_err)
Jens Axboed447a8c2009-07-17 22:26:15 +020089{
90 const char *typehelp[] = {
Jens Axboe07b32322010-03-05 09:48:44 +010091 "invalid",
Jens Axboed447a8c2009-07-17 22:26:15 +020092 "string (opt=bla)",
Jens Axboeae3fb6f2010-09-14 13:10:35 +020093 "string (opt=bla)",
Jens Axboed447a8c2009-07-17 22:26:15 +020094 "string with possible k/m/g postfix (opt=4k)",
95 "string with time postfix (opt=10s)",
96 "string (opt=bla)",
97 "string with dual range (opt=1k-4k,4k-8k)",
98 "integer value (opt=100)",
99 "boolean value (opt=1)",
Yu-ju Hong83349192011-08-13 00:53:44 +0200100 "list of floating point values separated by ':' (opt=5.9:7.8)",
Jens Axboed447a8c2009-07-17 22:26:15 +0200101 "no argument (opt)",
Jens Axboe07b32322010-03-05 09:48:44 +0100102 "deprecated",
Jens Axboed447a8c2009-07-17 22:26:15 +0200103 };
Jens Axboe06b0be62011-10-04 10:31:10 +0200104 int (*logger)(const char *format, ...);
105
106 if (is_err)
107 logger = log_err;
108 else
109 logger = log_info;
Jens Axboed447a8c2009-07-17 22:26:15 +0200110
111 if (o->alias)
Jens Axboe06b0be62011-10-04 10:31:10 +0200112 logger("%20s: %s\n", "alias", o->alias);
Jens Axboed447a8c2009-07-17 22:26:15 +0200113
Jens Axboe06b0be62011-10-04 10:31:10 +0200114 logger("%20s: %s\n", "type", typehelp[o->type]);
115 logger("%20s: %s\n", "default", o->def ? o->def : "no default");
Jens Axboe07b32322010-03-05 09:48:44 +0100116 if (o->prof_name)
Jens Axboe06b0be62011-10-04 10:31:10 +0200117 logger("%20s: only for profile '%s'\n", "valid", o->prof_name);
118 show_option_range(o, logger);
Jens Axboed447a8c2009-07-17 22:26:15 +0200119 show_option_values(o);
120}
121
Jens Axboecb2c86f2006-10-26 13:48:34 +0200122static unsigned long get_mult_time(char c)
123{
124 switch (c) {
Jens Axboe5ec10ea2008-03-06 15:42:00 +0100125 case 'm':
126 case 'M':
127 return 60;
128 case 'h':
129 case 'H':
130 return 60 * 60;
131 case 'd':
132 case 'D':
133 return 24 * 60 * 60;
134 default:
135 return 1;
Jens Axboecb2c86f2006-10-26 13:48:34 +0200136 }
137}
138
Jens Axboe7bb59102011-07-12 19:47:03 +0200139static unsigned long long __get_mult_bytes(const char *p, void *data,
140 int *percent)
Jens Axboecb2c86f2006-10-26 13:48:34 +0200141{
Jens Axboed6978a32009-07-18 21:04:09 +0200142 unsigned int kb_base = fio_get_kb_base(data);
Jens Axboea639f0b2009-07-18 08:25:35 +0200143 unsigned long long ret = 1;
Jens Axboe57fc29f2010-06-23 22:24:07 +0200144 unsigned int i, pow = 0, mult = kb_base;
145 char *c;
Jens Axboea639f0b2009-07-18 08:25:35 +0200146
Jens Axboe57fc29f2010-06-23 22:24:07 +0200147 if (!p)
148 return 1;
Jens Axboea639f0b2009-07-18 08:25:35 +0200149
Jens Axboe57fc29f2010-06-23 22:24:07 +0200150 c = strdup(p);
151
152 for (i = 0; i < strlen(c); i++)
153 c[i] = tolower(c[i]);
154
Jens Axboea04f1582012-03-07 10:53:29 +0100155 if (!strncmp("pib", c, 3)) {
Jens Axboe57fc29f2010-06-23 22:24:07 +0200156 pow = 5;
157 mult = 1000;
Jens Axboea04f1582012-03-07 10:53:29 +0100158 } else if (!strncmp("tib", c, 3)) {
Jens Axboe57fc29f2010-06-23 22:24:07 +0200159 pow = 4;
160 mult = 1000;
Jens Axboea04f1582012-03-07 10:53:29 +0100161 } else if (!strncmp("gib", c, 3)) {
Jens Axboe57fc29f2010-06-23 22:24:07 +0200162 pow = 3;
163 mult = 1000;
Jens Axboea04f1582012-03-07 10:53:29 +0100164 } else if (!strncmp("mib", c, 3)) {
Jens Axboe57fc29f2010-06-23 22:24:07 +0200165 pow = 2;
166 mult = 1000;
Jens Axboea04f1582012-03-07 10:53:29 +0100167 } else if (!strncmp("kib", c, 3)) {
Jens Axboe57fc29f2010-06-23 22:24:07 +0200168 pow = 1;
169 mult = 1000;
Jens Axboea04f1582012-03-07 10:53:29 +0100170 } else if (!strncmp("p", c, 1) || !strncmp("pb", c, 2))
Jens Axboe57fc29f2010-06-23 22:24:07 +0200171 pow = 5;
Jens Axboea04f1582012-03-07 10:53:29 +0100172 else if (!strncmp("t", c, 1) || !strncmp("tb", c, 2))
Jens Axboe57fc29f2010-06-23 22:24:07 +0200173 pow = 4;
Jens Axboea04f1582012-03-07 10:53:29 +0100174 else if (!strncmp("g", c, 1) || !strncmp("gb", c, 2))
Jens Axboe57fc29f2010-06-23 22:24:07 +0200175 pow = 3;
Jens Axboea04f1582012-03-07 10:53:29 +0100176 else if (!strncmp("m", c, 1) || !strncmp("mb", c, 2))
Jens Axboe57fc29f2010-06-23 22:24:07 +0200177 pow = 2;
Jens Axboea04f1582012-03-07 10:53:29 +0100178 else if (!strncmp("k", c, 1) || !strncmp("kb", c, 2))
Jens Axboe57fc29f2010-06-23 22:24:07 +0200179 pow = 1;
Jens Axboea04f1582012-03-07 10:53:29 +0100180 else if (!strncmp("%", c, 1)) {
Jens Axboe7bb59102011-07-12 19:47:03 +0200181 *percent = 1;
Jens Axboee721c572012-02-09 20:55:29 +0100182 free(c);
Jens Axboe7bb59102011-07-12 19:47:03 +0200183 return ret;
184 }
Jens Axboe57fc29f2010-06-23 22:24:07 +0200185
186 while (pow--)
187 ret *= (unsigned long long) mult;
188
189 free(c);
Jens Axboea639f0b2009-07-18 08:25:35 +0200190 return ret;
Jens Axboecb2c86f2006-10-26 13:48:34 +0200191}
192
Jens Axboe7bb59102011-07-12 19:47:03 +0200193static unsigned long long get_mult_bytes(const char *str, int len, void *data,
Jens Axboe6925dd32011-09-07 22:10:11 +0200194 int *percent)
Jens Axboe57fc29f2010-06-23 22:24:07 +0200195{
Jens Axboe55ed9632011-03-27 20:55:09 +0200196 const char *p = str;
Jens Axboeba4ddd62011-09-07 22:11:00 +0200197 int digit_seen = 0;
Jens Axboe57fc29f2010-06-23 22:24:07 +0200198
Jens Axboe1d1c1872010-07-29 10:50:05 +0200199 if (len < 2)
Jens Axboe7bb59102011-07-12 19:47:03 +0200200 return __get_mult_bytes(str, data, percent);
Jens Axboe1d1c1872010-07-29 10:50:05 +0200201
Steven Langd0c814e2011-10-28 08:37:13 +0200202 /*
203 * Go forward until we hit a non-digit, or +/- sign
204 */
Jens Axboe55ed9632011-03-27 20:55:09 +0200205 while ((p - str) <= len) {
Jens Axboeba4ddd62011-09-07 22:11:00 +0200206 if (!isdigit((int) *p) &&
207 (((*p != '+') && (*p != '-')) || digit_seen))
Jens Axboe55ed9632011-03-27 20:55:09 +0200208 break;
Jens Axboe3c703d12011-09-21 09:27:24 +0200209 digit_seen |= isdigit((int) *p);
Jens Axboe55ed9632011-03-27 20:55:09 +0200210 p++;
211 }
212
Jens Axboe7bb59102011-07-12 19:47:03 +0200213 if (!isalpha((int) *p) && (*p != '%'))
Jens Axboe57fc29f2010-06-23 22:24:07 +0200214 p = NULL;
215
Jens Axboe7bb59102011-07-12 19:47:03 +0200216 return __get_mult_bytes(p, data, percent);
Jens Axboe57fc29f2010-06-23 22:24:07 +0200217}
218
Jens Axboecb2c86f2006-10-26 13:48:34 +0200219/*
Yu-ju Hong83349192011-08-13 00:53:44 +0200220 * Convert string into a floating number. Return 1 for success and 0 otherwise.
221 */
Jens Axboecc62ea72012-02-09 21:17:06 +0100222static int str_to_float(const char *str, double *val)
Yu-ju Hong83349192011-08-13 00:53:44 +0200223{
224 return (1 == sscanf(str, "%lf", val));
225}
226
227/*
Jens Axboee1f36502006-10-27 10:54:08 +0200228 * convert string into decimal value, noting any size suffix
Jens Axboecb2c86f2006-10-26 13:48:34 +0200229 */
Jens Axboe6925dd32011-09-07 22:10:11 +0200230int str_to_decimal(const char *str, long long *val, int kilo, void *data)
Jens Axboecb2c86f2006-10-26 13:48:34 +0200231{
Jens Axboeb347f9d2009-03-09 14:15:21 +0100232 int len, base;
Jens Axboecb2c86f2006-10-26 13:48:34 +0200233
Jens Axboecb2c86f2006-10-26 13:48:34 +0200234 len = strlen(str);
Jens Axboef90eff52006-11-06 11:08:21 +0100235 if (!len)
236 return 1;
Jens Axboecb2c86f2006-10-26 13:48:34 +0200237
Jens Axboeb347f9d2009-03-09 14:15:21 +0100238 if (strstr(str, "0x") || strstr(str, "0X"))
239 base = 16;
240 else
241 base = 10;
242
243 *val = strtoll(str, NULL, base);
Jens Axboecda866c2007-01-10 16:02:32 +0100244 if (*val == LONG_MAX && errno == ERANGE)
Jens Axboecb2c86f2006-10-26 13:48:34 +0200245 return 1;
246
Jens Axboe7bb59102011-07-12 19:47:03 +0200247 if (kilo) {
248 unsigned long long mult;
249 int perc = 0;
250
Jens Axboe6925dd32011-09-07 22:10:11 +0200251 mult = get_mult_bytes(str, len, data, &perc);
Jens Axboe7bb59102011-07-12 19:47:03 +0200252 if (perc)
253 *val = -1ULL - *val;
254 else
255 *val *= mult;
256 } else
Jens Axboecb2c86f2006-10-26 13:48:34 +0200257 *val *= get_mult_time(str[len - 1]);
Jens Axboe787f7e92006-11-06 13:26:29 +0100258
Jens Axboecb2c86f2006-10-26 13:48:34 +0200259 return 0;
260}
261
Jens Axboe9af4a242012-03-16 10:13:49 +0100262int check_str_bytes(const char *p, long long *val, void *data)
Jens Axboecb2c86f2006-10-26 13:48:34 +0200263{
Jens Axboe6925dd32011-09-07 22:10:11 +0200264 return str_to_decimal(p, val, 1, data);
Jens Axboecb2c86f2006-10-26 13:48:34 +0200265}
266
Jens Axboe63f29372007-01-10 13:20:09 +0100267static int check_str_time(const char *p, long long *val)
Jens Axboecb2c86f2006-10-26 13:48:34 +0200268{
Jens Axboe6925dd32011-09-07 22:10:11 +0200269 return str_to_decimal(p, val, 0, NULL);
Jens Axboecb2c86f2006-10-26 13:48:34 +0200270}
271
272void strip_blank_front(char **p)
273{
274 char *s = *p;
275
Jens Axboe4c8e9642011-10-15 14:37:38 +0200276 if (!strlen(s))
277 return;
Jens Axboe76cd9372011-07-08 21:14:57 +0200278 while (isspace((int) *s))
Jens Axboecb2c86f2006-10-26 13:48:34 +0200279 s++;
Jens Axboe4d651da2007-03-28 19:34:53 +0200280
281 *p = s;
Jens Axboecb2c86f2006-10-26 13:48:34 +0200282}
283
284void strip_blank_end(char *p)
285{
Jens Axboe853ee7f2009-03-06 20:29:29 +0100286 char *start = p, *s;
Jens Axboecb2c86f2006-10-26 13:48:34 +0200287
Jens Axboe4c8e9642011-10-15 14:37:38 +0200288 if (!strlen(p))
289 return;
290
Jens Axboe523bfad2007-04-04 11:04:06 +0200291 s = strchr(p, ';');
292 if (s)
293 *s = '\0';
294 s = strchr(p, '#');
295 if (s)
296 *s = '\0';
297 if (s)
298 p = s;
299
Jens Axboe7f7e6e52007-07-19 14:50:05 +0200300 s = p + strlen(p);
Jens Axboe76cd9372011-07-08 21:14:57 +0200301 while ((isspace((int) *s) || iscntrl((int) *s)) && (s > start))
Jens Axboecb2c86f2006-10-26 13:48:34 +0200302 s--;
303
304 *(s + 1) = '\0';
305}
306
Jens Axboed6978a32009-07-18 21:04:09 +0200307static int check_range_bytes(const char *str, long *val, void *data)
Jens Axboecb2c86f2006-10-26 13:48:34 +0200308{
Jens Axboe57fc29f2010-06-23 22:24:07 +0200309 long long __val;
Jens Axboecb2c86f2006-10-26 13:48:34 +0200310
Jens Axboe6925dd32011-09-07 22:10:11 +0200311 if (!str_to_decimal(str, &__val, 1, data)) {
Jens Axboe57fc29f2010-06-23 22:24:07 +0200312 *val = __val;
Jens Axboecb2c86f2006-10-26 13:48:34 +0200313 return 0;
314 }
315
Jens Axboecb2c86f2006-10-26 13:48:34 +0200316 return 1;
317}
318
Jens Axboe63f29372007-01-10 13:20:09 +0100319static int check_int(const char *p, int *val)
Jens Axboecb2c86f2006-10-26 13:48:34 +0200320{
Jens Axboe787f7e92006-11-06 13:26:29 +0100321 if (!strlen(p))
322 return 1;
Jens Axboed78ee462007-08-10 14:03:20 +0200323 if (strstr(p, "0x") || strstr(p, "0X")) {
Jens Axboea61bdfd2007-07-30 09:07:04 +0200324 if (sscanf(p, "%x", val) == 1)
325 return 0;
326 } else {
327 if (sscanf(p, "%u", val) == 1)
328 return 0;
329 }
Jens Axboecb2c86f2006-10-26 13:48:34 +0200330
331 return 1;
332}
333
Jens Axboe808def72010-07-14 16:27:02 -0600334static int opt_len(const char *str)
335{
336 char *postfix;
337
338 postfix = strchr(str, ':');
339 if (!postfix)
340 return strlen(str);
341
342 return (int)(postfix - str);
343}
344
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100345#define val_store(ptr, val, off, or, data) \
Jens Axboe17abbe82006-11-06 11:23:10 +0100346 do { \
347 ptr = td_var((data), (off)); \
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100348 if ((or)) \
349 *ptr |= (val); \
350 else \
351 *ptr = (val); \
Jens Axboe17abbe82006-11-06 11:23:10 +0100352 } while (0)
353
Jens Axboef90eff52006-11-06 11:08:21 +0100354static int __handle_option(struct fio_option *o, const char *ptr, void *data,
Yu-ju Hong83349192011-08-13 00:53:44 +0200355 int first, int more, int curr)
Jens Axboee1f36502006-10-27 10:54:08 +0200356{
Jens Axboe63f29372007-01-10 13:20:09 +0100357 int il, *ilp;
Jens Axboe3c3ed072012-03-27 09:12:39 +0200358 double *flp;
Jens Axboe63f29372007-01-10 13:20:09 +0100359 long long ull, *ullp;
360 long ul1, ul2;
Yu-ju Hong83349192011-08-13 00:53:44 +0200361 double uf;
Jens Axboeb4692822006-10-27 13:43:22 +0200362 char **cp;
Jens Axboee42b01e2011-05-05 12:05:10 -0600363 int ret = 0, is_time = 0;
Jens Axboec44b1ff2011-08-30 20:43:53 -0600364 const struct value_pair *vp;
365 struct value_pair posval[PARSE_MAX_VP];
366 int i, all_skipped = 1;
Jens Axboee1f36502006-10-27 10:54:08 +0200367
Jens Axboea3d741f2008-02-27 18:32:33 +0100368 dprint(FD_PARSE, "__handle_option=%s, type=%d, ptr=%s\n", o->name,
369 o->type, ptr);
370
Jens Axboee3cedca2008-11-19 19:57:52 +0100371 if (!ptr && o->type != FIO_OPT_STR_SET && o->type != FIO_OPT_STR) {
Jens Axboe28d7c362011-10-05 20:30:24 +0200372 log_err("Option %s requires an argument\n", o->name);
Jens Axboe08e26e32006-11-21 13:15:10 +0100373 return 1;
374 }
375
Jens Axboee1f36502006-10-27 10:54:08 +0200376 switch (o->type) {
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100377 case FIO_OPT_STR:
378 case FIO_OPT_STR_MULTI: {
Jens Axboee1f36502006-10-27 10:54:08 +0200379 fio_opt_str_fn *fn = o->cb;
380
Jens Axboef0857372007-03-19 13:15:23 +0100381 posval_sort(o, posval);
382
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100383 ret = 1;
Jens Axboeb1ec1da2007-02-23 10:29:16 +0100384 for (i = 0; i < PARSE_MAX_VP; i++) {
Jens Axboef0857372007-03-19 13:15:23 +0100385 vp = &posval[i];
Jens Axboeb1ec1da2007-02-23 10:29:16 +0100386 if (!vp->ival || vp->ival[0] == '\0')
Jens Axboea3073f42010-03-05 10:06:15 +0100387 continue;
Jens Axboeae2ddba2010-03-10 12:49:03 +0100388 all_skipped = 0;
Jens Axboe808def72010-07-14 16:27:02 -0600389 if (!strncmp(vp->ival, ptr, opt_len(ptr))) {
Jens Axboeb1ec1da2007-02-23 10:29:16 +0100390 ret = 0;
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100391 if (o->roff1) {
392 if (vp->or)
393 *(unsigned int *) o->roff1 |= vp->oval;
394 else
395 *(unsigned int *) o->roff1 = vp->oval;
396 } else {
Jens Axboe02c6aad2010-03-04 13:49:11 +0100397 if (!o->off1)
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100398 continue;
399 val_store(ilp, vp->oval, o->off1, vp->or, data);
Jens Axboe02c6aad2010-03-04 13:49:11 +0100400 }
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100401 continue;
Jens Axboeb1ec1da2007-02-23 10:29:16 +0100402 }
403 }
404
Jens Axboeae2ddba2010-03-10 12:49:03 +0100405 if (ret && !all_skipped)
Jens Axboeb1ec1da2007-02-23 10:29:16 +0100406 show_option_values(o);
407 else if (fn)
408 ret = fn(data, ptr);
Jens Axboee1f36502006-10-27 10:54:08 +0200409 break;
410 }
Jens Axboee42b01e2011-05-05 12:05:10 -0600411 case FIO_OPT_STR_VAL_TIME:
412 is_time = 1;
Jens Axboef7fa2652009-03-09 14:20:20 +0100413 case FIO_OPT_INT:
Jens Axboee42b01e2011-05-05 12:05:10 -0600414 case FIO_OPT_STR_VAL: {
415 fio_opt_str_val_fn *fn = o->cb;
Jens Axboee1f36502006-10-27 10:54:08 +0200416
Jens Axboee42b01e2011-05-05 12:05:10 -0600417 if (is_time)
418 ret = check_str_time(ptr, &ull);
419 else
Jens Axboe6925dd32011-09-07 22:10:11 +0200420 ret = check_str_bytes(ptr, &ull, data);
Jens Axboee42b01e2011-05-05 12:05:10 -0600421
Jens Axboee1f36502006-10-27 10:54:08 +0200422 if (ret)
423 break;
424
Jens Axboedb8e0162007-01-10 13:41:26 +0100425 if (o->maxval && ull > o->maxval) {
Jens Axboe28d7c362011-10-05 20:30:24 +0200426 log_err("max value out of range: %lld"
Jens Axboe5ec10ea2008-03-06 15:42:00 +0100427 " (%d max)\n", ull, o->maxval);
Jens Axboedb8e0162007-01-10 13:41:26 +0100428 return 1;
429 }
430 if (o->minval && ull < o->minval) {
Jens Axboe28d7c362011-10-05 20:30:24 +0200431 log_err("min value out of range: %lld"
Jens Axboe5ec10ea2008-03-06 15:42:00 +0100432 " (%d min)\n", ull, o->minval);
Jens Axboedb8e0162007-01-10 13:41:26 +0100433 return 1;
434 }
Jens Axboee1f36502006-10-27 10:54:08 +0200435
436 if (fn)
437 ret = fn(data, &ull);
438 else {
Jens Axboee01b22b2009-06-09 15:43:25 +0200439 if (o->type == FIO_OPT_INT) {
Jens Axboe02c6aad2010-03-04 13:49:11 +0100440 if (first) {
441 if (o->roff1)
Jens Axboe7758d4f2010-03-18 16:50:31 +0100442 *(unsigned int *) o->roff1 = ull;
Jens Axboe02c6aad2010-03-04 13:49:11 +0100443 else
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100444 val_store(ilp, ull, o->off1, 0, data);
Jens Axboe02c6aad2010-03-04 13:49:11 +0100445 }
446 if (!more) {
447 if (o->roff2)
Jens Axboe7758d4f2010-03-18 16:50:31 +0100448 *(unsigned int *) o->roff2 = ull;
Jens Axboe02c6aad2010-03-04 13:49:11 +0100449 else if (o->off2)
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100450 val_store(ilp, ull, o->off2, 0, data);
Jens Axboe02c6aad2010-03-04 13:49:11 +0100451 }
Jens Axboe75e6f362006-11-03 08:17:09 +0100452 } else {
Jens Axboe02c6aad2010-03-04 13:49:11 +0100453 if (first) {
454 if (o->roff1)
455 *(unsigned long long *) o->roff1 = ull;
456 else
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100457 val_store(ullp, ull, o->off1, 0, data);
Jens Axboe02c6aad2010-03-04 13:49:11 +0100458 }
459 if (!more) {
460 if (o->roff2)
461 *(unsigned long long *) o->roff2 = ull;
462 else if (o->off2)
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100463 val_store(ullp, ull, o->off2, 0, data);
Jens Axboe02c6aad2010-03-04 13:49:11 +0100464 }
Jens Axboe75e6f362006-11-03 08:17:09 +0100465 }
Jens Axboee1f36502006-10-27 10:54:08 +0200466 }
467 break;
468 }
Yu-ju Hong83349192011-08-13 00:53:44 +0200469 case FIO_OPT_FLOAT_LIST: {
470
471 if (first) {
472 ul2 = 1;
473 ilp = td_var(data, o->off2);
474 *ilp = ul2;
475 }
476 if (curr >= o->maxlen) {
Jens Axboe28d7c362011-10-05 20:30:24 +0200477 log_err("the list exceeding max length %d\n",
Yu-ju Hong83349192011-08-13 00:53:44 +0200478 o->maxlen);
479 return 1;
480 }
Jens Axboe3c3ed072012-03-27 09:12:39 +0200481 if (!str_to_float(ptr, &uf)) {
Jens Axboe28d7c362011-10-05 20:30:24 +0200482 log_err("not a floating point value: %s\n", ptr);
Yu-ju Hong83349192011-08-13 00:53:44 +0200483 return 1;
484 }
485 if (!isnan(o->maxfp) && uf > o->maxfp) {
Jens Axboe28d7c362011-10-05 20:30:24 +0200486 log_err("value out of range: %f"
Yu-ju Hong83349192011-08-13 00:53:44 +0200487 " (range max: %f)\n", uf, o->maxfp);
488 return 1;
489 }
490 if (!isnan(o->minfp) && uf < o->minfp) {
Jens Axboe28d7c362011-10-05 20:30:24 +0200491 log_err("value out of range: %f"
Yu-ju Hong83349192011-08-13 00:53:44 +0200492 " (range min: %f)\n", uf, o->minfp);
493 return 1;
494 }
495
496 flp = td_var(data, o->off1);
497 flp[curr] = uf;
498
499 break;
500 }
Jens Axboeaf52b342007-03-13 10:07:47 +0100501 case FIO_OPT_STR_STORE: {
502 fio_opt_str_fn *fn = o->cb;
503
Steven Lang184b4092011-11-16 10:33:51 +0100504 if (o->roff1 || o->off1) {
505 if (o->roff1)
506 cp = (char **) o->roff1;
507 else if (o->off1)
508 cp = td_var(data, o->off1);
Jens Axboece952ab2011-08-31 14:29:22 -0600509
Steven Lang184b4092011-11-16 10:33:51 +0100510 *cp = strdup(ptr);
511 } else {
512 cp = NULL;
Jens Axboe1c964ce2011-08-31 16:45:03 -0600513 }
Jens Axboe02c6aad2010-03-04 13:49:11 +0100514
Steven Lang184b4092011-11-16 10:33:51 +0100515 if (fn)
516 ret = fn(data, ptr);
517 else if (o->posval[0].ival) {
518 posval_sort(o, posval);
Jens Axboec44b1ff2011-08-30 20:43:53 -0600519
Steven Lang184b4092011-11-16 10:33:51 +0100520 ret = 1;
521 for (i = 0; i < PARSE_MAX_VP; i++) {
522 vp = &posval[i];
523 if (!vp->ival || vp->ival[0] == '\0')
524 continue;
525 all_skipped = 0;
526 if (!strncmp(vp->ival, ptr, opt_len(ptr))) {
527 char *rest;
528
529 ret = 0;
530 if (vp->cb)
531 fn = vp->cb;
532 rest = strstr(*cp ?: ptr, ":");
533 if (rest) {
534 if (*cp)
535 *rest = '\0';
536 ptr = rest + 1;
537 } else
538 ptr = NULL;
539 break;
540 }
Jens Axboeaf52b342007-03-13 10:07:47 +0100541 }
542 }
Jens Axboec44b1ff2011-08-30 20:43:53 -0600543
Steven Lang184b4092011-11-16 10:33:51 +0100544 if (!all_skipped) {
545 if (ret && !*cp)
546 show_option_values(o);
547 else if (ret && *cp)
548 ret = 0;
549 else if (fn && ptr)
550 ret = fn(data, ptr);
551 }
Jens Axboec44b1ff2011-08-30 20:43:53 -0600552
Jens Axboee1f36502006-10-27 10:54:08 +0200553 break;
Jens Axboeaf52b342007-03-13 10:07:47 +0100554 }
Jens Axboee1f36502006-10-27 10:54:08 +0200555 case FIO_OPT_RANGE: {
Jens Axboeb765a372006-10-27 15:00:16 +0200556 char tmp[128];
Jens Axboee1f36502006-10-27 10:54:08 +0200557 char *p1, *p2;
558
Jens Axboe0bbab0e2006-11-02 09:18:36 +0100559 strncpy(tmp, ptr, sizeof(tmp) - 1);
Jens Axboeb765a372006-10-27 15:00:16 +0200560
Dave Engberg31d23f42011-07-23 21:07:13 +0200561 /* Handle bsrange with separate read,write values: */
562 p1 = strchr(tmp, ',');
563 if (p1)
564 *p1 = '\0';
565
Jens Axboeb765a372006-10-27 15:00:16 +0200566 p1 = strchr(tmp, '-');
Jens Axboee1f36502006-10-27 10:54:08 +0200567 if (!p1) {
Jens Axboe0c9baf92007-01-11 15:59:26 +0100568 p1 = strchr(tmp, ':');
569 if (!p1) {
570 ret = 1;
571 break;
572 }
Jens Axboee1f36502006-10-27 10:54:08 +0200573 }
574
575 p2 = p1 + 1;
576 *p1 = '\0';
Jens Axboeb765a372006-10-27 15:00:16 +0200577 p1 = tmp;
Jens Axboee1f36502006-10-27 10:54:08 +0200578
579 ret = 1;
Jens Axboed6978a32009-07-18 21:04:09 +0200580 if (!check_range_bytes(p1, &ul1, data) &&
581 !check_range_bytes(p2, &ul2, data)) {
Jens Axboee1f36502006-10-27 10:54:08 +0200582 ret = 0;
Jens Axboee1f36502006-10-27 10:54:08 +0200583 if (ul1 > ul2) {
Jens Axboef90eff52006-11-06 11:08:21 +0100584 unsigned long foo = ul1;
585
586 ul1 = ul2;
587 ul2 = foo;
588 }
589
590 if (first) {
Jens Axboe02c6aad2010-03-04 13:49:11 +0100591 if (o->roff1)
Jens Axboe7758d4f2010-03-18 16:50:31 +0100592 *(unsigned int *) o->roff1 = ul1;
Jens Axboe02c6aad2010-03-04 13:49:11 +0100593 else
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100594 val_store(ilp, ul1, o->off1, 0, data);
Jens Axboe02c6aad2010-03-04 13:49:11 +0100595 if (o->roff2)
Jens Axboe7758d4f2010-03-18 16:50:31 +0100596 *(unsigned int *) o->roff2 = ul2;
Jens Axboe02c6aad2010-03-04 13:49:11 +0100597 else
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100598 val_store(ilp, ul2, o->off2, 0, data);
Jens Axboee1f36502006-10-27 10:54:08 +0200599 }
Jens Axboe02c6aad2010-03-04 13:49:11 +0100600 if (o->roff3 && o->roff4) {
Jens Axboe7758d4f2010-03-18 16:50:31 +0100601 *(unsigned int *) o->roff3 = ul1;
602 *(unsigned int *) o->roff4 = ul2;
Jens Axboe02c6aad2010-03-04 13:49:11 +0100603 } else if (o->off3 && o->off4) {
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100604 val_store(ilp, ul1, o->off3, 0, data);
605 val_store(ilp, ul2, o->off4, 0, data);
Jens Axboe17abbe82006-11-06 11:23:10 +0100606 }
607 }
608
Jens Axboee1f36502006-10-27 10:54:08 +0200609 break;
610 }
Jens Axboe74ba1802011-07-15 09:09:15 +0200611 case FIO_OPT_BOOL:
612 case FIO_OPT_STR_SET: {
Jens Axboee1f36502006-10-27 10:54:08 +0200613 fio_opt_int_fn *fn = o->cb;
614
Jens Axboe74ba1802011-07-15 09:09:15 +0200615 if (ptr)
616 ret = check_int(ptr, &il);
617 else if (o->type == FIO_OPT_BOOL)
618 ret = 1;
619 else
620 il = 1;
621
Jens Axboee1f36502006-10-27 10:54:08 +0200622 if (ret)
623 break;
624
Jens Axboedb8e0162007-01-10 13:41:26 +0100625 if (o->maxval && il > (int) o->maxval) {
Jens Axboe28d7c362011-10-05 20:30:24 +0200626 log_err("max value out of range: %d (%d max)\n",
Jens Axboe5ec10ea2008-03-06 15:42:00 +0100627 il, o->maxval);
Jens Axboedb8e0162007-01-10 13:41:26 +0100628 return 1;
629 }
630 if (o->minval && il < o->minval) {
Jens Axboe28d7c362011-10-05 20:30:24 +0200631 log_err("min value out of range: %d (%d min)\n",
Jens Axboe5ec10ea2008-03-06 15:42:00 +0100632 il, o->minval);
Jens Axboedb8e0162007-01-10 13:41:26 +0100633 return 1;
634 }
Jens Axboee1f36502006-10-27 10:54:08 +0200635
Jens Axboe76a43db2007-01-11 13:24:44 +0100636 if (o->neg)
637 il = !il;
638
Jens Axboee1f36502006-10-27 10:54:08 +0200639 if (fn)
640 ret = fn(data, &il);
641 else {
Jens Axboe02c6aad2010-03-04 13:49:11 +0100642 if (first) {
643 if (o->roff1)
644 *(unsigned int *)o->roff1 = il;
645 else
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100646 val_store(ilp, il, o->off1, 0, data);
Jens Axboe02c6aad2010-03-04 13:49:11 +0100647 }
648 if (!more) {
649 if (o->roff2)
650 *(unsigned int *) o->roff2 = il;
651 else if (o->off2)
Jens Axboe5f6ddf12010-03-09 20:40:44 +0100652 val_store(ilp, il, o->off2, 0, data);
Jens Axboe02c6aad2010-03-04 13:49:11 +0100653 }
Jens Axboee1f36502006-10-27 10:54:08 +0200654 }
655 break;
656 }
Jens Axboe15ca1502008-04-07 09:26:02 +0200657 case FIO_OPT_DEPRECATED:
Jens Axboe06b0be62011-10-04 10:31:10 +0200658 log_info("Option %s is deprecated\n", o->name);
Jens Axboe15ca1502008-04-07 09:26:02 +0200659 break;
Jens Axboee1f36502006-10-27 10:54:08 +0200660 default:
Jens Axboe06b0be62011-10-04 10:31:10 +0200661 log_err("Bad option type %u\n", o->type);
Jens Axboee1f36502006-10-27 10:54:08 +0200662 ret = 1;
663 }
664
Jens Axboe70a4c0c2009-07-01 09:24:05 +0200665 if (ret)
666 return ret;
667
Jens Axboed447a8c2009-07-17 22:26:15 +0200668 if (o->verify) {
Jens Axboe70a4c0c2009-07-01 09:24:05 +0200669 ret = o->verify(o, data);
Jens Axboed447a8c2009-07-17 22:26:15 +0200670 if (ret) {
Jens Axboe28d7c362011-10-05 20:30:24 +0200671 log_err("Correct format for offending option\n");
672 log_err("%20s: %s\n", o->name, o->help);
Jens Axboe06b0be62011-10-04 10:31:10 +0200673 show_option_help(o, 1);
Jens Axboed447a8c2009-07-17 22:26:15 +0200674 }
675 }
Jens Axboe70a4c0c2009-07-01 09:24:05 +0200676
Jens Axboee1f36502006-10-27 10:54:08 +0200677 return ret;
678}
679
Jens Axboe7c8f1a52009-06-09 12:28:57 +0200680static int handle_option(struct fio_option *o, const char *__ptr, void *data)
Jens Axboef90eff52006-11-06 11:08:21 +0100681{
Jens Axboeb62bdf22010-03-10 12:36:17 +0100682 char *o_ptr, *ptr, *ptr2;
683 int ret, done;
Jens Axboef90eff52006-11-06 11:08:21 +0100684
Jens Axboe7c8f1a52009-06-09 12:28:57 +0200685 dprint(FD_PARSE, "handle_option=%s, ptr=%s\n", o->name, __ptr);
686
Jens Axboeb62bdf22010-03-10 12:36:17 +0100687 o_ptr = ptr = NULL;
Jens Axboe7c8f1a52009-06-09 12:28:57 +0200688 if (__ptr)
Jens Axboeb62bdf22010-03-10 12:36:17 +0100689 o_ptr = ptr = strdup(__ptr);
Jens Axboea3d741f2008-02-27 18:32:33 +0100690
Jens Axboef90eff52006-11-06 11:08:21 +0100691 /*
Jens Axboeb62bdf22010-03-10 12:36:17 +0100692 * See if we have another set of parameters, hidden after a comma.
693 * Do this before parsing this round, to check if we should
Jens Axboe787f7e92006-11-06 13:26:29 +0100694 * copy set 1 options to set 2.
Jens Axboef90eff52006-11-06 11:08:21 +0100695 */
Jens Axboeb62bdf22010-03-10 12:36:17 +0100696 done = 0;
697 ret = 1;
698 do {
699 int __ret;
700
701 ptr2 = NULL;
702 if (ptr &&
703 (o->type != FIO_OPT_STR_STORE) &&
Yu-ju Hong83349192011-08-13 00:53:44 +0200704 (o->type != FIO_OPT_STR) &&
705 (o->type != FIO_OPT_FLOAT_LIST)) {
Jens Axboeb62bdf22010-03-10 12:36:17 +0100706 ptr2 = strchr(ptr, ',');
707 if (ptr2 && *(ptr2 + 1) == '\0')
708 *ptr2 = '\0';
709 if (o->type != FIO_OPT_STR_MULTI) {
710 if (!ptr2)
711 ptr2 = strchr(ptr, ':');
712 if (!ptr2)
713 ptr2 = strchr(ptr, '-');
714 }
Yu-ju Hong83349192011-08-13 00:53:44 +0200715 } else if (ptr && o->type == FIO_OPT_FLOAT_LIST) {
716 ptr2 = strchr(ptr, ':');
Jens Axboeb62bdf22010-03-10 12:36:17 +0100717 }
718
719 /*
720 * Don't return early if parsing the first option fails - if
721 * we are doing multiple arguments, we can allow the first one
722 * being empty.
723 */
Yu-ju Hong83349192011-08-13 00:53:44 +0200724 __ret = __handle_option(o, ptr, data, !done, !!ptr2, done);
Jens Axboeb62bdf22010-03-10 12:36:17 +0100725 if (ret)
726 ret = __ret;
727
Jens Axboe0c9baf92007-01-11 15:59:26 +0100728 if (!ptr2)
Jens Axboeb62bdf22010-03-10 12:36:17 +0100729 break;
Jens Axboe787f7e92006-11-06 13:26:29 +0100730
Jens Axboeb62bdf22010-03-10 12:36:17 +0100731 ptr = ptr2 + 1;
732 done++;
733 } while (1);
Jens Axboe787f7e92006-11-06 13:26:29 +0100734
Jens Axboeb62bdf22010-03-10 12:36:17 +0100735 if (o_ptr)
736 free(o_ptr);
737 return ret;
Jens Axboef90eff52006-11-06 11:08:21 +0100738}
739
Steven Langde890a12011-11-09 14:03:34 +0100740static struct fio_option *get_option(char *opt,
Jens Axboe07b32322010-03-05 09:48:44 +0100741 struct fio_option *options, char **post)
Jens Axboe3b8b7132008-06-10 19:46:23 +0200742{
743 struct fio_option *o;
744 char *ret;
745
746 ret = strchr(opt, '=');
747 if (ret) {
748 *post = ret;
749 *ret = '\0';
Steven Langde890a12011-11-09 14:03:34 +0100750 ret = opt;
Jens Axboe3b8b7132008-06-10 19:46:23 +0200751 (*post)++;
Jens Axboe43c129b2008-12-08 14:06:42 +0100752 strip_blank_end(ret);
Jens Axboe07b32322010-03-05 09:48:44 +0100753 o = find_option(options, ret);
Jens Axboe3b8b7132008-06-10 19:46:23 +0200754 } else {
Jens Axboe07b32322010-03-05 09:48:44 +0100755 o = find_option(options, opt);
Jens Axboe3b8b7132008-06-10 19:46:23 +0200756 *post = NULL;
757 }
758
759 return o;
760}
761
762static int opt_cmp(const void *p1, const void *p2)
763{
Steven Langde890a12011-11-09 14:03:34 +0100764 struct fio_option *o;
765 char *s, *foo;
Jens Axboe8cdabc12008-11-19 12:31:43 +0100766 int prio1, prio2;
Jens Axboe3b8b7132008-06-10 19:46:23 +0200767
Jens Axboe8cdabc12008-11-19 12:31:43 +0100768 prio1 = prio2 = 0;
Jens Axboe3b8b7132008-06-10 19:46:23 +0200769
Steven Langde890a12011-11-09 14:03:34 +0100770 if (*(char **)p1) {
771 s = strdup(*((char **) p1));
Jens Axboe9af4a242012-03-16 10:13:49 +0100772 o = get_option(s, __fio_options, &foo);
Steven Langde890a12011-11-09 14:03:34 +0100773 if (o)
774 prio1 = o->prio;
775 free(s);
776 }
777 if (*(char **)p2) {
778 s = strdup(*((char **) p2));
Jens Axboe9af4a242012-03-16 10:13:49 +0100779 o = get_option(s, __fio_options, &foo);
Steven Langde890a12011-11-09 14:03:34 +0100780 if (o)
781 prio2 = o->prio;
782 free(s);
783 }
784
Jens Axboe8cdabc12008-11-19 12:31:43 +0100785 return prio2 - prio1;
Jens Axboe3b8b7132008-06-10 19:46:23 +0200786}
787
788void sort_options(char **opts, struct fio_option *options, int num_opts)
789{
Jens Axboe9af4a242012-03-16 10:13:49 +0100790 __fio_options = options;
Jens Axboe3b8b7132008-06-10 19:46:23 +0200791 qsort(opts, num_opts, sizeof(char *), opt_cmp);
Jens Axboe9af4a242012-03-16 10:13:49 +0100792 __fio_options = NULL;
Jens Axboe3b8b7132008-06-10 19:46:23 +0200793}
794
Jens Axboeb4692822006-10-27 13:43:22 +0200795int parse_cmd_option(const char *opt, const char *val,
Jens Axboe07b32322010-03-05 09:48:44 +0100796 struct fio_option *options, void *data)
Jens Axboeb4692822006-10-27 13:43:22 +0200797{
798 struct fio_option *o;
799
Jens Axboe07b32322010-03-05 09:48:44 +0100800 o = find_option(options, opt);
Jens Axboeb4692822006-10-27 13:43:22 +0200801 if (!o) {
Jens Axboe06b0be62011-10-04 10:31:10 +0200802 log_err("Bad option <%s>\n", opt);
Jens Axboeb4692822006-10-27 13:43:22 +0200803 return 1;
804 }
805
Jens Axboeb1508cf2006-11-02 09:12:40 +0100806 if (!handle_option(o, val, data))
807 return 0;
808
Jens Axboe06b0be62011-10-04 10:31:10 +0200809 log_err("fio: failed parsing %s=%s\n", opt, val);
Jens Axboeb1508cf2006-11-02 09:12:40 +0100810 return 1;
Jens Axboeb4692822006-10-27 13:43:22 +0200811}
812
Steven Langde890a12011-11-09 14:03:34 +0100813int parse_option(char *opt, const char *input,
814 struct fio_option *options, struct fio_option **o, void *data)
Jens Axboee1f36502006-10-27 10:54:08 +0200815{
Steven Langd0c814e2011-10-28 08:37:13 +0200816 char *post;
Jens Axboee1f36502006-10-27 10:54:08 +0200817
Steven Langd0c814e2011-10-28 08:37:13 +0200818 if (!opt) {
819 log_err("fio: failed parsing %s\n", input);
Steven Langde890a12011-11-09 14:03:34 +0100820 *o = NULL;
Jens Axboe38789b52010-03-03 09:23:20 +0100821 return 1;
Steven Langd0c814e2011-10-28 08:37:13 +0200822 }
Jens Axboee1f36502006-10-27 10:54:08 +0200823
Steven Langde890a12011-11-09 14:03:34 +0100824 *o = get_option(opt, options, &post);
825 if (!*o) {
826 if (post) {
827 int len = strlen(opt);
828 if (opt + len + 1 != post)
829 memmove(opt + len + 1, post, strlen(post));
830 opt[len] = '=';
831 }
Jens Axboee1f36502006-10-27 10:54:08 +0200832 return 1;
833 }
834
Jens Axboe90265352012-03-19 20:29:44 +0100835 if (!handle_option(*o, post, data))
Jens Axboeb1508cf2006-11-02 09:12:40 +0100836 return 0;
837
Steven Langd0c814e2011-10-28 08:37:13 +0200838 log_err("fio: failed parsing %s\n", input);
Jens Axboeb1508cf2006-11-02 09:12:40 +0100839 return 1;
Jens Axboee1f36502006-10-27 10:54:08 +0200840}
Jens Axboefd28ca42007-01-09 21:20:13 +0100841
Jens Axboe0e9f7fa2007-03-01 14:05:30 +0100842/*
843 * Option match, levenshtein distance. Handy for not quite remembering what
844 * the option name is.
845 */
846static int string_distance(const char *s1, const char *s2)
847{
848 unsigned int s1_len = strlen(s1);
849 unsigned int s2_len = strlen(s2);
850 unsigned int *p, *q, *r;
851 unsigned int i, j;
852
853 p = malloc(sizeof(unsigned int) * (s2_len + 1));
854 q = malloc(sizeof(unsigned int) * (s2_len + 1));
855
856 p[0] = 0;
857 for (i = 1; i <= s2_len; i++)
858 p[i] = p[i - 1] + 1;
859
860 for (i = 1; i <= s1_len; i++) {
861 q[0] = p[0] + 1;
862 for (j = 1; j <= s2_len; j++) {
863 unsigned int sub = p[j - 1];
864
865 if (s1[i - 1] != s2[j - 1])
866 sub++;
867
868 q[j] = min(p[j] + 1, min(q[j - 1] + 1, sub));
869 }
870 r = p;
871 p = q;
872 q = r;
873 }
874
875 i = p[s2_len];
876 free(p);
877 free(q);
878 return i;
879}
880
Jens Axboeafdf9352007-07-31 16:14:34 +0200881static struct fio_option *find_child(struct fio_option *options,
882 struct fio_option *o)
883{
884 struct fio_option *__o;
885
Jens Axboefdf28742007-07-31 23:06:09 +0200886 for (__o = options + 1; __o->name; __o++)
887 if (__o->parent && !strcmp(__o->parent, o->name))
Jens Axboeafdf9352007-07-31 16:14:34 +0200888 return __o;
889
890 return NULL;
891}
892
Jens Axboe323d9112008-03-01 15:12:14 +0100893static void __print_option(struct fio_option *o, struct fio_option *org,
894 int level)
Jens Axboeafdf9352007-07-31 16:14:34 +0200895{
896 char name[256], *p;
Jens Axboe323d9112008-03-01 15:12:14 +0100897 int depth;
Jens Axboeafdf9352007-07-31 16:14:34 +0200898
899 if (!o)
900 return;
Jens Axboeef9aff52007-07-31 22:56:53 +0200901 if (!org)
902 org = o;
Jens Axboe5ec10ea2008-03-06 15:42:00 +0100903
Jens Axboeafdf9352007-07-31 16:14:34 +0200904 p = name;
Jens Axboe323d9112008-03-01 15:12:14 +0100905 depth = level;
906 while (depth--)
907 p += sprintf(p, "%s", " ");
Jens Axboeafdf9352007-07-31 16:14:34 +0200908
909 sprintf(p, "%s", o->name);
910
Jens Axboe28d7c362011-10-05 20:30:24 +0200911 log_info("%-24s: %s\n", name, o->help);
Jens Axboe323d9112008-03-01 15:12:14 +0100912}
913
914static void print_option(struct fio_option *o)
915{
916 struct fio_option *parent;
917 struct fio_option *__o;
918 unsigned int printed;
919 unsigned int level;
920
921 __print_option(o, NULL, 0);
922 parent = o;
923 level = 0;
924 do {
925 level++;
926 printed = 0;
927
928 while ((__o = find_child(o, parent)) != NULL) {
929 __print_option(__o, o, level);
930 o = __o;
931 printed++;
932 }
933
934 parent = o;
935 } while (printed);
Jens Axboeafdf9352007-07-31 16:14:34 +0200936}
937
Jens Axboe07b32322010-03-05 09:48:44 +0100938int show_cmd_help(struct fio_option *options, const char *name)
Jens Axboe0e9f7fa2007-03-01 14:05:30 +0100939{
940 struct fio_option *o, *closest;
Jens Axboed091d092010-04-01 19:56:23 +0200941 unsigned int best_dist = -1U;
Jens Axboe29fc6af2007-01-09 21:22:02 +0100942 int found = 0;
Jens Axboe320beef2007-03-01 10:44:12 +0100943 int show_all = 0;
944
945 if (!name || !strcmp(name, "all"))
946 show_all = 1;
Jens Axboefd28ca42007-01-09 21:20:13 +0100947
Jens Axboe0e9f7fa2007-03-01 14:05:30 +0100948 closest = NULL;
949 best_dist = -1;
Jens Axboe4945ba12007-01-11 14:36:56 +0100950 for (o = &options[0]; o->name; o++) {
Jens Axboe320beef2007-03-01 10:44:12 +0100951 int match = 0;
952
Jens Axboe15ca1502008-04-07 09:26:02 +0200953 if (o->type == FIO_OPT_DEPRECATED)
954 continue;
Jens Axboe07b32322010-03-05 09:48:44 +0100955 if (!exec_profile && o->prof_name)
956 continue;
Jens Axboe15ca1502008-04-07 09:26:02 +0200957
Jens Axboe0e9f7fa2007-03-01 14:05:30 +0100958 if (name) {
Jens Axboe7f9348f2007-03-15 14:09:28 +0100959 if (!strcmp(name, o->name) ||
960 (o->alias && !strcmp(name, o->alias)))
Jens Axboe0e9f7fa2007-03-01 14:05:30 +0100961 match = 1;
962 else {
963 unsigned int dist;
964
965 dist = string_distance(name, o->name);
966 if (dist < best_dist) {
967 best_dist = dist;
968 closest = o;
969 }
970 }
971 }
Jens Axboefd28ca42007-01-09 21:20:13 +0100972
973 if (show_all || match) {
Jens Axboe29fc6af2007-01-09 21:22:02 +0100974 found = 1;
Jens Axboec167ded2007-03-14 13:02:53 +0100975 if (match)
Jens Axboe28d7c362011-10-05 20:30:24 +0200976 log_info("%20s: %s\n", o->name, o->help);
Jens Axboec167ded2007-03-14 13:02:53 +0100977 if (show_all) {
Jens Axboeafdf9352007-07-31 16:14:34 +0200978 if (!o->parent)
Jens Axboe323d9112008-03-01 15:12:14 +0100979 print_option(o);
Jens Axboe4945ba12007-01-11 14:36:56 +0100980 continue;
Jens Axboec167ded2007-03-14 13:02:53 +0100981 }
Jens Axboefd28ca42007-01-09 21:20:13 +0100982 }
983
Jens Axboe70df2f12007-01-11 14:04:47 +0100984 if (!match)
985 continue;
986
Jens Axboe06b0be62011-10-04 10:31:10 +0200987 show_option_help(o, 0);
Jens Axboefd28ca42007-01-09 21:20:13 +0100988 }
989
Jens Axboe29fc6af2007-01-09 21:22:02 +0100990 if (found)
991 return 0;
Jens Axboefd28ca42007-01-09 21:20:13 +0100992
Jens Axboe28d7c362011-10-05 20:30:24 +0200993 log_err("No such command: %s", name);
Jens Axboed091d092010-04-01 19:56:23 +0200994
995 /*
996 * Only print an appropriately close option, one where the edit
997 * distance isn't too big. Otherwise we get crazy matches.
998 */
999 if (closest && best_dist < 3) {
Jens Axboe28d7c362011-10-05 20:30:24 +02001000 log_info(" - showing closest match\n");
1001 log_info("%20s: %s\n", closest->name, closest->help);
Jens Axboe06b0be62011-10-04 10:31:10 +02001002 show_option_help(closest, 0);
Jens Axboe0e9f7fa2007-03-01 14:05:30 +01001003 } else
Jens Axboe28d7c362011-10-05 20:30:24 +02001004 log_info("\n");
Jens Axboe0e9f7fa2007-03-01 14:05:30 +01001005
Jens Axboe29fc6af2007-01-09 21:22:02 +01001006 return 1;
Jens Axboefd28ca42007-01-09 21:20:13 +01001007}
Jens Axboeee738492007-01-10 11:23:16 +01001008
Jens Axboe13335dd2007-01-10 13:14:02 +01001009/*
1010 * Handle parsing of default parameters.
1011 */
Jens Axboeee738492007-01-10 11:23:16 +01001012void fill_default_options(void *data, struct fio_option *options)
1013{
Jens Axboe4945ba12007-01-11 14:36:56 +01001014 struct fio_option *o;
Jens Axboeee738492007-01-10 11:23:16 +01001015
Jens Axboea3d741f2008-02-27 18:32:33 +01001016 dprint(FD_PARSE, "filling default options\n");
1017
Jens Axboe4945ba12007-01-11 14:36:56 +01001018 for (o = &options[0]; o->name; o++)
Jens Axboeee738492007-01-10 11:23:16 +01001019 if (o->def)
1020 handle_option(o, o->def, data);
Jens Axboeee738492007-01-10 11:23:16 +01001021}
Jens Axboe13335dd2007-01-10 13:14:02 +01001022
Jens Axboe9f988e22010-03-04 10:42:38 +01001023void option_init(struct fio_option *o)
1024{
1025 if (o->type == FIO_OPT_DEPRECATED)
1026 return;
1027 if (o->type == FIO_OPT_BOOL) {
1028 o->minval = 0;
1029 o->maxval = 1;
1030 }
Yu-ju Hong83349192011-08-13 00:53:44 +02001031 if (o->type == FIO_OPT_FLOAT_LIST) {
1032 o->minfp = NAN;
1033 o->maxfp = NAN;
1034 }
Jens Axboe9f988e22010-03-04 10:42:38 +01001035 if (o->type == FIO_OPT_STR_SET && o->def) {
Jens Axboe06b0be62011-10-04 10:31:10 +02001036 log_err("Option %s: string set option with"
Jens Axboe9f988e22010-03-04 10:42:38 +01001037 " default will always be true\n", o->name);
1038 }
Jens Axboe06b0be62011-10-04 10:31:10 +02001039 if (!o->cb && (!o->off1 && !o->roff1))
1040 log_err("Option %s: neither cb nor offset given\n", o->name);
Jens Axboe5f6ddf12010-03-09 20:40:44 +01001041 if (o->type == FIO_OPT_STR || o->type == FIO_OPT_STR_STORE ||
1042 o->type == FIO_OPT_STR_MULTI)
Jens Axboe9f988e22010-03-04 10:42:38 +01001043 return;
Jens Axboee2de69d2010-03-04 14:05:48 +01001044 if (o->cb && ((o->off1 || o->off2 || o->off3 || o->off4) ||
1045 (o->roff1 || o->roff2 || o->roff3 || o->roff4))) {
Jens Axboe06b0be62011-10-04 10:31:10 +02001046 log_err("Option %s: both cb and offset given\n", o->name);
Jens Axboe9f988e22010-03-04 10:42:38 +01001047 }
Jens Axboe0a074fe2012-03-16 18:58:39 +01001048 if (!o->category) {
1049 log_info("Options %s: no category defined. Setting to misc\n", o->name);
Jens Axboee8b0e952012-03-19 14:37:08 +01001050 o->category = FIO_OPT_C_GENERAL;
Jens Axboe0a074fe2012-03-16 18:58:39 +01001051 }
Jens Axboe9f988e22010-03-04 10:42:38 +01001052}
1053
Jens Axboe13335dd2007-01-10 13:14:02 +01001054/*
1055 * Sanitize the options structure. For now it just sets min/max for bool
Jens Axboe5b0a8882007-01-11 14:40:27 +01001056 * values and whether both callback and offsets are given.
Jens Axboe13335dd2007-01-10 13:14:02 +01001057 */
1058void options_init(struct fio_option *options)
1059{
Jens Axboe4945ba12007-01-11 14:36:56 +01001060 struct fio_option *o;
Jens Axboe13335dd2007-01-10 13:14:02 +01001061
Jens Axboea3d741f2008-02-27 18:32:33 +01001062 dprint(FD_PARSE, "init options\n");
1063
Jens Axboe90265352012-03-19 20:29:44 +01001064 for (o = &options[0]; o->name; o++) {
Jens Axboe9f988e22010-03-04 10:42:38 +01001065 option_init(o);
Jens Axboe90265352012-03-19 20:29:44 +01001066 if (o->inverse)
1067 o->inv_opt = find_option(options, o->inverse);
1068 }
Jens Axboe13335dd2007-01-10 13:14:02 +01001069}
Jens Axboe7e356b22011-10-14 10:55:16 +02001070
1071void options_free(struct fio_option *options, void *data)
1072{
1073 struct fio_option *o;
1074 char **ptr;
1075
1076 dprint(FD_PARSE, "free options\n");
1077
1078 for (o = &options[0]; o->name; o++) {
Steven Langde890a12011-11-09 14:03:34 +01001079 if (o->type != FIO_OPT_STR_STORE || !o->off1)
Jens Axboe7e356b22011-10-14 10:55:16 +02001080 continue;
1081
1082 ptr = td_var(data, o->off1);
1083 if (*ptr) {
1084 free(*ptr);
1085 *ptr = NULL;
1086 }
1087 }
1088}