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, &td)) {
+ 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;
}
-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;
}
},
{
.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 mb_memory;
+ char buf[128];
+ long l;
+
+ sprintf(buf, "%lu", page_size);
+ fio_keywords[0].replace = strdup(buf);
+
+ l = sysconf(_SC_PHYS_PAGES);
+ mb_memory = l * (page_size / 1024UL);
+ sprintf(buf, "%lu", 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;
}
projects / fio.git / blobdiff