#include "parse.h"
#include "lib/fls.h"
-unsigned int fio_kb_base = 1024;
-
#define td_var_offset(var) ((size_t) &((struct thread_options *)0)->var)
/*
return strdup(p);
}
+static int converthexchartoint(char a)
+{
+ int base;
+
+ switch(a) {
+ case '0'...'9':
+ base = '0';
+ break;
+ case 'A'...'F':
+ base = 'A' - 10;
+ break;
+ case 'a'...'f':
+ base = 'a' - 10;
+ break;
+ default:
+ base = 0;
+ }
+ return (a - base);
+}
+
static int bs_cmp(const void *p1, const void *p2)
{
const struct bssplit *bsp1 = p1;
} else
perc = -1;
- if (str_to_decimal(fname, &val, 1)) {
+ if (str_to_decimal(fname, &val, 1, td)) {
log_err("fio: bssplit conversion failed\n");
free(td->o.bssplit);
return 1;
ret = 1;
break;
}
-
+
dprint(FD_PARSE, "set cpu allowed %d\n", icpu);
fio_cpu_set(mask, icpu);
icpu++;
return 0;
}
+/*
+ * Return next file in the string. Files are separated with ':'. If the ':'
+ * is escaped with a '\', then that ':' is part of the filename and does not
+ * indicate a new file.
+ */
+static char *get_next_file_name(char **ptr)
+{
+ char *str = *ptr;
+ char *p, *start;
+
+ if (!str || !strlen(str))
+ return NULL;
+
+ start = str;
+ do {
+ /*
+ * No colon, we are done
+ */
+ p = strchr(str, ':');
+ if (!p) {
+ *ptr = NULL;
+ break;
+ }
+
+ /*
+ * We got a colon, but it's the first character. Skip and
+ * continue
+ */
+ if (p == start) {
+ str = ++start;
+ continue;
+ }
+
+ if (*(p - 1) != '\\') {
+ *p = '\0';
+ *ptr = p + 1;
+ break;
+ }
+
+ memmove(p - 1, p, strlen(p) + 1);
+ str = p;
+ } while (1);
+
+ return start;
+}
+
static int str_filename_cb(void *data, const char *input)
{
struct thread_data *td = data;
if (!td->files_index)
td->o.nr_files = 0;
- while ((fname = strsep(&str, ":")) != NULL) {
+ while ((fname = get_next_file_name(&str)) != NULL) {
if (!strlen(fname))
break;
if (check_dir(td, fname)) {
return 0;
}
-static int str_verify_pattern_cb(void *data, unsigned int *off)
+static int str_verify_pattern_cb(void *data, const char *input)
{
struct thread_data *td = data;
- unsigned int msb;
-
- msb = __fls(*off);
- if (msb <= 8)
- td->o.verify_pattern_bytes = 1;
- else if (msb <= 16)
- td->o.verify_pattern_bytes = 2;
- else if (msb <= 24)
- td->o.verify_pattern_bytes = 3;
- else
- td->o.verify_pattern_bytes = 4;
-
- td->o.verify_pattern = *off;
+ long off;
+ int i = 0, j = 0, len, k, base = 10;
+ char* loc1, * loc2;
+
+ loc1 = strstr(input, "0x");
+ loc2 = strstr(input, "0X");
+ if (loc1 || loc2)
+ base = 16;
+ off = strtol(input, NULL, base);
+ if (off != LONG_MAX || errno != ERANGE) {
+ while (off) {
+ td->o.verify_pattern[i] = off & 0xff;
+ off >>= 8;
+ i++;
+ }
+ } else {
+ len = strlen(input);
+ k = len - 1;
+ if (base == 16) {
+ if (loc1)
+ j = loc1 - input + 2;
+ else
+ j = loc2 - input + 2;
+ } else
+ return 1;
+ if (len - j < MAX_PATTERN_SIZE * 2) {
+ while (k >= j) {
+ off = converthexchartoint(input[k--]);
+ if (k >= j)
+ off += (converthexchartoint(input[k--])
+ * 16);
+ td->o.verify_pattern[i++] = (char) off;
+ }
+ }
+ }
+ td->o.verify_pattern_bytes = i;
return 0;
}
return 1;
}
- fio_kb_base = td->o.kb_base;
return 0;
}
.oval = VERIFY_CRC7,
.help = "Use crc7 checksums for verification",
},
+ { .ival = "sha1",
+ .oval = VERIFY_SHA1,
+ .help = "Use sha1 checksums for verification",
+ },
{ .ival = "sha256",
.oval = VERIFY_SHA256,
.help = "Use sha256 checksums for verification",
},
{
.name = "verify_pattern",
- .type = FIO_OPT_INT,
+ .type = FIO_OPT_STR,
.cb = str_verify_pattern_cb,
.help = "Fill pattern for IO buffers",
.parent = "verify",
.help = "Create files when they are opened for IO",
.def = "0",
},
- {
+ {
.name = "pre_read",
.type = FIO_OPT_BOOL,
.off1 = td_var_offset(pre_read),
.help = "Continue on non-fatal errors during I/O",
.def = "0",
},
+ {
+ .name = "profile",
+ .type = FIO_OPT_STR,
+ .off1 = td_var_offset(profile),
+ .posval = {
+ { .ival = "tiobench",
+ .oval = PROFILE_TIOBENCH,
+ .help = "Perform tiobench like test",
+ },
+ },
+ .help = "Select a specific builtin performance test",
+ },
+ {
+ .name = "cgroup",
+ .type = FIO_OPT_STR_STORE,
+ .off1 = td_var_offset(cgroup),
+ .help = "Add job to cgroup of this name",
+ },
+ {
+ .name = "cgroup_weight",
+ .type = FIO_OPT_INT,
+ .off1 = td_var_offset(cgroup_weight),
+ .help = "Use given weight for cgroup",
+ .minval = 100,
+ .maxval = 1000,
+ },
+ {
+ .name = "uid",
+ .type = FIO_OPT_INT,
+ .off1 = td_var_offset(uid),
+ .help = "Run job with this user ID",
+ },
+ {
+ .name = "gid",
+ .type = FIO_OPT_INT,
+ .off1 = td_var_offset(gid),
+ .help = "Run job with this group ID",
+ },
{
.name = NULL,
},
}
}
+struct fio_keyword {
+ const char *word;
+ const char *desc;
+ char *replace;
+};
+
+static struct fio_keyword fio_keywords[] = {
+ {
+ .word = "$pagesize",
+ .desc = "Page size in the system",
+ },
+ {
+ .word = "$mb_memory",
+ .desc = "Megabytes of memory online",
+ },
+ {
+ .word = "$ncpus",
+ .desc = "Number of CPUs online in the system",
+ },
+ {
+ .word = NULL,
+ },
+};
+
+void fio_keywords_init(void)
+{
+ unsigned long long mb_memory;
+ char buf[128];
+ long l;
+
+ sprintf(buf, "%lu", page_size);
+ fio_keywords[0].replace = strdup(buf);
+
+ mb_memory = os_phys_mem() / page_size;
+ sprintf(buf, "%llu", mb_memory);
+ fio_keywords[1].replace = strdup(buf);
+
+ l = sysconf(_SC_NPROCESSORS_ONLN);
+ sprintf(buf, "%lu", l);
+ fio_keywords[2].replace = strdup(buf);
+}
+
+#define BC_APP "bc"
+
+static char *bc_calc(char *str)
+{
+ char *buf, *tmp, opt[80];
+ FILE *f;
+ int ret;
+
+ /*
+ * No math, just return string
+ */
+ if (!strchr(str, '+') && !strchr(str, '-') && !strchr(str, '*') &&
+ !strchr(str, '/'))
+ return str;
+
+ /*
+ * Split option from value, we only need to calculate the value
+ */
+ tmp = strchr(str, '=');
+ if (!tmp)
+ return str;
+
+ tmp++;
+ memset(opt, 0, sizeof(opt));
+ strncpy(opt, str, tmp - str);
+
+ buf = malloc(128);
+
+ sprintf(buf, "which %s > /dev/null", BC_APP);
+ if (system(buf)) {
+ log_err("fio: bc is needed for performing math\n");
+ free(buf);
+ return NULL;
+ }
+
+ sprintf(buf, "echo %s | %s", tmp, BC_APP);
+ f = popen(buf, "r");
+ if (!f) {
+ free(buf);
+ return NULL;
+ }
+
+ ret = fread(buf, 1, 128, f);
+ if (ret <= 0) {
+ free(buf);
+ return NULL;
+ }
+
+ buf[ret - 1] = '\0';
+ strcat(opt, buf);
+ strcpy(buf, opt);
+ pclose(f);
+ free(str);
+ return buf;
+}
+
+/*
+ * Look for reserved variable names and replace them with real values
+ */
+static char *fio_keyword_replace(char *opt)
+{
+ char *s;
+ int i;
+
+ for (i = 0; fio_keywords[i].word != NULL; i++) {
+ struct fio_keyword *kw = &fio_keywords[i];
+
+ while ((s = strstr(opt, kw->word)) != NULL) {
+ char *new = malloc(strlen(opt) + 1);
+ char *o_org = opt;
+ int olen = s - opt;
+ int len;
+
+ /*
+ * Copy part of the string before the keyword and
+ * sprintf() the replacement after it.
+ */
+ memcpy(new, opt, olen);
+ len = sprintf(new + olen, "%s", kw->replace);
+
+ /*
+ * If there's more in the original string, copy that
+ * in too
+ */
+ opt += strlen(kw->word) + olen;
+ if (strlen(opt))
+ memcpy(new + olen + len, opt, opt - o_org - 1);
+
+ /*
+ * replace opt and free the old opt
+ */
+ opt = new;
+ //free(o_org);
+
+ /*
+ * Check for potential math and invoke bc, if possible
+ */
+ opt = bc_calc(opt);
+ }
+ }
+
+ return opt;
+}
+
int fio_options_parse(struct thread_data *td, char **opts, int num_opts)
{
int i, ret;
sort_options(opts, options, num_opts);
- for (ret = 0, i = 0; i < num_opts; i++)
+ for (ret = 0, i = 0; i < num_opts; i++) {
+ opts[i] = fio_keyword_replace(opts[i]);
ret |= parse_option(opts[i], options, td);
+ }
return ret;
}
__options_mem(td, 0);
#endif
}
+
+unsigned int fio_get_kb_base(void *data)
+{
+ struct thread_data *td = data;
+ unsigned int kb_base = 0;
+
+ if (td)
+ kb_base = td->o.kb_base;
+ if (!kb_base)
+ kb_base = 1024;
+
+ return kb_base;
+}