#include "parse.h"
#include "debug.h"
#include "options.h"
+#include "optgroup.h"
#include "minmax.h"
#include "lib/ieee754.h"
+#include "lib/pow2.h"
#ifdef CONFIG_ARITHMETIC
#include "y.tab.h"
}
static void show_option_range(struct fio_option *o,
- int (*logger)(const char *format, ...))
+ size_t (*logger)(const char *format, ...))
{
if (o->type == FIO_OPT_FLOAT_LIST) {
if (o->minfp == DBL_MIN && o->maxfp == DBL_MAX)
"no argument (opt)",
"deprecated",
};
- int (*logger)(const char *format, ...);
+ size_t (*logger)(const char *format, ...);
if (is_err)
logger = log_err;
}
extern int evaluate_arithmetic_expression(const char *buffer, long long *ival,
- double *dval, double implied_units);
-
-#ifdef CONFIG_ARITHMETIC
-/*
- * These two verification functions are just to gain confidence that
- * the arithmetic processing code is always getting the same answer as the
- * original number parsing code. Once sufficiently sure that the arithmetic
- * code is always getting the right answers, these can be removed.
- */
-static void verify_exp_parser_float(const char *str, double implied_units)
-{
- long long ival;
- double dval, tmpval;
-
- if (sscanf(str, "%lf", &tmpval) != 1)
- return;
-
- if (evaluate_arithmetic_expression(str, &ival, &dval, implied_units) != 0) {
- log_info("Arithmetic failed on '%s'\n", str);
- return;
- }
- if (dval != tmpval) {
- log_info("Arithmetic failed on: '%s' got %lf, expected %lf\n",
- str, dval, tmpval);
- }
-}
-
-static void verify_exp_parser_decimal(const char *str, long long val, int kilo, int is_seconds)
-{
- int rc;
- long long ival;
- double dval;
- double implied_units = 1.0;
-
- if (is_seconds)
- implied_units = 1000000.0;
-
- rc = evaluate_arithmetic_expression(str, &ival, &dval, implied_units);
- if (!rc) {
- if (ival != val)
- log_info("Arithmetic failed on '%s', expected %lld, got %lld\n",
- str, val, ival);
- } else {
- log_info("Arithmetic failed on '%s'\n", str);
- }
-}
-#endif
+ double *dval, double implied_units,
+ int is_time);
/*
* Convert string into a floating number. Return 1 for success and 0 otherwise.
*/
-int str_to_float(const char *str, double *val)
+int str_to_float(const char *str, double *val, int is_time)
{
#ifdef CONFIG_ARITHMETIC
int rc;
double dval;
if (str[0] == '(') {
- rc = evaluate_arithmetic_expression(str, &ival, &dval, 1.0);
+ rc = evaluate_arithmetic_expression(str, &ival, &dval, 1.0, is_time);
if (!rc) {
*val = dval;
return 1;
}
- } else {
- verify_exp_parser_float(str, 1.0);
}
#endif
return 1 == sscanf(str, "%lf", val);
* convert string into decimal value, noting any size suffix
*/
int str_to_decimal(const char *str, long long *val, int kilo, void *data,
- int is_seconds)
+ int is_seconds, int is_time)
{
int len, base;
int rc = 1;
if (is_seconds)
implied_units = 1000000.0;
if (str[0] == '(')
- rc = evaluate_arithmetic_expression(str, &ival, &dval, implied_units);
+ rc = evaluate_arithmetic_expression(str, &ival, &dval, implied_units, is_time);
if (str[0] == '(' && !rc) {
if (!kilo && is_seconds)
*val = ival / 1000000LL;
*val *= mult;
} else
*val *= get_mult_time(str, len, is_seconds);
-#ifdef CONFIG_ARITHMETIC
- verify_exp_parser_decimal(str, *val, kilo, is_seconds);
-#endif
+
return 0;
}
int check_str_bytes(const char *p, long long *val, void *data)
{
- return str_to_decimal(p, val, 1, data, 0);
+ return str_to_decimal(p, val, 1, data, 0, 0);
}
int check_str_time(const char *p, long long *val, int is_seconds)
{
- return str_to_decimal(p, val, 0, NULL, is_seconds);
+ return str_to_decimal(p, val, 0, NULL, is_seconds, 1);
}
void strip_blank_front(char **p)
{
long long __val;
- if (!str_to_decimal(str, &__val, 1, data, 0)) {
+ if (!str_to_decimal(str, &__val, 1, data, 0, 0)) {
*val = __val;
return 0;
}
if (!vp->ival || vp->ival[0] == '\0')
continue;
all_skipped = 0;
+ if (!ptr)
+ break;
if (!strncmp(vp->ival, ptr, str_match_len(vp, ptr))) {
ret = 0;
if (o->off1)
fio_opt_str_val_fn *fn = o->cb;
char tmp[128], *p;
+ if (!is_time && o->is_time)
+ is_time = o->is_time;
+
+ tmp[sizeof(tmp) - 1] = '\0';
strncpy(tmp, ptr, sizeof(tmp) - 1);
p = strchr(tmp, ',');
if (p)
if (ret)
break;
+ if (o->pow2 && !is_power_of_2(ull)) {
+ log_err("%s: must be a power-of-2\n", o->name);
+ return 1;
+ }
if (o->maxval && ull > o->maxval) {
log_err("max value out of range: %llu"
o->maxlen);
return 1;
}
- if (!str_to_float(ptr, &uf)) {
+ if (!str_to_float(ptr, &uf, 0)) { /* this breaks if we ever have lists of times */
log_err("not a floating point value: %s\n", ptr);
return 1;
}
char tmp[128];
char *p1, *p2;
+ tmp[sizeof(tmp) - 1] = '\0';
strncpy(tmp, ptr, sizeof(tmp) - 1);
/* Handle bsrange with separate read,write values: */
__fio_options = NULL;
}
+static void add_to_dump_list(struct fio_option *o, struct flist_head *dump_list,
+ const char *post)
+{
+ struct print_option *p;
+
+ if (!dump_list)
+ return;
+
+ p = malloc(sizeof(*p));
+ p->name = strdup(o->name);
+ if (post)
+ p->value = strdup(post);
+ else
+ p->value = NULL;
+
+ flist_add_tail(&p->list, dump_list);
+}
+
int parse_cmd_option(const char *opt, const char *val,
- struct fio_option *options, void *data)
+ struct fio_option *options, void *data,
+ struct flist_head *dump_list)
{
struct fio_option *o;
return 1;
}
- if (!handle_option(o, val, data))
- return 0;
+ if (handle_option(o, val, data)) {
+ log_err("fio: failed parsing %s=%s\n", opt, val);
+ return 1;
+ }
- log_err("fio: failed parsing %s=%s\n", opt, val);
- return 1;
+ add_to_dump_list(o, dump_list, val);
+ return 0;
}
int parse_option(char *opt, const char *input,
struct fio_option *options, struct fio_option **o, void *data,
- int dump_cmdline)
+ struct flist_head *dump_list)
{
char *post;
return 1;
}
- if (dump_cmdline) {
- const char *delim;
-
- if (!strcmp("description", (*o)->name))
- delim = "\"";
- else
- delim = "";
-
- log_info("--%s%s", (*o)->name, post ? "" : " ");
- if (post)
- log_info("=%s%s%s ", delim, post, delim);
- }
-
+ add_to_dump_list(*o, dump_list, post);
return 0;
}
* Option match, levenshtein distance. Handy for not quite remembering what
* the option name is.
*/
-static int string_distance(const char *s1, const char *s2)
+int string_distance(const char *s1, const char *s2)
{
unsigned int s1_len = strlen(s1);
unsigned int s2_len = strlen(s2);
return i;
}
+/*
+ * Make a guess of whether the distance from 's1' is significant enough
+ * to warrant printing the guess. We set this to a 1/2 match.
+ */
+int string_distance_ok(const char *opt, int distance)
+{
+ size_t len;
+
+ len = strlen(opt);
+ len = (len + 1) / 2;
+ return distance <= len;
+}
+
static struct fio_option *find_child(struct fio_option *options,
struct fio_option *o)
{
if (o->type == FIO_OPT_STR || o->type == FIO_OPT_STR_STORE ||
o->type == FIO_OPT_STR_MULTI)
return;
- if (o->cb && (o->off1 || o->off2 || o->off3 || o->off4))
- log_err("Option %s: both cb and offset given\n", o->name);
}
/*