blob: 3caaa4f2d254129cba2745db3ccdb27e85b2a28b [file] [log] [blame]
Jens Axboe214e1ec2007-03-15 10:48:13 +01001#include <stdio.h>
2#include <stdlib.h>
3#include <unistd.h>
4#include <ctype.h>
5#include <string.h>
Jens Axboe214e1ec2007-03-15 10:48:13 +01006#include <assert.h>
Jens Axboe921c7662008-03-26 09:17:55 +01007#include <libgen.h>
Jens Axboe5921e802008-05-30 15:02:38 +02008#include <fcntl.h>
9#include <sys/types.h>
10#include <sys/stat.h>
Jens Axboe214e1ec2007-03-15 10:48:13 +010011
12#include "fio.h"
Jens Axboe4f5af7b2009-06-03 08:45:40 +020013#include "verify.h"
Jens Axboe214e1ec2007-03-15 10:48:13 +010014#include "parse.h"
Jens Axboeeef32352008-06-02 13:31:26 +020015#include "lib/fls.h"
Jens Axboe9f988e22010-03-04 10:42:38 +010016#include "options.h"
Jens Axboe214e1ec2007-03-15 10:48:13 +010017
Jens Axboe5d7c5d32010-06-21 15:08:17 +020018#include "crc/crc32c.h"
19
Jens Axboe214e1ec2007-03-15 10:48:13 +010020/*
21 * Check if mmap/mmaphuge has a :/foo/bar/file at the end. If so, return that.
22 */
23static char *get_opt_postfix(const char *str)
24{
25 char *p = strstr(str, ":");
26
27 if (!p)
28 return NULL;
29
30 p++;
31 strip_blank_front(&p);
32 strip_blank_end(p);
33 return strdup(p);
34}
35
Radha Ramachandran0e92f872009-10-27 20:14:27 +010036static int converthexchartoint(char a)
37{
38 int base;
39
40 switch(a) {
41 case '0'...'9':
42 base = '0';
43 break;
44 case 'A'...'F':
45 base = 'A' - 10;
46 break;
47 case 'a'...'f':
48 base = 'a' - 10;
49 break;
50 default:
51 base = 0;
52 }
53 return (a - base);
54}
55
Jens Axboe564ca972007-12-14 12:21:19 +010056static int bs_cmp(const void *p1, const void *p2)
57{
58 const struct bssplit *bsp1 = p1;
59 const struct bssplit *bsp2 = p2;
60
61 return bsp1->perc < bsp2->perc;
62}
63
Jens Axboe720e84a2009-04-21 08:29:55 +020064static int bssplit_ddir(struct thread_data *td, int ddir, char *str)
Jens Axboe564ca972007-12-14 12:21:19 +010065{
Jens Axboe720e84a2009-04-21 08:29:55 +020066 struct bssplit *bssplit;
Jens Axboe564ca972007-12-14 12:21:19 +010067 unsigned int i, perc, perc_missing;
68 unsigned int max_bs, min_bs;
69 long long val;
Jens Axboe720e84a2009-04-21 08:29:55 +020070 char *fname;
Jens Axboe564ca972007-12-14 12:21:19 +010071
Jens Axboe720e84a2009-04-21 08:29:55 +020072 td->o.bssplit_nr[ddir] = 4;
73 bssplit = malloc(4 * sizeof(struct bssplit));
Jens Axboe564ca972007-12-14 12:21:19 +010074
75 i = 0;
76 max_bs = 0;
77 min_bs = -1;
78 while ((fname = strsep(&str, ":")) != NULL) {
79 char *perc_str;
80
81 if (!strlen(fname))
82 break;
83
84 /*
85 * grow struct buffer, if needed
86 */
Jens Axboe720e84a2009-04-21 08:29:55 +020087 if (i == td->o.bssplit_nr[ddir]) {
88 td->o.bssplit_nr[ddir] <<= 1;
89 bssplit = realloc(bssplit, td->o.bssplit_nr[ddir]
Jens Axboe5ec10ea2008-03-06 15:42:00 +010090 * sizeof(struct bssplit));
Jens Axboe564ca972007-12-14 12:21:19 +010091 }
92
93 perc_str = strstr(fname, "/");
94 if (perc_str) {
95 *perc_str = '\0';
96 perc_str++;
97 perc = atoi(perc_str);
98 if (perc > 100)
99 perc = 100;
100 else if (!perc)
101 perc = -1;
102 } else
103 perc = -1;
104
Jens Axboe6925dd32011-09-07 22:10:11 +0200105 if (str_to_decimal(fname, &val, 1, td)) {
Jens Axboe564ca972007-12-14 12:21:19 +0100106 log_err("fio: bssplit conversion failed\n");
107 free(td->o.bssplit);
108 return 1;
109 }
110
111 if (val > max_bs)
112 max_bs = val;
113 if (val < min_bs)
114 min_bs = val;
115
Jens Axboe720e84a2009-04-21 08:29:55 +0200116 bssplit[i].bs = val;
117 bssplit[i].perc = perc;
Jens Axboe564ca972007-12-14 12:21:19 +0100118 i++;
119 }
120
Jens Axboe720e84a2009-04-21 08:29:55 +0200121 td->o.bssplit_nr[ddir] = i;
Jens Axboe564ca972007-12-14 12:21:19 +0100122
123 /*
124 * Now check if the percentages add up, and how much is missing
125 */
126 perc = perc_missing = 0;
Jens Axboe720e84a2009-04-21 08:29:55 +0200127 for (i = 0; i < td->o.bssplit_nr[ddir]; i++) {
128 struct bssplit *bsp = &bssplit[i];
Jens Axboe564ca972007-12-14 12:21:19 +0100129
130 if (bsp->perc == (unsigned char) -1)
131 perc_missing++;
132 else
133 perc += bsp->perc;
134 }
135
136 if (perc > 100) {
137 log_err("fio: bssplit percentages add to more than 100%%\n");
Jens Axboe720e84a2009-04-21 08:29:55 +0200138 free(bssplit);
Jens Axboe564ca972007-12-14 12:21:19 +0100139 return 1;
140 }
141 /*
142 * If values didn't have a percentage set, divide the remains between
143 * them.
144 */
145 if (perc_missing) {
Jens Axboe720e84a2009-04-21 08:29:55 +0200146 for (i = 0; i < td->o.bssplit_nr[ddir]; i++) {
147 struct bssplit *bsp = &bssplit[i];
Jens Axboe564ca972007-12-14 12:21:19 +0100148
149 if (bsp->perc == (unsigned char) -1)
150 bsp->perc = (100 - perc) / perc_missing;
151 }
152 }
153
Jens Axboe720e84a2009-04-21 08:29:55 +0200154 td->o.min_bs[ddir] = min_bs;
155 td->o.max_bs[ddir] = max_bs;
Jens Axboe564ca972007-12-14 12:21:19 +0100156
157 /*
158 * now sort based on percentages, for ease of lookup
159 */
Jens Axboe720e84a2009-04-21 08:29:55 +0200160 qsort(bssplit, td->o.bssplit_nr[ddir], sizeof(struct bssplit), bs_cmp);
161 td->o.bssplit[ddir] = bssplit;
162 return 0;
Jens Axboe720e84a2009-04-21 08:29:55 +0200163}
164
165static int str_bssplit_cb(void *data, const char *input)
166{
167 struct thread_data *td = data;
168 char *str, *p, *odir;
169 int ret = 0;
170
171 p = str = strdup(input);
172
173 strip_blank_front(&str);
174 strip_blank_end(str);
175
176 odir = strchr(str, ',');
177 if (odir) {
178 ret = bssplit_ddir(td, DDIR_WRITE, odir + 1);
179 if (!ret) {
180 *odir = '\0';
181 ret = bssplit_ddir(td, DDIR_READ, str);
182 }
183 } else {
184 char *op;
185
186 op = strdup(str);
187
188 ret = bssplit_ddir(td, DDIR_READ, str);
189 if (!ret)
190 ret = bssplit_ddir(td, DDIR_WRITE, op);
191
192 free(op);
193 }
Jens Axboe564ca972007-12-14 12:21:19 +0100194
195 free(p);
Jens Axboe720e84a2009-04-21 08:29:55 +0200196 return ret;
Jens Axboe564ca972007-12-14 12:21:19 +0100197}
198
Jens Axboe211097b2007-03-22 18:56:45 +0100199static int str_rw_cb(void *data, const char *str)
200{
201 struct thread_data *td = data;
202 char *nr = get_opt_postfix(str);
203
Jens Axboe5736c102010-07-20 12:03:25 -0600204 td->o.ddir_seq_nr = 1;
Jens Axboe059b0802011-08-25 09:09:37 +0200205 td->o.ddir_seq_add = 0;
206
207 if (!nr)
208 return 0;
209
210 if (td_random(td))
Jens Axboe5736c102010-07-20 12:03:25 -0600211 td->o.ddir_seq_nr = atoi(nr);
Jens Axboe059b0802011-08-25 09:09:37 +0200212 else {
213 long long val;
214
Jens Axboe6925dd32011-09-07 22:10:11 +0200215 if (str_to_decimal(nr, &val, 1, td)) {
Jens Axboe059b0802011-08-25 09:09:37 +0200216 log_err("fio: rw postfix parsing failed\n");
217 free(nr);
218 return 1;
219 }
220
221 td->o.ddir_seq_add = val;
Jens Axboe182ec6e2008-11-14 13:06:06 +0100222 }
Jens Axboe211097b2007-03-22 18:56:45 +0100223
Jens Axboe059b0802011-08-25 09:09:37 +0200224 free(nr);
Jens Axboe211097b2007-03-22 18:56:45 +0100225 return 0;
226}
227
Jens Axboe214e1ec2007-03-15 10:48:13 +0100228static int str_mem_cb(void *data, const char *mem)
229{
230 struct thread_data *td = data;
231
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100232 if (td->o.mem_type == MEM_MMAPHUGE || td->o.mem_type == MEM_MMAP) {
Jens Axboe214e1ec2007-03-15 10:48:13 +0100233 td->mmapfile = get_opt_postfix(mem);
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100234 if (td->o.mem_type == MEM_MMAPHUGE && !td->mmapfile) {
Jens Axboe214e1ec2007-03-15 10:48:13 +0100235 log_err("fio: mmaphuge:/path/to/file\n");
236 return 1;
237 }
238 }
239
240 return 0;
241}
242
Jens Axboe5d7c5d32010-06-21 15:08:17 +0200243static int str_verify_cb(void *data, const char *mem)
244{
245 struct thread_data *td = data;
246
Jens Axboee3aaafc2012-02-22 20:28:17 +0100247 if (td->o.verify == VERIFY_CRC32C_INTEL ||
248 td->o.verify == VERIFY_CRC32C) {
249 crc32c_intel_probe();
Jens Axboe5d7c5d32010-06-21 15:08:17 +0200250 }
251
252 return 0;
253}
254
Jens Axboec223da82010-03-24 13:23:53 +0100255static int fio_clock_source_cb(void *data, const char *str)
256{
257 struct thread_data *td = data;
258
259 fio_clock_source = td->o.clocksource;
260 fio_time_init();
261 return 0;
262}
263
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400264static int str_lockmem_cb(void fio_unused *data, unsigned long long *val)
Jens Axboe214e1ec2007-03-15 10:48:13 +0100265{
266 mlock_size = *val;
267 return 0;
268}
269
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400270static int str_rwmix_read_cb(void *data, unsigned long long *val)
Jens Axboecb499fc2008-05-28 10:33:32 +0200271{
272 struct thread_data *td = data;
273
274 td->o.rwmix[DDIR_READ] = *val;
275 td->o.rwmix[DDIR_WRITE] = 100 - *val;
276 return 0;
277}
278
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400279static int str_rwmix_write_cb(void *data, unsigned long long *val)
Jens Axboecb499fc2008-05-28 10:33:32 +0200280{
281 struct thread_data *td = data;
282
283 td->o.rwmix[DDIR_WRITE] = *val;
284 td->o.rwmix[DDIR_READ] = 100 - *val;
285 return 0;
286}
287
Jens Axboe214e1ec2007-03-15 10:48:13 +0100288#ifdef FIO_HAVE_IOPRIO
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400289static int str_prioclass_cb(void *data, unsigned long long *val)
Jens Axboe214e1ec2007-03-15 10:48:13 +0100290{
291 struct thread_data *td = data;
Jens Axboe6cefbe32007-04-18 12:46:56 +0200292 unsigned short mask;
293
294 /*
295 * mask off old class bits, str_prio_cb() may have set a default class
296 */
297 mask = (1 << IOPRIO_CLASS_SHIFT) - 1;
298 td->ioprio &= mask;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100299
300 td->ioprio |= *val << IOPRIO_CLASS_SHIFT;
Jens Axboeac684782007-11-08 08:29:07 +0100301 td->ioprio_set = 1;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100302 return 0;
303}
304
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400305static int str_prio_cb(void *data, unsigned long long *val)
Jens Axboe214e1ec2007-03-15 10:48:13 +0100306{
307 struct thread_data *td = data;
308
309 td->ioprio |= *val;
Jens Axboe6cefbe32007-04-18 12:46:56 +0200310
311 /*
312 * If no class is set, assume BE
313 */
314 if ((td->ioprio >> IOPRIO_CLASS_SHIFT) == 0)
315 td->ioprio |= IOPRIO_CLASS_BE << IOPRIO_CLASS_SHIFT;
316
Jens Axboeac684782007-11-08 08:29:07 +0100317 td->ioprio_set = 1;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100318 return 0;
319}
320#endif
321
322static int str_exitall_cb(void)
323{
324 exitall_on_terminate = 1;
325 return 0;
326}
327
Jens Axboe214e1ec2007-03-15 10:48:13 +0100328#ifdef FIO_HAVE_CPU_AFFINITY
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400329static int str_cpumask_cb(void *data, unsigned long long *val)
Jens Axboe214e1ec2007-03-15 10:48:13 +0100330{
331 struct thread_data *td = data;
Jens Axboed2e268b2007-06-15 10:33:49 +0200332 unsigned int i;
Jens Axboeb03daaf2008-12-08 20:31:43 +0100333 long max_cpu;
Jens Axboed2ce18b2008-12-12 20:51:40 +0100334 int ret;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100335
Jens Axboed2ce18b2008-12-12 20:51:40 +0100336 ret = fio_cpuset_init(&td->o.cpumask);
337 if (ret < 0) {
338 log_err("fio: cpuset_init failed\n");
339 td_verror(td, ret, "fio_cpuset_init");
340 return 1;
341 }
342
Jens Axboec00a2282011-07-08 20:56:06 +0200343 max_cpu = cpus_online();
Jens Axboed2e268b2007-06-15 10:33:49 +0200344
Jens Axboe62a72732008-12-08 11:37:01 +0100345 for (i = 0; i < sizeof(int) * 8; i++) {
346 if ((1 << i) & *val) {
Jens Axboeb03daaf2008-12-08 20:31:43 +0100347 if (i > max_cpu) {
348 log_err("fio: CPU %d too large (max=%ld)\n", i,
349 max_cpu);
350 return 1;
351 }
Jens Axboe62a72732008-12-08 11:37:01 +0100352 dprint(FD_PARSE, "set cpu allowed %d\n", i);
Jens Axboe6d459ee2008-12-12 20:02:58 +0100353 fio_cpu_set(&td->o.cpumask, i);
Jens Axboe62a72732008-12-08 11:37:01 +0100354 }
355 }
Jens Axboed2e268b2007-06-15 10:33:49 +0200356
Jens Axboe375b2692007-05-22 09:13:02 +0200357 td->o.cpumask_set = 1;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100358 return 0;
359}
360
Jens Axboee8462bd2009-07-06 12:59:04 +0200361static int set_cpus_allowed(struct thread_data *td, os_cpu_mask_t *mask,
362 const char *input)
Jens Axboed2e268b2007-06-15 10:33:49 +0200363{
Jens Axboed2e268b2007-06-15 10:33:49 +0200364 char *cpu, *str, *p;
Jens Axboeb03daaf2008-12-08 20:31:43 +0100365 long max_cpu;
Jens Axboe19608d62008-12-08 15:03:12 +0100366 int ret = 0;
Jens Axboed2e268b2007-06-15 10:33:49 +0200367
Jens Axboee8462bd2009-07-06 12:59:04 +0200368 ret = fio_cpuset_init(mask);
Jens Axboed2ce18b2008-12-12 20:51:40 +0100369 if (ret < 0) {
370 log_err("fio: cpuset_init failed\n");
371 td_verror(td, ret, "fio_cpuset_init");
372 return 1;
373 }
Jens Axboed2e268b2007-06-15 10:33:49 +0200374
375 p = str = strdup(input);
376
377 strip_blank_front(&str);
378 strip_blank_end(str);
379
Jens Axboec00a2282011-07-08 20:56:06 +0200380 max_cpu = cpus_online();
Jens Axboeb03daaf2008-12-08 20:31:43 +0100381
Jens Axboed2e268b2007-06-15 10:33:49 +0200382 while ((cpu = strsep(&str, ",")) != NULL) {
Jens Axboe62a72732008-12-08 11:37:01 +0100383 char *str2, *cpu2;
384 int icpu, icpu2;
385
Jens Axboed2e268b2007-06-15 10:33:49 +0200386 if (!strlen(cpu))
387 break;
Jens Axboe62a72732008-12-08 11:37:01 +0100388
389 str2 = cpu;
390 icpu2 = -1;
391 while ((cpu2 = strsep(&str2, "-")) != NULL) {
392 if (!strlen(cpu2))
393 break;
394
395 icpu2 = atoi(cpu2);
396 }
397
398 icpu = atoi(cpu);
399 if (icpu2 == -1)
400 icpu2 = icpu;
401 while (icpu <= icpu2) {
Jens Axboe6d459ee2008-12-12 20:02:58 +0100402 if (icpu >= FIO_MAX_CPUS) {
Jens Axboe19608d62008-12-08 15:03:12 +0100403 log_err("fio: your OS only supports up to"
Jens Axboe6d459ee2008-12-12 20:02:58 +0100404 " %d CPUs\n", (int) FIO_MAX_CPUS);
Jens Axboe19608d62008-12-08 15:03:12 +0100405 ret = 1;
406 break;
407 }
Jens Axboeb03daaf2008-12-08 20:31:43 +0100408 if (icpu > max_cpu) {
409 log_err("fio: CPU %d too large (max=%ld)\n",
410 icpu, max_cpu);
411 ret = 1;
412 break;
413 }
Jens Axboe0b9d69e2009-09-11 22:29:54 +0200414
Jens Axboe62a72732008-12-08 11:37:01 +0100415 dprint(FD_PARSE, "set cpu allowed %d\n", icpu);
Jens Axboee8462bd2009-07-06 12:59:04 +0200416 fio_cpu_set(mask, icpu);
Jens Axboe62a72732008-12-08 11:37:01 +0100417 icpu++;
418 }
Jens Axboe19608d62008-12-08 15:03:12 +0100419 if (ret)
420 break;
Jens Axboed2e268b2007-06-15 10:33:49 +0200421 }
422
423 free(p);
Jens Axboe19608d62008-12-08 15:03:12 +0100424 if (!ret)
425 td->o.cpumask_set = 1;
426 return ret;
Jens Axboed2e268b2007-06-15 10:33:49 +0200427}
Jens Axboee8462bd2009-07-06 12:59:04 +0200428
429static int str_cpus_allowed_cb(void *data, const char *input)
430{
431 struct thread_data *td = data;
432 int ret;
433
434 ret = set_cpus_allowed(td, &td->o.cpumask, input);
435 if (!ret)
436 td->o.cpumask_set = 1;
437
438 return ret;
439}
440
441static int str_verify_cpus_allowed_cb(void *data, const char *input)
442{
443 struct thread_data *td = data;
444 int ret;
445
446 ret = set_cpus_allowed(td, &td->o.verify_cpumask, input);
447 if (!ret)
448 td->o.verify_cpumask_set = 1;
449
450 return ret;
451}
Jens Axboed2e268b2007-06-15 10:33:49 +0200452#endif
453
Jens Axboe0d29de82010-09-01 13:54:15 +0200454#ifdef FIO_HAVE_TRIM
455static int str_verify_trim_cb(void *data, unsigned long long *val)
456{
457 struct thread_data *td = data;
458
459 td->o.trim_percentage = *val;
460 return 0;
461}
462#endif
463
Jens Axboe214e1ec2007-03-15 10:48:13 +0100464static int str_fst_cb(void *data, const char *str)
465{
466 struct thread_data *td = data;
467 char *nr = get_opt_postfix(str);
468
469 td->file_service_nr = 1;
Jens Axboe182ec6e2008-11-14 13:06:06 +0100470 if (nr) {
Jens Axboe214e1ec2007-03-15 10:48:13 +0100471 td->file_service_nr = atoi(nr);
Jens Axboe182ec6e2008-11-14 13:06:06 +0100472 free(nr);
473 }
Jens Axboe214e1ec2007-03-15 10:48:13 +0100474
475 return 0;
476}
477
Jens Axboe3ae06372010-03-19 19:17:15 +0100478#ifdef FIO_HAVE_SYNC_FILE_RANGE
Jens Axboe44f29692010-03-09 20:09:44 +0100479static int str_sfr_cb(void *data, const char *str)
480{
481 struct thread_data *td = data;
482 char *nr = get_opt_postfix(str);
483
484 td->sync_file_range_nr = 1;
485 if (nr) {
486 td->sync_file_range_nr = atoi(nr);
487 free(nr);
488 }
489
490 return 0;
491}
Jens Axboe3ae06372010-03-19 19:17:15 +0100492#endif
Jens Axboe44f29692010-03-09 20:09:44 +0100493
Jens Axboe921c7662008-03-26 09:17:55 +0100494static int check_dir(struct thread_data *td, char *fname)
495{
Jens Axboe3f0ca9b2011-05-24 21:36:24 +0200496#if 0
Jens Axboe921c7662008-03-26 09:17:55 +0100497 char file[PATH_MAX], *dir;
Jens Axboebc838912008-04-07 09:00:54 +0200498 int elen = 0;
Jens Axboe921c7662008-03-26 09:17:55 +0100499
Jens Axboebc838912008-04-07 09:00:54 +0200500 if (td->o.directory) {
501 strcpy(file, td->o.directory);
Jens Axboefcef0b32008-05-26 14:53:24 +0200502 strcat(file, "/");
Jens Axboebc838912008-04-07 09:00:54 +0200503 elen = strlen(file);
504 }
505
Jens Axboefcef0b32008-05-26 14:53:24 +0200506 sprintf(file + elen, "%s", fname);
Jens Axboe921c7662008-03-26 09:17:55 +0100507 dir = dirname(file);
508
Jens Axboefcef0b32008-05-26 14:53:24 +0200509 {
510 struct stat sb;
511 /*
512 * We can't do this on FIO_DISKLESSIO engines. The engine isn't loaded
513 * yet, so we can't do this check right here...
514 */
Jens Axboe921c7662008-03-26 09:17:55 +0100515 if (lstat(dir, &sb) < 0) {
516 int ret = errno;
517
518 log_err("fio: %s is not a directory\n", dir);
519 td_verror(td, ret, "lstat");
520 return 1;
521 }
522
523 if (!S_ISDIR(sb.st_mode)) {
524 log_err("fio: %s is not a directory\n", dir);
525 return 1;
526 }
Jens Axboefcef0b32008-05-26 14:53:24 +0200527 }
528#endif
Jens Axboe921c7662008-03-26 09:17:55 +0100529
530 return 0;
531}
532
Jens Axboe8e827d32009-08-04 09:51:48 +0200533/*
534 * Return next file in the string. Files are separated with ':'. If the ':'
535 * is escaped with a '\', then that ':' is part of the filename and does not
536 * indicate a new file.
537 */
538static char *get_next_file_name(char **ptr)
539{
540 char *str = *ptr;
541 char *p, *start;
542
543 if (!str || !strlen(str))
544 return NULL;
545
546 start = str;
547 do {
548 /*
549 * No colon, we are done
550 */
551 p = strchr(str, ':');
552 if (!p) {
553 *ptr = NULL;
554 break;
555 }
556
557 /*
558 * We got a colon, but it's the first character. Skip and
559 * continue
560 */
561 if (p == start) {
562 str = ++start;
563 continue;
564 }
565
566 if (*(p - 1) != '\\') {
567 *p = '\0';
568 *ptr = p + 1;
569 break;
570 }
571
572 memmove(p - 1, p, strlen(p) + 1);
573 str = p;
574 } while (1);
575
576 return start;
577}
578
Jens Axboe214e1ec2007-03-15 10:48:13 +0100579static int str_filename_cb(void *data, const char *input)
580{
581 struct thread_data *td = data;
582 char *fname, *str, *p;
583
584 p = str = strdup(input);
585
586 strip_blank_front(&str);
587 strip_blank_end(str);
588
589 if (!td->files_index)
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100590 td->o.nr_files = 0;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100591
Jens Axboe8e827d32009-08-04 09:51:48 +0200592 while ((fname = get_next_file_name(&str)) != NULL) {
Jens Axboe214e1ec2007-03-15 10:48:13 +0100593 if (!strlen(fname))
594 break;
Jens Axboe921c7662008-03-26 09:17:55 +0100595 if (check_dir(td, fname)) {
596 free(p);
597 return 1;
598 }
Jens Axboe214e1ec2007-03-15 10:48:13 +0100599 add_file(td, fname);
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100600 td->o.nr_files++;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100601 }
602
603 free(p);
604 return 0;
605}
606
607static int str_directory_cb(void *data, const char fio_unused *str)
608{
609 struct thread_data *td = data;
610 struct stat sb;
611
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100612 if (lstat(td->o.directory, &sb) < 0) {
Jens Axboe921c7662008-03-26 09:17:55 +0100613 int ret = errno;
614
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100615 log_err("fio: %s is not a directory\n", td->o.directory);
Jens Axboe921c7662008-03-26 09:17:55 +0100616 td_verror(td, ret, "lstat");
Jens Axboe214e1ec2007-03-15 10:48:13 +0100617 return 1;
618 }
619 if (!S_ISDIR(sb.st_mode)) {
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100620 log_err("fio: %s is not a directory\n", td->o.directory);
Jens Axboe214e1ec2007-03-15 10:48:13 +0100621 return 1;
622 }
623
624 return 0;
625}
626
627static int str_opendir_cb(void *data, const char fio_unused *str)
628{
629 struct thread_data *td = data;
630
631 if (!td->files_index)
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100632 td->o.nr_files = 0;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100633
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100634 return add_dir_files(td, td->o.opendir);
Jens Axboe214e1ec2007-03-15 10:48:13 +0100635}
636
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400637static int str_verify_offset_cb(void *data, unsigned long long *off)
Shawn Lewis546a9142007-07-28 21:11:37 +0200638{
639 struct thread_data *td = data;
Jens Axboea59e1702007-07-30 08:53:27 +0200640
Shawn Lewis546a9142007-07-28 21:11:37 +0200641 if (*off && *off < sizeof(struct verify_header)) {
Jens Axboea59e1702007-07-30 08:53:27 +0200642 log_err("fio: verify_offset too small\n");
Shawn Lewis546a9142007-07-28 21:11:37 +0200643 return 1;
644 }
Jens Axboea59e1702007-07-30 08:53:27 +0200645
646 td->o.verify_offset = *off;
Shawn Lewis546a9142007-07-28 21:11:37 +0200647 return 0;
648}
649
Radha Ramachandran0e92f872009-10-27 20:14:27 +0100650static int str_verify_pattern_cb(void *data, const char *input)
Jens Axboe90059d62007-07-30 09:33:12 +0200651{
652 struct thread_data *td = data;
Radha Ramachandran0e92f872009-10-27 20:14:27 +0100653 long off;
654 int i = 0, j = 0, len, k, base = 10;
655 char* loc1, * loc2;
Jens Axboe90059d62007-07-30 09:33:12 +0200656
Radha Ramachandran0e92f872009-10-27 20:14:27 +0100657 loc1 = strstr(input, "0x");
658 loc2 = strstr(input, "0X");
659 if (loc1 || loc2)
660 base = 16;
661 off = strtol(input, NULL, base);
662 if (off != LONG_MAX || errno != ERANGE) {
663 while (off) {
664 td->o.verify_pattern[i] = off & 0xff;
665 off >>= 8;
666 i++;
667 }
668 } else {
669 len = strlen(input);
670 k = len - 1;
671 if (base == 16) {
672 if (loc1)
673 j = loc1 - input + 2;
674 else
675 j = loc2 - input + 2;
676 } else
677 return 1;
678 if (len - j < MAX_PATTERN_SIZE * 2) {
679 while (k >= j) {
680 off = converthexchartoint(input[k--]);
681 if (k >= j)
682 off += (converthexchartoint(input[k--])
683 * 16);
684 td->o.verify_pattern[i++] = (char) off;
685 }
686 }
687 }
Steven Langefcd9dc2012-02-02 20:22:04 +0100688
689 /*
690 * Fill the pattern all the way to the end. This greatly reduces
691 * the number of memcpy's we have to do when verifying the IO.
692 */
693 while (i > 1 && i * 2 <= MAX_PATTERN_SIZE) {
694 memcpy(&td->o.verify_pattern[i], &td->o.verify_pattern[0], i);
695 i *= 2;
696 }
Steven Lang9a2a86d2012-02-07 09:42:59 +0100697 if (i == 1) {
698 /*
699 * The code in verify_io_u_pattern assumes a single byte pattern
700 * fills the whole verify pattern buffer.
701 */
702 memset(td->o.verify_pattern, td->o.verify_pattern[0],
703 MAX_PATTERN_SIZE);
704 }
Steven Langefcd9dc2012-02-02 20:22:04 +0100705
Radha Ramachandran0e92f872009-10-27 20:14:27 +0100706 td->o.verify_pattern_bytes = i;
Steven Langefcd9dc2012-02-02 20:22:04 +0100707
Jens Axboe92bf48d2011-01-14 21:20:42 +0100708 /*
709 * VERIFY_META could already be set
710 */
711 if (td->o.verify == VERIFY_NONE)
712 td->o.verify = VERIFY_PATTERN;
Steven Langefcd9dc2012-02-02 20:22:04 +0100713
Jens Axboe90059d62007-07-30 09:33:12 +0200714 return 0;
715}
Jens Axboe214e1ec2007-03-15 10:48:13 +0100716
Jens Axboe4d4e80f2008-03-04 10:18:56 +0100717static int str_lockfile_cb(void *data, const char *str)
718{
719 struct thread_data *td = data;
720 char *nr = get_opt_postfix(str);
721
722 td->o.lockfile_batch = 1;
Jens Axboe182ec6e2008-11-14 13:06:06 +0100723 if (nr) {
Jens Axboe4d4e80f2008-03-04 10:18:56 +0100724 td->o.lockfile_batch = atoi(nr);
Jens Axboe182ec6e2008-11-14 13:06:06 +0100725 free(nr);
726 }
Jens Axboe4d4e80f2008-03-04 10:18:56 +0100727
728 return 0;
729}
730
Jens Axboee3cedca2008-11-19 19:57:52 +0100731static int str_write_bw_log_cb(void *data, const char *str)
732{
733 struct thread_data *td = data;
734
735 if (str)
736 td->o.bw_log_file = strdup(str);
737
738 td->o.write_bw_log = 1;
739 return 0;
740}
741
742static int str_write_lat_log_cb(void *data, const char *str)
743{
744 struct thread_data *td = data;
745
746 if (str)
747 td->o.lat_log_file = strdup(str);
748
749 td->o.write_lat_log = 1;
750 return 0;
751}
752
Jens Axboec8eeb9d2011-10-05 14:02:22 +0200753static int str_write_iops_log_cb(void *data, const char *str)
754{
755 struct thread_data *td = data;
756
757 if (str)
758 td->o.iops_log_file = strdup(str);
759
760 td->o.write_iops_log = 1;
761 return 0;
762}
763
Jens Axboe993bf482008-11-14 13:04:53 +0100764static int str_gtod_reduce_cb(void *data, int *il)
765{
766 struct thread_data *td = data;
767 int val = *il;
768
Jens Axboe02af0982010-06-24 09:59:34 +0200769 td->o.disable_lat = !!val;
Jens Axboe993bf482008-11-14 13:04:53 +0100770 td->o.disable_clat = !!val;
771 td->o.disable_slat = !!val;
772 td->o.disable_bw = !!val;
Jens Axboe0dc1bc02011-10-13 08:55:29 +0200773 td->o.clat_percentiles = !val;
Jens Axboe993bf482008-11-14 13:04:53 +0100774 if (val)
775 td->tv_cache_mask = 63;
776
777 return 0;
778}
779
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400780static int str_gtod_cpu_cb(void *data, long long *il)
Jens Axboebe4ecfd2008-12-08 14:10:52 +0100781{
782 struct thread_data *td = data;
783 int val = *il;
784
785 td->o.gtod_cpu = val;
786 td->o.gtod_offload = 1;
787 return 0;
788}
789
Jens Axboe7bb59102011-07-12 19:47:03 +0200790static int str_size_cb(void *data, unsigned long long *__val)
791{
792 struct thread_data *td = data;
793 unsigned long long v = *__val;
794
795 if (parse_is_percent(v)) {
796 td->o.size = 0;
797 td->o.size_percent = -1ULL - v;
798 } else
799 td->o.size = v;
800
801 return 0;
802}
803
Jens Axboe896cac22009-07-01 10:38:35 +0200804static int rw_verify(struct fio_option *o, void *data)
805{
806 struct thread_data *td = data;
807
808 if (read_only && td_write(td)) {
809 log_err("fio: job <%s> has write bit set, but fio is in"
810 " read-only mode\n", td->o.name);
811 return 1;
812 }
813
814 return 0;
815}
816
Jens Axboe276ca4f2009-07-01 10:43:05 +0200817static int gtod_cpu_verify(struct fio_option *o, void *data)
Jens Axboe29d43ff2009-07-01 10:42:18 +0200818{
Jens Axboe276ca4f2009-07-01 10:43:05 +0200819#ifndef FIO_HAVE_CPU_AFFINITY
Jens Axboe29d43ff2009-07-01 10:42:18 +0200820 struct thread_data *td = data;
821
Jens Axboe29d43ff2009-07-01 10:42:18 +0200822 if (td->o.gtod_cpu) {
823 log_err("fio: platform must support CPU affinity for"
824 "gettimeofday() offloading\n");
825 return 1;
826 }
827#endif
828
829 return 0;
830}
831
Jens Axboe90fef2d2009-07-17 22:33:32 +0200832static int kb_base_verify(struct fio_option *o, void *data)
833{
834 struct thread_data *td = data;
835
836 if (td->o.kb_base != 1024 && td->o.kb_base != 1000) {
837 log_err("fio: kb_base set to nonsensical value: %u\n",
838 td->o.kb_base);
839 return 1;
840 }
841
842 return 0;
843}
844
Jens Axboe214e1ec2007-03-15 10:48:13 +0100845/*
Jens Axboe9af4a242012-03-16 10:13:49 +0100846 * Option grouping
847 */
848static struct opt_group fio_opt_groups[] = {
849 {
850 .name = "Description",
851 .mask = FIO_OPT_G_DESC,
852 },
853 {
854 .name = "File",
855 .mask = FIO_OPT_G_FILE,
856 },
857 {
858 .name = "Misc",
859 .mask = FIO_OPT_G_MISC,
860 },
861 {
862 .name = "IO (main)",
863 .mask = FIO_OPT_G_IO,
864 },
865 {
866 .name = "IO direction",
867 .mask = FIO_OPT_G_IO_DDIR,
868 },
869 {
870 .name = "IO buffer",
871 .mask = FIO_OPT_G_IO_BUF,
872 },
873 {
874 .name = "Random",
875 .mask = FIO_OPT_G_RAND,
876 },
877 {
878 .name = "OS",
879 .mask = FIO_OPT_G_OS,
880 },
881 {
882 .name = "Memory",
883 .mask = FIO_OPT_G_MEM,
884 },
885 {
886 .name = "Verify",
887 .mask = FIO_OPT_G_VERIFY,
888 },
889 {
890 .name = "CPU",
891 .mask = FIO_OPT_G_CPU,
892 },
893 {
894 .name = "Log",
895 .mask = FIO_OPT_G_LOG,
896 },
897 {
898 .name = "Zone",
899 .mask = FIO_OPT_G_ZONE,
900 },
901 {
902 .name = "Cache",
903 .mask = FIO_OPT_G_CACHE,
904 },
905 {
906 .name = "Stat",
907 .mask = FIO_OPT_G_STAT,
908 },
909 {
910 .name = "Error",
911 .mask = FIO_OPT_G_ERR,
912 },
913 {
914 .name = "Job",
915 .mask = FIO_OPT_G_JOB,
916 },
917 {
918 .name = NULL,
919 },
920};
921
922struct opt_group *opt_group_from_mask(unsigned int *mask)
923{
924 struct opt_group *og;
925 int i;
926
927 if (*mask == FIO_OPT_G_INVALID)
928 return NULL;
929
930 for (i = 0; fio_opt_groups[i].name; i++) {
931 og = &fio_opt_groups[i];
932
933 if (*mask & og->mask) {
934 *mask &= ~(og->mask);
935 return og;
936 }
937 }
938
939 return NULL;
940}
941
942/*
Jens Axboe214e1ec2007-03-15 10:48:13 +0100943 * Map of job/command line options
944 */
Jens Axboe9af4a242012-03-16 10:13:49 +0100945struct fio_option fio_options[FIO_MAX_OPTS] = {
Jens Axboe214e1ec2007-03-15 10:48:13 +0100946 {
947 .name = "description",
948 .type = FIO_OPT_STR_STORE,
949 .off1 = td_var_offset(description),
950 .help = "Text job description",
Jens Axboec9c63312012-03-12 10:46:43 +0100951 .category = FIO_OPT_G_DESC,
Jens Axboe214e1ec2007-03-15 10:48:13 +0100952 },
953 {
954 .name = "name",
955 .type = FIO_OPT_STR_STORE,
956 .off1 = td_var_offset(name),
957 .help = "Name of this job",
Jens Axboec9c63312012-03-12 10:46:43 +0100958 .category = FIO_OPT_G_DESC,
Jens Axboe214e1ec2007-03-15 10:48:13 +0100959 },
960 {
961 .name = "directory",
962 .type = FIO_OPT_STR_STORE,
963 .off1 = td_var_offset(directory),
964 .cb = str_directory_cb,
965 .help = "Directory to store files in",
Jens Axboec9c63312012-03-12 10:46:43 +0100966 .category = FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +0100967 },
968 {
969 .name = "filename",
970 .type = FIO_OPT_STR_STORE,
971 .off1 = td_var_offset(filename),
972 .cb = str_filename_cb,
Jens Axboef0d524b2009-04-27 08:00:48 +0200973 .prio = -1, /* must come after "directory" */
Jens Axboe214e1ec2007-03-15 10:48:13 +0100974 .help = "File(s) to use for the workload",
Jens Axboec9c63312012-03-12 10:46:43 +0100975 .category = FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +0100976 },
977 {
Jens Axboe90fef2d2009-07-17 22:33:32 +0200978 .name = "kb_base",
979 .type = FIO_OPT_INT,
980 .off1 = td_var_offset(kb_base),
Jens Axboe90fef2d2009-07-17 22:33:32 +0200981 .verify = kb_base_verify,
Jens Axboea639f0b2009-07-18 08:25:35 +0200982 .prio = 1,
Jens Axboe90fef2d2009-07-17 22:33:32 +0200983 .def = "1024",
Jens Axboea639f0b2009-07-18 08:25:35 +0200984 .help = "How many bytes per KB for reporting (1000 or 1024)",
Jens Axboec9c63312012-03-12 10:46:43 +0100985 .category = FIO_OPT_G_MISC,
Jens Axboe90fef2d2009-07-17 22:33:32 +0200986 },
987 {
Jens Axboe29c13492008-03-01 19:25:20 +0100988 .name = "lockfile",
Jens Axboe4d4e80f2008-03-04 10:18:56 +0100989 .type = FIO_OPT_STR,
990 .cb = str_lockfile_cb,
991 .off1 = td_var_offset(file_lock_mode),
Jens Axboe29c13492008-03-01 19:25:20 +0100992 .help = "Lock file when doing IO to it",
993 .parent = "filename",
Jens Axboe4d4e80f2008-03-04 10:18:56 +0100994 .def = "none",
Jens Axboec9c63312012-03-12 10:46:43 +0100995 .category = FIO_OPT_G_FILE,
Jens Axboe4d4e80f2008-03-04 10:18:56 +0100996 .posval = {
997 { .ival = "none",
998 .oval = FILE_LOCK_NONE,
999 .help = "No file locking",
1000 },
1001 { .ival = "exclusive",
1002 .oval = FILE_LOCK_EXCLUSIVE,
1003 .help = "Exclusive file lock",
1004 },
1005 {
1006 .ival = "readwrite",
1007 .oval = FILE_LOCK_READWRITE,
1008 .help = "Read vs write lock",
1009 },
1010 },
Jens Axboe29c13492008-03-01 19:25:20 +01001011 },
1012 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001013 .name = "opendir",
1014 .type = FIO_OPT_STR_STORE,
1015 .off1 = td_var_offset(opendir),
1016 .cb = str_opendir_cb,
1017 .help = "Recursively add files from this directory and down",
Jens Axboec9c63312012-03-12 10:46:43 +01001018 .category = FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001019 },
1020 {
1021 .name = "rw",
Jens Axboed3aad8f2007-03-15 14:12:05 +01001022 .alias = "readwrite",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001023 .type = FIO_OPT_STR,
Jens Axboe211097b2007-03-22 18:56:45 +01001024 .cb = str_rw_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001025 .off1 = td_var_offset(td_ddir),
1026 .help = "IO direction",
1027 .def = "read",
Jens Axboe896cac22009-07-01 10:38:35 +02001028 .verify = rw_verify,
Jens Axboec9c63312012-03-12 10:46:43 +01001029 .category = FIO_OPT_G_IO_DDIR,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001030 .posval = {
1031 { .ival = "read",
1032 .oval = TD_DDIR_READ,
1033 .help = "Sequential read",
1034 },
1035 { .ival = "write",
1036 .oval = TD_DDIR_WRITE,
1037 .help = "Sequential write",
1038 },
1039 { .ival = "randread",
1040 .oval = TD_DDIR_RANDREAD,
1041 .help = "Random read",
1042 },
1043 { .ival = "randwrite",
1044 .oval = TD_DDIR_RANDWRITE,
1045 .help = "Random write",
1046 },
1047 { .ival = "rw",
1048 .oval = TD_DDIR_RW,
1049 .help = "Sequential read and write mix",
1050 },
1051 { .ival = "randrw",
1052 .oval = TD_DDIR_RANDRW,
1053 .help = "Random read and write mix"
1054 },
1055 },
1056 },
1057 {
Jens Axboe38dad622010-07-20 14:46:00 -06001058 .name = "rw_sequencer",
1059 .type = FIO_OPT_STR,
1060 .off1 = td_var_offset(rw_seq),
1061 .help = "IO offset generator modifier",
1062 .def = "sequential",
Jens Axboec9c63312012-03-12 10:46:43 +01001063 .category = FIO_OPT_G_IO_DDIR,
Jens Axboe38dad622010-07-20 14:46:00 -06001064 .posval = {
1065 { .ival = "sequential",
1066 .oval = RW_SEQ_SEQ,
1067 .help = "Generate sequential offsets",
1068 },
1069 { .ival = "identical",
1070 .oval = RW_SEQ_IDENT,
1071 .help = "Generate identical offsets",
1072 },
1073 },
1074 },
1075
1076 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001077 .name = "ioengine",
1078 .type = FIO_OPT_STR_STORE,
1079 .off1 = td_var_offset(ioengine),
1080 .help = "IO engine to use",
Jens Axboe58483fa2011-01-19 11:09:58 -07001081 .def = FIO_PREFERRED_ENGINE,
Jens Axboec9c63312012-03-12 10:46:43 +01001082 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001083 .posval = {
1084 { .ival = "sync",
1085 .help = "Use read/write",
1086 },
gurudas paia31041e2007-10-23 15:12:30 +02001087 { .ival = "psync",
1088 .help = "Use pread/pwrite",
1089 },
Jens Axboe1d2af022008-02-04 10:59:07 +01001090 { .ival = "vsync",
Bruce Cran03e20d62011-01-02 20:14:54 +01001091 .help = "Use readv/writev",
Jens Axboe1d2af022008-02-04 10:59:07 +01001092 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01001093#ifdef FIO_HAVE_LIBAIO
1094 { .ival = "libaio",
1095 .help = "Linux native asynchronous IO",
1096 },
1097#endif
1098#ifdef FIO_HAVE_POSIXAIO
1099 { .ival = "posixaio",
1100 .help = "POSIX asynchronous IO",
1101 },
1102#endif
Jens Axboe417f0062008-06-02 11:59:30 +02001103#ifdef FIO_HAVE_SOLARISAIO
1104 { .ival = "solarisaio",
1105 .help = "Solaris native asynchronous IO",
1106 },
1107#endif
Bruce Cran03e20d62011-01-02 20:14:54 +01001108#ifdef FIO_HAVE_WINDOWSAIO
1109 { .ival = "windowsaio",
Jens Axboe3be80072011-01-19 11:07:28 -07001110 .help = "Windows native asynchronous IO"
Steven Langde890a12011-11-09 14:03:34 +01001111 },
Jens Axboe3be80072011-01-19 11:07:28 -07001112#endif
Jens Axboe214e1ec2007-03-15 10:48:13 +01001113 { .ival = "mmap",
Bruce Cran03e20d62011-01-02 20:14:54 +01001114 .help = "Memory mapped IO"
Jens Axboe214e1ec2007-03-15 10:48:13 +01001115 },
1116#ifdef FIO_HAVE_SPLICE
1117 { .ival = "splice",
1118 .help = "splice/vmsplice based IO",
1119 },
Jens Axboe9cce02e2007-06-22 15:42:21 +02001120 { .ival = "netsplice",
1121 .help = "splice/vmsplice to/from the network",
1122 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01001123#endif
1124#ifdef FIO_HAVE_SGIO
1125 { .ival = "sg",
1126 .help = "SCSI generic v3 IO",
1127 },
1128#endif
1129 { .ival = "null",
1130 .help = "Testing engine (no data transfer)",
1131 },
1132 { .ival = "net",
1133 .help = "Network IO",
1134 },
1135#ifdef FIO_HAVE_SYSLET
1136 { .ival = "syslet-rw",
1137 .help = "syslet enabled async pread/pwrite IO",
1138 },
1139#endif
1140 { .ival = "cpuio",
Bruce Cran03e20d62011-01-02 20:14:54 +01001141 .help = "CPU cycle burner engine",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001142 },
Jens Axboeb8c82a42007-03-21 08:48:26 +01001143#ifdef FIO_HAVE_GUASI
1144 { .ival = "guasi",
1145 .help = "GUASI IO engine",
1146 },
1147#endif
Jens Axboe79a43182010-09-07 13:28:58 +02001148#ifdef FIO_HAVE_BINJECT
1149 { .ival = "binject",
1150 .help = "binject direct inject block engine",
1151 },
1152#endif
ren yufei21b8aee2011-08-01 10:01:57 +02001153#ifdef FIO_HAVE_RDMA
1154 { .ival = "rdma",
1155 .help = "RDMA IO engine",
1156 },
1157#endif
Jens Axboe214e1ec2007-03-15 10:48:13 +01001158 { .ival = "external",
1159 .help = "Load external engine (append name)",
1160 },
1161 },
1162 },
1163 {
1164 .name = "iodepth",
1165 .type = FIO_OPT_INT,
1166 .off1 = td_var_offset(iodepth),
Bruce Cran03e20d62011-01-02 20:14:54 +01001167 .help = "Number of IO buffers to keep in flight",
Jens Axboe757aff42007-12-12 19:42:13 +01001168 .minval = 1,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001169 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01001170 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001171 },
1172 {
1173 .name = "iodepth_batch",
Jens Axboe49504212008-06-05 09:03:30 +02001174 .alias = "iodepth_batch_submit",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001175 .type = FIO_OPT_INT,
1176 .off1 = td_var_offset(iodepth_batch),
Jens Axboed65db442009-01-16 19:15:33 +01001177 .help = "Number of IO buffers to submit in one go",
Jens Axboeafdf9352007-07-31 16:14:34 +02001178 .parent = "iodepth",
Jens Axboea2e6f8a2008-01-18 10:28:11 +01001179 .minval = 1,
1180 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01001181 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001182 },
1183 {
Jens Axboe49504212008-06-05 09:03:30 +02001184 .name = "iodepth_batch_complete",
1185 .type = FIO_OPT_INT,
1186 .off1 = td_var_offset(iodepth_batch_complete),
Jens Axboed65db442009-01-16 19:15:33 +01001187 .help = "Number of IO buffers to retrieve in one go",
Jens Axboe49504212008-06-05 09:03:30 +02001188 .parent = "iodepth",
1189 .minval = 0,
1190 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01001191 .category = FIO_OPT_G_IO,
Jens Axboe49504212008-06-05 09:03:30 +02001192 },
1193 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001194 .name = "iodepth_low",
1195 .type = FIO_OPT_INT,
1196 .off1 = td_var_offset(iodepth_low),
1197 .help = "Low water mark for queuing depth",
Jens Axboeafdf9352007-07-31 16:14:34 +02001198 .parent = "iodepth",
Jens Axboec9c63312012-03-12 10:46:43 +01001199 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001200 },
1201 {
1202 .name = "size",
1203 .type = FIO_OPT_STR_VAL,
Jens Axboe7bb59102011-07-12 19:47:03 +02001204 .cb = str_size_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001205 .help = "Total size of device or files",
Jens Axboec9c63312012-03-12 10:46:43 +01001206 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001207 },
1208 {
Shawn Lewisaa31f1f2008-01-11 09:45:11 +01001209 .name = "fill_device",
Jens Axboe74586c12011-01-20 10:16:03 -07001210 .alias = "fill_fs",
Shawn Lewisaa31f1f2008-01-11 09:45:11 +01001211 .type = FIO_OPT_BOOL,
1212 .off1 = td_var_offset(fill_device),
1213 .help = "Write until an ENOSPC error occurs",
1214 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001215 .category = FIO_OPT_G_IO,
Shawn Lewisaa31f1f2008-01-11 09:45:11 +01001216 },
1217 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001218 .name = "filesize",
1219 .type = FIO_OPT_STR_VAL,
1220 .off1 = td_var_offset(file_size_low),
1221 .off2 = td_var_offset(file_size_high),
Jens Axboec3edbdb2007-07-20 14:25:31 +02001222 .minval = 1,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001223 .help = "Size of individual files",
Jens Axboec9c63312012-03-12 10:46:43 +01001224 .category = FIO_OPT_G_IO | FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001225 },
1226 {
Jens Axboe67a10002007-07-31 23:12:16 +02001227 .name = "offset",
1228 .alias = "fileoffset",
1229 .type = FIO_OPT_STR_VAL,
1230 .off1 = td_var_offset(start_offset),
1231 .help = "Start IO from this offset",
1232 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001233 .category = FIO_OPT_G_IO,
Jens Axboe67a10002007-07-31 23:12:16 +02001234 },
1235 {
Jens Axboe2d7cd862012-03-15 14:53:38 +01001236 .name = "offset_increment",
1237 .type = FIO_OPT_STR_VAL,
1238 .off1 = td_var_offset(offset_increment),
1239 .help = "What is the increment from one offset to the next",
1240 .parent = "offset",
1241 .def = "0",
Jens Axboe767a0a62012-03-16 19:08:39 +01001242 .category = FIO_OPT_G_IO,
Jens Axboe2d7cd862012-03-15 14:53:38 +01001243 },
1244 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001245 .name = "bs",
Jens Axboed3aad8f2007-03-15 14:12:05 +01001246 .alias = "blocksize",
Jens Axboee01b22b2009-06-09 15:43:25 +02001247 .type = FIO_OPT_INT,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001248 .off1 = td_var_offset(bs[DDIR_READ]),
1249 .off2 = td_var_offset(bs[DDIR_WRITE]),
Jens Axboec3edbdb2007-07-20 14:25:31 +02001250 .minval = 1,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001251 .help = "Block size unit",
1252 .def = "4k",
Jens Axboe67a10002007-07-31 23:12:16 +02001253 .parent = "rw",
Jens Axboec9c63312012-03-12 10:46:43 +01001254 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001255 },
1256 {
Jens Axboe2b7a01d2009-03-11 11:00:13 +01001257 .name = "ba",
1258 .alias = "blockalign",
Jens Axboee01b22b2009-06-09 15:43:25 +02001259 .type = FIO_OPT_INT,
Jens Axboe2b7a01d2009-03-11 11:00:13 +01001260 .off1 = td_var_offset(ba[DDIR_READ]),
1261 .off2 = td_var_offset(ba[DDIR_WRITE]),
1262 .minval = 1,
1263 .help = "IO block offset alignment",
1264 .parent = "rw",
Jens Axboec9c63312012-03-12 10:46:43 +01001265 .category = FIO_OPT_G_IO | FIO_OPT_G_IO_BUF,
Jens Axboe2b7a01d2009-03-11 11:00:13 +01001266 },
1267 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001268 .name = "bsrange",
Jens Axboed3aad8f2007-03-15 14:12:05 +01001269 .alias = "blocksize_range",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001270 .type = FIO_OPT_RANGE,
1271 .off1 = td_var_offset(min_bs[DDIR_READ]),
1272 .off2 = td_var_offset(max_bs[DDIR_READ]),
1273 .off3 = td_var_offset(min_bs[DDIR_WRITE]),
1274 .off4 = td_var_offset(max_bs[DDIR_WRITE]),
Jens Axboec3edbdb2007-07-20 14:25:31 +02001275 .minval = 1,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001276 .help = "Set block size range (in more detail than bs)",
Jens Axboe67a10002007-07-31 23:12:16 +02001277 .parent = "rw",
Jens Axboec9c63312012-03-12 10:46:43 +01001278 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001279 },
1280 {
Jens Axboe564ca972007-12-14 12:21:19 +01001281 .name = "bssplit",
1282 .type = FIO_OPT_STR,
1283 .cb = str_bssplit_cb,
1284 .help = "Set a specific mix of block sizes",
1285 .parent = "rw",
Jens Axboec9c63312012-03-12 10:46:43 +01001286 .category = FIO_OPT_G_IO,
Jens Axboe564ca972007-12-14 12:21:19 +01001287 },
1288 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001289 .name = "bs_unaligned",
Jens Axboed3aad8f2007-03-15 14:12:05 +01001290 .alias = "blocksize_unaligned",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001291 .type = FIO_OPT_STR_SET,
1292 .off1 = td_var_offset(bs_unaligned),
1293 .help = "Don't sector align IO buffer sizes",
Jens Axboe67a10002007-07-31 23:12:16 +02001294 .parent = "rw",
Jens Axboec9c63312012-03-12 10:46:43 +01001295 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001296 },
1297 {
1298 .name = "randrepeat",
1299 .type = FIO_OPT_BOOL,
1300 .off1 = td_var_offset(rand_repeatable),
1301 .help = "Use repeatable random IO pattern",
1302 .def = "1",
Jens Axboe67a10002007-07-31 23:12:16 +02001303 .parent = "rw",
Jens Axboec9c63312012-03-12 10:46:43 +01001304 .category = FIO_OPT_G_IO | FIO_OPT_G_RAND,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001305 },
1306 {
Jens Axboe2615cc42011-03-28 09:35:09 +02001307 .name = "use_os_rand",
1308 .type = FIO_OPT_BOOL,
1309 .off1 = td_var_offset(use_os_rand),
1310 .help = "Set to use OS random generator",
1311 .def = "0",
1312 .parent = "rw",
Jens Axboec9c63312012-03-12 10:46:43 +01001313 .category = FIO_OPT_G_RAND,
Jens Axboe2615cc42011-03-28 09:35:09 +02001314 },
1315 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001316 .name = "norandommap",
1317 .type = FIO_OPT_STR_SET,
1318 .off1 = td_var_offset(norandommap),
1319 .help = "Accept potential duplicate random blocks",
Jens Axboe67a10002007-07-31 23:12:16 +02001320 .parent = "rw",
Jens Axboec9c63312012-03-12 10:46:43 +01001321 .category = FIO_OPT_G_RAND,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001322 },
1323 {
Jens Axboe2b386d22008-03-26 10:32:57 +01001324 .name = "softrandommap",
1325 .type = FIO_OPT_BOOL,
1326 .off1 = td_var_offset(softrandommap),
Jens Axboef66ab3c2008-06-05 11:48:22 +02001327 .help = "Set norandommap if randommap allocation fails",
Jens Axboe2b386d22008-03-26 10:32:57 +01001328 .parent = "norandommap",
1329 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001330 .category = FIO_OPT_G_RAND,
Jens Axboe2b386d22008-03-26 10:32:57 +01001331 },
1332 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001333 .name = "nrfiles",
Jens Axboed7c8be02010-11-25 08:21:39 +01001334 .alias = "nr_files",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001335 .type = FIO_OPT_INT,
1336 .off1 = td_var_offset(nr_files),
1337 .help = "Split job workload between this number of files",
1338 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01001339 .category = FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001340 },
1341 {
1342 .name = "openfiles",
1343 .type = FIO_OPT_INT,
1344 .off1 = td_var_offset(open_files),
1345 .help = "Number of files to keep open at the same time",
Jens Axboec9c63312012-03-12 10:46:43 +01001346 .category = FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001347 },
1348 {
1349 .name = "file_service_type",
1350 .type = FIO_OPT_STR,
1351 .cb = str_fst_cb,
1352 .off1 = td_var_offset(file_service_type),
1353 .help = "How to select which file to service next",
1354 .def = "roundrobin",
Jens Axboec9c63312012-03-12 10:46:43 +01001355 .category = FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001356 .posval = {
1357 { .ival = "random",
1358 .oval = FIO_FSERVICE_RANDOM,
1359 .help = "Choose a file at random",
1360 },
1361 { .ival = "roundrobin",
1362 .oval = FIO_FSERVICE_RR,
1363 .help = "Round robin select files",
1364 },
Jens Axboea086c252009-03-04 08:27:37 +01001365 { .ival = "sequential",
1366 .oval = FIO_FSERVICE_SEQ,
1367 .help = "Finish one file before moving to the next",
1368 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01001369 },
Jens Axboe67a10002007-07-31 23:12:16 +02001370 .parent = "nrfiles",
1371 },
Jens Axboe7bc8c2c2010-01-28 11:31:31 +01001372#ifdef FIO_HAVE_FALLOCATE
1373 {
1374 .name = "fallocate",
Eric Gourioua596f042011-06-17 09:11:45 +02001375 .type = FIO_OPT_STR,
1376 .off1 = td_var_offset(fallocate_mode),
1377 .help = "Whether pre-allocation is performed when laying out files",
1378 .def = "posix",
Jens Axboec9c63312012-03-12 10:46:43 +01001379 .category = FIO_OPT_G_FILE,
Eric Gourioua596f042011-06-17 09:11:45 +02001380 .posval = {
1381 { .ival = "none",
1382 .oval = FIO_FALLOCATE_NONE,
1383 .help = "Do not pre-allocate space",
1384 },
1385 { .ival = "posix",
1386 .oval = FIO_FALLOCATE_POSIX,
1387 .help = "Use posix_fallocate()",
1388 },
1389#ifdef FIO_HAVE_LINUX_FALLOCATE
1390 { .ival = "keep",
1391 .oval = FIO_FALLOCATE_KEEP_SIZE,
1392 .help = "Use fallocate(..., FALLOC_FL_KEEP_SIZE, ...)",
1393 },
Jens Axboe7bc8c2c2010-01-28 11:31:31 +01001394#endif
Eric Gourioua596f042011-06-17 09:11:45 +02001395 /* Compatibility with former boolean values */
1396 { .ival = "0",
1397 .oval = FIO_FALLOCATE_NONE,
1398 .help = "Alias for 'none'",
1399 },
1400 { .ival = "1",
1401 .oval = FIO_FALLOCATE_POSIX,
1402 .help = "Alias for 'posix'",
1403 },
1404 },
1405 },
1406#endif /* FIO_HAVE_FALLOCATE */
Jens Axboe67a10002007-07-31 23:12:16 +02001407 {
1408 .name = "fadvise_hint",
1409 .type = FIO_OPT_BOOL,
1410 .off1 = td_var_offset(fadvise_hint),
1411 .help = "Use fadvise() to advise the kernel on IO pattern",
1412 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01001413 .category = FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001414 },
1415 {
1416 .name = "fsync",
1417 .type = FIO_OPT_INT,
1418 .off1 = td_var_offset(fsync_blocks),
1419 .help = "Issue fsync for writes every given number of blocks",
1420 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001421 .category = FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001422 },
1423 {
Jens Axboe5f9099e2009-06-16 22:40:26 +02001424 .name = "fdatasync",
1425 .type = FIO_OPT_INT,
1426 .off1 = td_var_offset(fdatasync_blocks),
1427 .help = "Issue fdatasync for writes every given number of blocks",
1428 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001429 .category = FIO_OPT_G_FILE,
Jens Axboe5f9099e2009-06-16 22:40:26 +02001430 },
Jens Axboe1ef2b6b2010-10-08 15:07:01 +02001431 {
1432 .name = "write_barrier",
1433 .type = FIO_OPT_INT,
1434 .off1 = td_var_offset(barrier_blocks),
1435 .help = "Make every Nth write a barrier write",
1436 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001437 .category = FIO_OPT_G_IO,
Jens Axboe1ef2b6b2010-10-08 15:07:01 +02001438 },
Jens Axboe44f29692010-03-09 20:09:44 +01001439#ifdef FIO_HAVE_SYNC_FILE_RANGE
1440 {
1441 .name = "sync_file_range",
1442 .posval = {
1443 { .ival = "wait_before",
1444 .oval = SYNC_FILE_RANGE_WAIT_BEFORE,
1445 .help = "SYNC_FILE_RANGE_WAIT_BEFORE",
Jens Axboe3843deb2010-03-09 20:41:15 +01001446 .or = 1,
Jens Axboe44f29692010-03-09 20:09:44 +01001447 },
1448 { .ival = "write",
1449 .oval = SYNC_FILE_RANGE_WRITE,
1450 .help = "SYNC_FILE_RANGE_WRITE",
Jens Axboe3843deb2010-03-09 20:41:15 +01001451 .or = 1,
Jens Axboe44f29692010-03-09 20:09:44 +01001452 },
1453 {
1454 .ival = "wait_after",
1455 .oval = SYNC_FILE_RANGE_WAIT_AFTER,
1456 .help = "SYNC_FILE_RANGE_WAIT_AFTER",
Jens Axboe3843deb2010-03-09 20:41:15 +01001457 .or = 1,
Jens Axboe44f29692010-03-09 20:09:44 +01001458 },
1459 },
Jens Axboe3843deb2010-03-09 20:41:15 +01001460 .type = FIO_OPT_STR_MULTI,
Jens Axboe44f29692010-03-09 20:09:44 +01001461 .cb = str_sfr_cb,
1462 .off1 = td_var_offset(sync_file_range),
1463 .help = "Use sync_file_range()",
Jens Axboec9c63312012-03-12 10:46:43 +01001464 .category = FIO_OPT_G_FILE,
Jens Axboe44f29692010-03-09 20:09:44 +01001465 },
1466#endif
Jens Axboe5f9099e2009-06-16 22:40:26 +02001467 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001468 .name = "direct",
1469 .type = FIO_OPT_BOOL,
1470 .off1 = td_var_offset(odirect),
1471 .help = "Use O_DIRECT IO (negates buffered)",
1472 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001473 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001474 },
1475 {
1476 .name = "buffered",
1477 .type = FIO_OPT_BOOL,
1478 .off1 = td_var_offset(odirect),
1479 .neg = 1,
1480 .help = "Use buffered IO (negates direct)",
1481 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01001482 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001483 },
1484 {
1485 .name = "overwrite",
1486 .type = FIO_OPT_BOOL,
1487 .off1 = td_var_offset(overwrite),
1488 .help = "When writing, set whether to overwrite current data",
1489 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001490 .category = FIO_OPT_G_IO | FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001491 },
1492 {
1493 .name = "loops",
1494 .type = FIO_OPT_INT,
1495 .off1 = td_var_offset(loops),
1496 .help = "Number of times to run the job",
1497 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01001498 .category = FIO_OPT_G_MISC,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001499 },
1500 {
1501 .name = "numjobs",
1502 .type = FIO_OPT_INT,
1503 .off1 = td_var_offset(numjobs),
1504 .help = "Duplicate this job this many times",
1505 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01001506 .category = FIO_OPT_G_MISC,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001507 },
1508 {
1509 .name = "startdelay",
Jens Axboea5737c92010-06-29 10:40:30 +02001510 .type = FIO_OPT_STR_VAL_TIME,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001511 .off1 = td_var_offset(start_delay),
1512 .help = "Only start job when this period has passed",
1513 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001514 .category = FIO_OPT_G_MISC,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001515 },
1516 {
1517 .name = "runtime",
1518 .alias = "timeout",
1519 .type = FIO_OPT_STR_VAL_TIME,
1520 .off1 = td_var_offset(timeout),
1521 .help = "Stop workload when this amount of time has passed",
1522 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001523 .category = FIO_OPT_G_MISC,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001524 },
1525 {
Jens Axboecf4464c2007-04-17 20:14:42 +02001526 .name = "time_based",
1527 .type = FIO_OPT_STR_SET,
1528 .off1 = td_var_offset(time_based),
1529 .help = "Keep running until runtime/timeout is met",
Jens Axboec9c63312012-03-12 10:46:43 +01001530 .category = FIO_OPT_G_MISC,
Jens Axboecf4464c2007-04-17 20:14:42 +02001531 },
1532 {
Jens Axboe721938a2008-09-10 09:46:16 +02001533 .name = "ramp_time",
1534 .type = FIO_OPT_STR_VAL_TIME,
1535 .off1 = td_var_offset(ramp_time),
1536 .help = "Ramp up time before measuring performance",
Jens Axboec9c63312012-03-12 10:46:43 +01001537 .category = FIO_OPT_G_MISC,
Jens Axboe721938a2008-09-10 09:46:16 +02001538 },
1539 {
Jens Axboec223da82010-03-24 13:23:53 +01001540 .name = "clocksource",
1541 .type = FIO_OPT_STR,
1542 .cb = fio_clock_source_cb,
1543 .off1 = td_var_offset(clocksource),
1544 .help = "What type of timing source to use",
Jens Axboec9c63312012-03-12 10:46:43 +01001545 .category = FIO_OPT_G_OS,
Jens Axboec223da82010-03-24 13:23:53 +01001546 .posval = {
1547 { .ival = "gettimeofday",
1548 .oval = CS_GTOD,
1549 .help = "Use gettimeofday(2) for timing",
1550 },
1551 { .ival = "clock_gettime",
1552 .oval = CS_CGETTIME,
1553 .help = "Use clock_gettime(2) for timing",
1554 },
1555#ifdef ARCH_HAVE_CPU_CLOCK
1556 { .ival = "cpu",
1557 .oval = CS_CPUCLOCK,
1558 .help = "Use CPU private clock",
1559 },
1560#endif
1561 },
1562 },
1563 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001564 .name = "mem",
Jens Axboed3aad8f2007-03-15 14:12:05 +01001565 .alias = "iomem",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001566 .type = FIO_OPT_STR,
1567 .cb = str_mem_cb,
1568 .off1 = td_var_offset(mem_type),
1569 .help = "Backing type for IO buffers",
1570 .def = "malloc",
Jens Axboec9c63312012-03-12 10:46:43 +01001571 .category = FIO_OPT_G_IO_BUF | FIO_OPT_G_MEM,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001572 .posval = {
1573 { .ival = "malloc",
1574 .oval = MEM_MALLOC,
1575 .help = "Use malloc(3) for IO buffers",
1576 },
Jens Axboeb370e462007-03-19 10:51:49 +01001577 { .ival = "shm",
1578 .oval = MEM_SHM,
1579 .help = "Use shared memory segments for IO buffers",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001580 },
1581#ifdef FIO_HAVE_HUGETLB
Jens Axboe37c8cdf2007-03-19 13:14:03 +01001582 { .ival = "shmhuge",
1583 .oval = MEM_SHMHUGE,
1584 .help = "Like shm, but use huge pages",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001585 },
1586#endif
Jens Axboeb370e462007-03-19 10:51:49 +01001587 { .ival = "mmap",
1588 .oval = MEM_MMAP,
1589 .help = "Use mmap(2) (file or anon) for IO buffers",
1590 },
Jens Axboe37c8cdf2007-03-19 13:14:03 +01001591#ifdef FIO_HAVE_HUGETLB
1592 { .ival = "mmaphuge",
1593 .oval = MEM_MMAPHUGE,
1594 .help = "Like mmap, but use huge pages",
1595 },
1596#endif
Jens Axboe214e1ec2007-03-15 10:48:13 +01001597 },
1598 },
1599 {
Jens Axboed529ee12009-07-01 10:33:03 +02001600 .name = "iomem_align",
1601 .alias = "mem_align",
1602 .type = FIO_OPT_INT,
1603 .off1 = td_var_offset(mem_align),
1604 .minval = 0,
1605 .help = "IO memory buffer offset alignment",
1606 .def = "0",
1607 .parent = "iomem",
Jens Axboec9c63312012-03-12 10:46:43 +01001608 .category = FIO_OPT_G_IO_BUF | FIO_OPT_G_MEM,
Jens Axboed529ee12009-07-01 10:33:03 +02001609 },
1610 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001611 .name = "verify",
1612 .type = FIO_OPT_STR,
1613 .off1 = td_var_offset(verify),
1614 .help = "Verify data written",
Jens Axboe5d7c5d32010-06-21 15:08:17 +02001615 .cb = str_verify_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001616 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001617 .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001618 .posval = {
1619 { .ival = "0",
1620 .oval = VERIFY_NONE,
1621 .help = "Don't do IO verification",
1622 },
Jens Axboefcca4b52007-07-27 15:42:00 +02001623 { .ival = "md5",
1624 .oval = VERIFY_MD5,
1625 .help = "Use md5 checksums for verification",
1626 },
Jens Axboed77a7af2007-07-27 15:35:06 +02001627 { .ival = "crc64",
1628 .oval = VERIFY_CRC64,
1629 .help = "Use crc64 checksums for verification",
1630 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01001631 { .ival = "crc32",
1632 .oval = VERIFY_CRC32,
1633 .help = "Use crc32 checksums for verification",
1634 },
Jens Axboeaf497e62008-08-04 15:40:35 +02001635 { .ival = "crc32c-intel",
Jens Axboee3aaafc2012-02-22 20:28:17 +01001636 .oval = VERIFY_CRC32C,
1637 .help = "Use crc32c checksums for verification (hw assisted, if available)",
Jens Axboeaf497e62008-08-04 15:40:35 +02001638 },
Jens Axboebac39e02008-06-11 20:46:19 +02001639 { .ival = "crc32c",
1640 .oval = VERIFY_CRC32C,
Jens Axboee3aaafc2012-02-22 20:28:17 +01001641 .help = "Use crc32c checksums for verification (hw assisted, if available)",
Jens Axboebac39e02008-06-11 20:46:19 +02001642 },
Jens Axboe969f7ed2007-07-27 09:07:17 +02001643 { .ival = "crc16",
1644 .oval = VERIFY_CRC16,
1645 .help = "Use crc16 checksums for verification",
1646 },
Jens Axboe1e154bd2007-07-27 09:52:40 +02001647 { .ival = "crc7",
1648 .oval = VERIFY_CRC7,
1649 .help = "Use crc7 checksums for verification",
1650 },
Jens Axboe7c353ce2009-08-09 22:40:33 +02001651 { .ival = "sha1",
1652 .oval = VERIFY_SHA1,
1653 .help = "Use sha1 checksums for verification",
1654 },
Jens Axboecd14cc12007-07-30 10:59:33 +02001655 { .ival = "sha256",
1656 .oval = VERIFY_SHA256,
1657 .help = "Use sha256 checksums for verification",
1658 },
1659 { .ival = "sha512",
1660 .oval = VERIFY_SHA512,
1661 .help = "Use sha512 checksums for verification",
1662 },
Shawn Lewis7437ee82007-08-02 21:05:58 +02001663 { .ival = "meta",
1664 .oval = VERIFY_META,
1665 .help = "Use io information",
1666 },
Jens Axboe36690c92007-03-26 10:23:34 +02001667 {
1668 .ival = "null",
1669 .oval = VERIFY_NULL,
1670 .help = "Pretend to verify",
1671 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01001672 },
1673 },
1674 {
Jens Axboe005c5652007-08-02 22:21:36 +02001675 .name = "do_verify",
Jens Axboe68e1f292007-08-10 10:32:14 +02001676 .type = FIO_OPT_BOOL,
Jens Axboe005c5652007-08-02 22:21:36 +02001677 .off1 = td_var_offset(do_verify),
1678 .help = "Run verification stage after write",
1679 .def = "1",
1680 .parent = "verify",
Jens Axboec9c63312012-03-12 10:46:43 +01001681 .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY,
Jens Axboe005c5652007-08-02 22:21:36 +02001682 },
1683 {
Jens Axboe160b9662007-03-27 10:59:49 +02001684 .name = "verifysort",
1685 .type = FIO_OPT_BOOL,
1686 .off1 = td_var_offset(verifysort),
1687 .help = "Sort written verify blocks for read back",
1688 .def = "1",
Jens Axboec83f2df2007-07-31 22:51:47 +02001689 .parent = "verify",
Jens Axboec9c63312012-03-12 10:46:43 +01001690 .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY,
Jens Axboe160b9662007-03-27 10:59:49 +02001691 },
1692 {
Jens Axboea59e1702007-07-30 08:53:27 +02001693 .name = "verify_interval",
Jens Axboee01b22b2009-06-09 15:43:25 +02001694 .type = FIO_OPT_INT,
Jens Axboea59e1702007-07-30 08:53:27 +02001695 .off1 = td_var_offset(verify_interval),
Jens Axboe819a9682007-07-28 21:30:31 +02001696 .minval = 2 * sizeof(struct verify_header),
Jens Axboea59e1702007-07-30 08:53:27 +02001697 .help = "Store verify buffer header every N bytes",
Jens Axboeafdf9352007-07-31 16:14:34 +02001698 .parent = "verify",
Jens Axboec9c63312012-03-12 10:46:43 +01001699 .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY,
Shawn Lewis3f9f4e22007-07-28 21:10:37 +02001700 },
1701 {
Jens Axboea59e1702007-07-30 08:53:27 +02001702 .name = "verify_offset",
Jens Axboee01b22b2009-06-09 15:43:25 +02001703 .type = FIO_OPT_INT,
Jens Axboea59e1702007-07-30 08:53:27 +02001704 .help = "Offset verify header location by N bytes",
Shawn Lewis546a9142007-07-28 21:11:37 +02001705 .def = "0",
Jens Axboe5ec10ea2008-03-06 15:42:00 +01001706 .cb = str_verify_offset_cb,
Jens Axboeafdf9352007-07-31 16:14:34 +02001707 .parent = "verify",
Jens Axboec9c63312012-03-12 10:46:43 +01001708 .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY,
Shawn Lewis546a9142007-07-28 21:11:37 +02001709 },
1710 {
Shawn Lewise28218f2008-01-16 11:01:33 +01001711 .name = "verify_pattern",
Radha Ramachandran0e92f872009-10-27 20:14:27 +01001712 .type = FIO_OPT_STR,
Shawn Lewise28218f2008-01-16 11:01:33 +01001713 .cb = str_verify_pattern_cb,
1714 .help = "Fill pattern for IO buffers",
1715 .parent = "verify",
Jens Axboec9c63312012-03-12 10:46:43 +01001716 .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY,
Shawn Lewise28218f2008-01-16 11:01:33 +01001717 },
1718 {
Jens Axboea12a3b42007-08-09 10:20:54 +02001719 .name = "verify_fatal",
Jens Axboe68e1f292007-08-10 10:32:14 +02001720 .type = FIO_OPT_BOOL,
Jens Axboea12a3b42007-08-09 10:20:54 +02001721 .off1 = td_var_offset(verify_fatal),
1722 .def = "0",
1723 .help = "Exit on a single verify failure, don't continue",
1724 .parent = "verify",
Jens Axboec9c63312012-03-12 10:46:43 +01001725 .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY | FIO_OPT_G_ERR,
Jens Axboea12a3b42007-08-09 10:20:54 +02001726 },
1727 {
Jens Axboeb463e932011-01-12 09:03:23 +01001728 .name = "verify_dump",
1729 .type = FIO_OPT_BOOL,
1730 .off1 = td_var_offset(verify_dump),
Jens Axboeef71e312011-10-25 22:43:36 +02001731 .def = "0",
Jens Axboeb463e932011-01-12 09:03:23 +01001732 .help = "Dump contents of good and bad blocks on failure",
1733 .parent = "verify",
Jens Axboec9c63312012-03-12 10:46:43 +01001734 .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY | FIO_OPT_G_ERR,
Jens Axboeb463e932011-01-12 09:03:23 +01001735 },
1736 {
Jens Axboee8462bd2009-07-06 12:59:04 +02001737 .name = "verify_async",
1738 .type = FIO_OPT_INT,
1739 .off1 = td_var_offset(verify_async),
1740 .def = "0",
1741 .help = "Number of async verifier threads to use",
1742 .parent = "verify",
Jens Axboec9c63312012-03-12 10:46:43 +01001743 .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY,
Jens Axboee8462bd2009-07-06 12:59:04 +02001744 },
Jens Axboe9e144182010-06-15 14:25:36 +02001745 {
1746 .name = "verify_backlog",
1747 .type = FIO_OPT_STR_VAL,
1748 .off1 = td_var_offset(verify_backlog),
1749 .help = "Verify after this number of blocks are written",
1750 .parent = "verify",
Jens Axboec9c63312012-03-12 10:46:43 +01001751 .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY,
Jens Axboe9e144182010-06-15 14:25:36 +02001752 },
1753 {
1754 .name = "verify_backlog_batch",
1755 .type = FIO_OPT_INT,
1756 .off1 = td_var_offset(verify_batch),
1757 .help = "Verify this number of IO blocks",
Jens Axboe0d29de82010-09-01 13:54:15 +02001758 .parent = "verify",
Jens Axboec9c63312012-03-12 10:46:43 +01001759 .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY,
Jens Axboe9e144182010-06-15 14:25:36 +02001760 },
Jens Axboee8462bd2009-07-06 12:59:04 +02001761#ifdef FIO_HAVE_CPU_AFFINITY
1762 {
1763 .name = "verify_async_cpus",
1764 .type = FIO_OPT_STR,
1765 .cb = str_verify_cpus_allowed_cb,
1766 .help = "Set CPUs allowed for async verify threads",
1767 .parent = "verify_async",
Jens Axboec9c63312012-03-12 10:46:43 +01001768 .category = FIO_OPT_G_OS | FIO_OPT_G_CPU | FIO_OPT_G_VERIFY,
Jens Axboee8462bd2009-07-06 12:59:04 +02001769 },
1770#endif
Jens Axboe0d29de82010-09-01 13:54:15 +02001771#ifdef FIO_HAVE_TRIM
1772 {
1773 .name = "trim_percentage",
1774 .type = FIO_OPT_INT,
1775 .cb = str_verify_trim_cb,
1776 .maxval = 100,
1777 .help = "Number of verify blocks to discard/trim",
1778 .parent = "verify",
1779 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001780 .category = FIO_OPT_G_IO,
Jens Axboe0d29de82010-09-01 13:54:15 +02001781 },
1782 {
1783 .name = "trim_verify_zero",
1784 .type = FIO_OPT_INT,
1785 .help = "Verify that trim/discarded blocks are returned as zeroes",
1786 .off1 = td_var_offset(trim_zero),
1787 .parent = "trim_percentage",
1788 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01001789 .category = FIO_OPT_G_IO,
Jens Axboe0d29de82010-09-01 13:54:15 +02001790 },
1791 {
1792 .name = "trim_backlog",
1793 .type = FIO_OPT_STR_VAL,
1794 .off1 = td_var_offset(trim_backlog),
1795 .help = "Trim after this number of blocks are written",
1796 .parent = "trim_percentage",
Jens Axboec9c63312012-03-12 10:46:43 +01001797 .category = FIO_OPT_G_IO,
Jens Axboe0d29de82010-09-01 13:54:15 +02001798 },
1799 {
1800 .name = "trim_backlog_batch",
1801 .type = FIO_OPT_INT,
1802 .off1 = td_var_offset(trim_batch),
1803 .help = "Trim this number of IO blocks",
1804 .parent = "trim_percentage",
Jens Axboec9c63312012-03-12 10:46:43 +01001805 .category = FIO_OPT_G_IO,
Jens Axboe0d29de82010-09-01 13:54:15 +02001806 },
1807#endif
Jens Axboee8462bd2009-07-06 12:59:04 +02001808 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001809 .name = "write_iolog",
1810 .type = FIO_OPT_STR_STORE,
1811 .off1 = td_var_offset(write_iolog_file),
1812 .help = "Store IO pattern to file",
Jens Axboec9c63312012-03-12 10:46:43 +01001813 .category = FIO_OPT_G_IO | FIO_OPT_G_LOG,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001814 },
1815 {
1816 .name = "read_iolog",
1817 .type = FIO_OPT_STR_STORE,
1818 .off1 = td_var_offset(read_iolog_file),
1819 .help = "Playback IO pattern from file",
Jens Axboec9c63312012-03-12 10:46:43 +01001820 .category = FIO_OPT_G_IO | FIO_OPT_G_LOG,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001821 },
1822 {
David Nellans64bbb862010-08-24 22:13:30 +02001823 .name = "replay_no_stall",
1824 .type = FIO_OPT_INT,
1825 .off1 = td_var_offset(no_stall),
1826 .def = "0",
Jens Axboe87e7a972010-08-25 09:01:25 +02001827 .parent = "read_iolog",
David Nellans64bbb862010-08-24 22:13:30 +02001828 .help = "Playback IO pattern file as fast as possible without stalls",
Jens Axboec9c63312012-03-12 10:46:43 +01001829 .category = FIO_OPT_G_IO | FIO_OPT_G_LOG,
David Nellans64bbb862010-08-24 22:13:30 +02001830 },
1831 {
David Nellansd1c46c02010-08-31 21:20:47 +02001832 .name = "replay_redirect",
1833 .type = FIO_OPT_STR_STORE,
1834 .off1 = td_var_offset(replay_redirect),
1835 .parent = "read_iolog",
1836 .help = "Replay all I/O onto this device, regardless of trace device",
Jens Axboec9c63312012-03-12 10:46:43 +01001837 .category = FIO_OPT_G_IO | FIO_OPT_G_LOG,
David Nellansd1c46c02010-08-31 21:20:47 +02001838 },
1839 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001840 .name = "exec_prerun",
1841 .type = FIO_OPT_STR_STORE,
1842 .off1 = td_var_offset(exec_prerun),
1843 .help = "Execute this file prior to running job",
Jens Axboec9c63312012-03-12 10:46:43 +01001844 .category = FIO_OPT_G_MISC | FIO_OPT_G_OS,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001845 },
1846 {
1847 .name = "exec_postrun",
1848 .type = FIO_OPT_STR_STORE,
1849 .off1 = td_var_offset(exec_postrun),
1850 .help = "Execute this file after running job",
Jens Axboec9c63312012-03-12 10:46:43 +01001851 .category = FIO_OPT_G_MISC | FIO_OPT_G_OS,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001852 },
1853#ifdef FIO_HAVE_IOSCHED_SWITCH
1854 {
1855 .name = "ioscheduler",
1856 .type = FIO_OPT_STR_STORE,
1857 .off1 = td_var_offset(ioscheduler),
1858 .help = "Use this IO scheduler on the backing device",
Jens Axboec9c63312012-03-12 10:46:43 +01001859 .category = FIO_OPT_G_OS | FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001860 },
1861#endif
1862 {
1863 .name = "zonesize",
1864 .type = FIO_OPT_STR_VAL,
1865 .off1 = td_var_offset(zone_size),
Steven Noonaned335852012-01-31 13:58:00 +01001866 .help = "Amount of data to read per zone",
1867 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001868 .category = FIO_OPT_G_IO | FIO_OPT_G_ZONE,
Steven Noonaned335852012-01-31 13:58:00 +01001869 },
1870 {
1871 .name = "zonerange",
1872 .type = FIO_OPT_STR_VAL,
1873 .off1 = td_var_offset(zone_range),
Jens Axboe214e1ec2007-03-15 10:48:13 +01001874 .help = "Give size of an IO zone",
1875 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001876 .category = FIO_OPT_G_IO | FIO_OPT_G_ZONE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001877 },
1878 {
1879 .name = "zoneskip",
1880 .type = FIO_OPT_STR_VAL,
1881 .off1 = td_var_offset(zone_skip),
1882 .help = "Space between IO zones",
1883 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001884 .category = FIO_OPT_G_IO | FIO_OPT_G_ZONE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001885 },
1886 {
1887 .name = "lockmem",
1888 .type = FIO_OPT_STR_VAL,
1889 .cb = str_lockmem_cb,
1890 .help = "Lock down this amount of memory",
1891 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001892 .category = FIO_OPT_G_OS | FIO_OPT_G_MEM,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001893 },
1894 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001895 .name = "rwmixread",
1896 .type = FIO_OPT_INT,
Jens Axboecb499fc2008-05-28 10:33:32 +02001897 .cb = str_rwmix_read_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001898 .maxval = 100,
1899 .help = "Percentage of mixed workload that is reads",
1900 .def = "50",
Jens Axboec9c63312012-03-12 10:46:43 +01001901 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001902 },
1903 {
1904 .name = "rwmixwrite",
1905 .type = FIO_OPT_INT,
Jens Axboecb499fc2008-05-28 10:33:32 +02001906 .cb = str_rwmix_write_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001907 .maxval = 100,
1908 .help = "Percentage of mixed workload that is writes",
1909 .def = "50",
Jens Axboec9c63312012-03-12 10:46:43 +01001910 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001911 },
1912 {
Jens Axboeafdf9352007-07-31 16:14:34 +02001913 .name = "rwmixcycle",
Jens Axboe15ca1502008-04-07 09:26:02 +02001914 .type = FIO_OPT_DEPRECATED,
Jens Axboec9c63312012-03-12 10:46:43 +01001915 .category = FIO_OPT_G_IO,
Jens Axboeafdf9352007-07-31 16:14:34 +02001916 },
1917 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001918 .name = "nice",
1919 .type = FIO_OPT_INT,
1920 .off1 = td_var_offset(nice),
1921 .help = "Set job CPU nice value",
1922 .minval = -19,
1923 .maxval = 20,
1924 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001925 .category = FIO_OPT_G_OS | FIO_OPT_G_CPU,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001926 },
1927#ifdef FIO_HAVE_IOPRIO
1928 {
1929 .name = "prio",
1930 .type = FIO_OPT_INT,
1931 .cb = str_prio_cb,
1932 .help = "Set job IO priority value",
1933 .minval = 0,
1934 .maxval = 7,
Jens Axboec9c63312012-03-12 10:46:43 +01001935 .category = FIO_OPT_G_OS | FIO_OPT_G_CPU,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001936 },
1937 {
1938 .name = "prioclass",
1939 .type = FIO_OPT_INT,
1940 .cb = str_prioclass_cb,
1941 .help = "Set job IO priority class",
1942 .minval = 0,
1943 .maxval = 3,
Jens Axboec9c63312012-03-12 10:46:43 +01001944 .category = FIO_OPT_G_OS | FIO_OPT_G_CPU,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001945 },
1946#endif
1947 {
1948 .name = "thinktime",
1949 .type = FIO_OPT_INT,
1950 .off1 = td_var_offset(thinktime),
1951 .help = "Idle time between IO buffers (usec)",
1952 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01001953 .category = FIO_OPT_G_MISC,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001954 },
1955 {
1956 .name = "thinktime_spin",
1957 .type = FIO_OPT_INT,
1958 .off1 = td_var_offset(thinktime_spin),
1959 .help = "Start think time by spinning this amount (usec)",
1960 .def = "0",
Jens Axboeafdf9352007-07-31 16:14:34 +02001961 .parent = "thinktime",
Jens Axboec9c63312012-03-12 10:46:43 +01001962 .category = FIO_OPT_G_MISC,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001963 },
1964 {
1965 .name = "thinktime_blocks",
1966 .type = FIO_OPT_INT,
1967 .off1 = td_var_offset(thinktime_blocks),
1968 .help = "IO buffer period between 'thinktime'",
1969 .def = "1",
Jens Axboeafdf9352007-07-31 16:14:34 +02001970 .parent = "thinktime",
Jens Axboec9c63312012-03-12 10:46:43 +01001971 .category = FIO_OPT_G_MISC,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001972 },
1973 {
1974 .name = "rate",
Jens Axboee01b22b2009-06-09 15:43:25 +02001975 .type = FIO_OPT_INT,
Jens Axboe581e7142009-06-09 12:47:16 +02001976 .off1 = td_var_offset(rate[0]),
1977 .off2 = td_var_offset(rate[1]),
Jens Axboe214e1ec2007-03-15 10:48:13 +01001978 .help = "Set bandwidth rate",
Jens Axboec9c63312012-03-12 10:46:43 +01001979 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001980 },
1981 {
1982 .name = "ratemin",
Jens Axboee01b22b2009-06-09 15:43:25 +02001983 .type = FIO_OPT_INT,
Jens Axboe581e7142009-06-09 12:47:16 +02001984 .off1 = td_var_offset(ratemin[0]),
1985 .off2 = td_var_offset(ratemin[1]),
Jens Axboe4e991c22007-03-15 11:41:11 +01001986 .help = "Job must meet this rate or it will be shutdown",
Jens Axboeafdf9352007-07-31 16:14:34 +02001987 .parent = "rate",
Jens Axboec9c63312012-03-12 10:46:43 +01001988 .category = FIO_OPT_G_IO,
Jens Axboe4e991c22007-03-15 11:41:11 +01001989 },
1990 {
1991 .name = "rate_iops",
Jens Axboee01b22b2009-06-09 15:43:25 +02001992 .type = FIO_OPT_INT,
Jens Axboe581e7142009-06-09 12:47:16 +02001993 .off1 = td_var_offset(rate_iops[0]),
1994 .off2 = td_var_offset(rate_iops[1]),
Jens Axboe4e991c22007-03-15 11:41:11 +01001995 .help = "Limit IO used to this number of IO operations/sec",
Jens Axboec9c63312012-03-12 10:46:43 +01001996 .category = FIO_OPT_G_IO,
Jens Axboe4e991c22007-03-15 11:41:11 +01001997 },
1998 {
1999 .name = "rate_iops_min",
Jens Axboee01b22b2009-06-09 15:43:25 +02002000 .type = FIO_OPT_INT,
Jens Axboe581e7142009-06-09 12:47:16 +02002001 .off1 = td_var_offset(rate_iops_min[0]),
2002 .off2 = td_var_offset(rate_iops_min[1]),
Bruce Cran03e20d62011-01-02 20:14:54 +01002003 .help = "Job must meet this rate or it will be shut down",
Jens Axboeafdf9352007-07-31 16:14:34 +02002004 .parent = "rate_iops",
Jens Axboec9c63312012-03-12 10:46:43 +01002005 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002006 },
2007 {
2008 .name = "ratecycle",
2009 .type = FIO_OPT_INT,
2010 .off1 = td_var_offset(ratecycle),
2011 .help = "Window average for rate limits (msec)",
2012 .def = "1000",
Jens Axboeafdf9352007-07-31 16:14:34 +02002013 .parent = "rate",
Jens Axboec9c63312012-03-12 10:46:43 +01002014 .category = FIO_OPT_G_IO,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002015 },
2016 {
2017 .name = "invalidate",
2018 .type = FIO_OPT_BOOL,
2019 .off1 = td_var_offset(invalidate_cache),
2020 .help = "Invalidate buffer/page cache prior to running job",
2021 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01002022 .category = FIO_OPT_G_IO | FIO_OPT_G_CACHE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002023 },
2024 {
2025 .name = "sync",
2026 .type = FIO_OPT_BOOL,
2027 .off1 = td_var_offset(sync_io),
2028 .help = "Use O_SYNC for buffered writes",
2029 .def = "0",
Jens Axboe67a10002007-07-31 23:12:16 +02002030 .parent = "buffered",
Jens Axboec9c63312012-03-12 10:46:43 +01002031 .category = FIO_OPT_G_IO | FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002032 },
2033 {
2034 .name = "bwavgtime",
2035 .type = FIO_OPT_INT,
2036 .off1 = td_var_offset(bw_avg_time),
Jens Axboe5ec10ea2008-03-06 15:42:00 +01002037 .help = "Time window over which to calculate bandwidth"
2038 " (msec)",
Jens Axboe214e1ec2007-03-15 10:48:13 +01002039 .def = "500",
Jens Axboec8eeb9d2011-10-05 14:02:22 +02002040 .parent = "write_bw_log",
Jens Axboec9c63312012-03-12 10:46:43 +01002041 .category = FIO_OPT_G_LOG | FIO_OPT_G_STAT,
Jens Axboec8eeb9d2011-10-05 14:02:22 +02002042 },
2043 {
2044 .name = "iopsavgtime",
2045 .type = FIO_OPT_INT,
2046 .off1 = td_var_offset(iops_avg_time),
2047 .help = "Time window over which to calculate IOPS (msec)",
2048 .def = "500",
2049 .parent = "write_iops_log",
Jens Axboec9c63312012-03-12 10:46:43 +01002050 .category = FIO_OPT_G_LOG | FIO_OPT_G_STAT,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002051 },
2052 {
2053 .name = "create_serialize",
2054 .type = FIO_OPT_BOOL,
2055 .off1 = td_var_offset(create_serialize),
2056 .help = "Serialize creating of job files",
2057 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01002058 .category = FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002059 },
2060 {
2061 .name = "create_fsync",
2062 .type = FIO_OPT_BOOL,
2063 .off1 = td_var_offset(create_fsync),
Bruce Cran03e20d62011-01-02 20:14:54 +01002064 .help = "fsync file after creation",
Jens Axboe214e1ec2007-03-15 10:48:13 +01002065 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01002066 .category = FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002067 },
2068 {
Jens Axboe814452b2009-03-04 12:53:13 +01002069 .name = "create_on_open",
2070 .type = FIO_OPT_BOOL,
2071 .off1 = td_var_offset(create_on_open),
2072 .help = "Create files when they are opened for IO",
2073 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002074 .category = FIO_OPT_G_FILE,
Jens Axboe814452b2009-03-04 12:53:13 +01002075 },
Jens Axboe0b9d69e2009-09-11 22:29:54 +02002076 {
Zhang, Yanminafad68f2009-05-20 11:30:55 +02002077 .name = "pre_read",
2078 .type = FIO_OPT_BOOL,
2079 .off1 = td_var_offset(pre_read),
Bruce Cran03e20d62011-01-02 20:14:54 +01002080 .help = "Pre-read files before starting official testing",
Zhang, Yanminafad68f2009-05-20 11:30:55 +02002081 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002082 .category = FIO_OPT_G_FILE | FIO_OPT_G_CACHE,
Zhang, Yanminafad68f2009-05-20 11:30:55 +02002083 },
Jens Axboe814452b2009-03-04 12:53:13 +01002084 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01002085 .name = "cpuload",
2086 .type = FIO_OPT_INT,
2087 .off1 = td_var_offset(cpuload),
2088 .help = "Use this percentage of CPU",
Jens Axboec9c63312012-03-12 10:46:43 +01002089 .category = FIO_OPT_G_CPU,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002090 },
2091 {
2092 .name = "cpuchunks",
2093 .type = FIO_OPT_INT,
2094 .off1 = td_var_offset(cpucycle),
2095 .help = "Length of the CPU burn cycles (usecs)",
2096 .def = "50000",
Jens Axboe67a10002007-07-31 23:12:16 +02002097 .parent = "cpuload",
Jens Axboec9c63312012-03-12 10:46:43 +01002098 .category = FIO_OPT_G_CPU,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002099 },
2100#ifdef FIO_HAVE_CPU_AFFINITY
2101 {
2102 .name = "cpumask",
2103 .type = FIO_OPT_INT,
2104 .cb = str_cpumask_cb,
2105 .help = "CPU affinity mask",
Jens Axboec9c63312012-03-12 10:46:43 +01002106 .category = FIO_OPT_G_CPU | FIO_OPT_G_OS,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002107 },
Jens Axboed2e268b2007-06-15 10:33:49 +02002108 {
2109 .name = "cpus_allowed",
2110 .type = FIO_OPT_STR,
2111 .cb = str_cpus_allowed_cb,
2112 .help = "Set CPUs allowed",
Jens Axboec9c63312012-03-12 10:46:43 +01002113 .category = FIO_OPT_G_CPU | FIO_OPT_G_OS,
Jens Axboed2e268b2007-06-15 10:33:49 +02002114 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01002115#endif
2116 {
2117 .name = "end_fsync",
2118 .type = FIO_OPT_BOOL,
2119 .off1 = td_var_offset(end_fsync),
2120 .help = "Include fsync at the end of job",
2121 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002122 .category = FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002123 },
2124 {
2125 .name = "fsync_on_close",
2126 .type = FIO_OPT_BOOL,
2127 .off1 = td_var_offset(fsync_on_close),
2128 .help = "fsync files on close",
2129 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002130 .category = FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002131 },
2132 {
2133 .name = "unlink",
2134 .type = FIO_OPT_BOOL,
2135 .off1 = td_var_offset(unlink),
2136 .help = "Unlink created files after job has completed",
2137 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002138 .category = FIO_OPT_G_FILE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002139 },
2140 {
2141 .name = "exitall",
2142 .type = FIO_OPT_STR_SET,
2143 .cb = str_exitall_cb,
2144 .help = "Terminate all jobs when one exits",
Jens Axboec9c63312012-03-12 10:46:43 +01002145 .category = FIO_OPT_G_MISC | FIO_OPT_G_JOB,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002146 },
2147 {
2148 .name = "stonewall",
Jens Axboed3923652011-08-03 12:38:39 +02002149 .alias = "wait_for_previous",
Jens Axboe214e1ec2007-03-15 10:48:13 +01002150 .type = FIO_OPT_STR_SET,
2151 .off1 = td_var_offset(stonewall),
2152 .help = "Insert a hard barrier between this job and previous",
Jens Axboec9c63312012-03-12 10:46:43 +01002153 .category = FIO_OPT_G_MISC | FIO_OPT_G_JOB,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002154 },
2155 {
Jens Axboeb3d62a72007-03-20 14:23:26 +01002156 .name = "new_group",
2157 .type = FIO_OPT_STR_SET,
2158 .off1 = td_var_offset(new_group),
2159 .help = "Mark the start of a new group (for reporting)",
Jens Axboec9c63312012-03-12 10:46:43 +01002160 .category = FIO_OPT_G_MISC | FIO_OPT_G_JOB,
Jens Axboeb3d62a72007-03-20 14:23:26 +01002161 },
2162 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01002163 .name = "thread",
2164 .type = FIO_OPT_STR_SET,
2165 .off1 = td_var_offset(use_thread),
2166 .help = "Use threads instead of forks",
Jens Axboec9c63312012-03-12 10:46:43 +01002167 .category = FIO_OPT_G_MISC | FIO_OPT_G_OS | FIO_OPT_G_JOB,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002168 },
2169 {
2170 .name = "write_bw_log",
Jens Axboee3cedca2008-11-19 19:57:52 +01002171 .type = FIO_OPT_STR,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002172 .off1 = td_var_offset(write_bw_log),
Jens Axboee3cedca2008-11-19 19:57:52 +01002173 .cb = str_write_bw_log_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002174 .help = "Write log of bandwidth during run",
Jens Axboec9c63312012-03-12 10:46:43 +01002175 .category = FIO_OPT_G_LOG,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002176 },
2177 {
2178 .name = "write_lat_log",
Jens Axboee3cedca2008-11-19 19:57:52 +01002179 .type = FIO_OPT_STR,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002180 .off1 = td_var_offset(write_lat_log),
Jens Axboee3cedca2008-11-19 19:57:52 +01002181 .cb = str_write_lat_log_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002182 .help = "Write log of latency during run",
Jens Axboec9c63312012-03-12 10:46:43 +01002183 .category = FIO_OPT_G_LOG,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002184 },
2185 {
Jens Axboec8eeb9d2011-10-05 14:02:22 +02002186 .name = "write_iops_log",
2187 .type = FIO_OPT_STR,
2188 .off1 = td_var_offset(write_iops_log),
2189 .cb = str_write_iops_log_cb,
2190 .help = "Write log of IOPS during run",
Jens Axboec9c63312012-03-12 10:46:43 +01002191 .category = FIO_OPT_G_LOG,
Jens Axboec8eeb9d2011-10-05 14:02:22 +02002192 },
2193 {
Jens Axboeb8bc8cb2011-12-01 09:04:31 +01002194 .name = "log_avg_msec",
2195 .type = FIO_OPT_INT,
2196 .off1 = td_var_offset(log_avg_msec),
2197 .help = "Average bw/iops/lat logs over this period of time",
2198 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002199 .category = FIO_OPT_G_LOG,
Jens Axboeb8bc8cb2011-12-01 09:04:31 +01002200 },
2201 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01002202 .name = "hugepage-size",
Jens Axboee01b22b2009-06-09 15:43:25 +02002203 .type = FIO_OPT_INT,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002204 .off1 = td_var_offset(hugepage_size),
2205 .help = "When using hugepages, specify size of each page",
Jens Axboe81179ee2011-10-04 12:42:06 +02002206 .def = __fio_stringify(FIO_HUGE_PAGE),
Jens Axboec9c63312012-03-12 10:46:43 +01002207 .category = FIO_OPT_G_OS | FIO_OPT_G_MEM,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002208 },
2209 {
2210 .name = "group_reporting",
2211 .type = FIO_OPT_STR_SET,
2212 .off1 = td_var_offset(group_reporting),
2213 .help = "Do reporting on a per-group basis",
Jens Axboec9c63312012-03-12 10:46:43 +01002214 .category = FIO_OPT_G_MISC,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002215 },
2216 {
Jens Axboee9459e52007-04-17 15:46:32 +02002217 .name = "zero_buffers",
2218 .type = FIO_OPT_STR_SET,
2219 .off1 = td_var_offset(zero_buffers),
2220 .help = "Init IO buffers to all zeroes",
Jens Axboec9c63312012-03-12 10:46:43 +01002221 .category = FIO_OPT_G_IO_BUF,
Jens Axboee9459e52007-04-17 15:46:32 +02002222 },
Jens Axboe5973caf2008-05-21 19:52:35 +02002223 {
2224 .name = "refill_buffers",
2225 .type = FIO_OPT_STR_SET,
2226 .off1 = td_var_offset(refill_buffers),
2227 .help = "Refill IO buffers on every IO submit",
Jens Axboec9c63312012-03-12 10:46:43 +01002228 .category = FIO_OPT_G_IO_BUF,
Jens Axboe5973caf2008-05-21 19:52:35 +02002229 },
Yu-ju Hong83349192011-08-13 00:53:44 +02002230 {
Jens Axboefd684182011-09-19 09:24:44 +02002231 .name = "scramble_buffers",
2232 .type = FIO_OPT_BOOL,
2233 .off1 = td_var_offset(scramble_buffers),
2234 .help = "Slightly scramble buffers on every IO submit",
2235 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01002236 .category = FIO_OPT_G_IO_BUF,
Jens Axboefd684182011-09-19 09:24:44 +02002237 },
2238 {
Jens Axboe9c426842012-03-02 21:02:12 +01002239 .name = "buffer_compress_percentage",
2240 .type = FIO_OPT_INT,
2241 .off1 = td_var_offset(compress_percentage),
2242 .maxval = 100,
2243 .minval = 1,
2244 .help = "How compressible the buffer is (approximately)",
Jens Axboe767a0a62012-03-16 19:08:39 +01002245 .category = FIO_OPT_G_IO_BUF,
Jens Axboe9c426842012-03-02 21:02:12 +01002246 },
2247 {
Jens Axboef97a43a2012-03-09 19:06:24 +01002248 .name = "buffer_compress_chunk",
2249 .type = FIO_OPT_INT,
2250 .off1 = td_var_offset(compress_chunk),
Jens Axboe207b18e2012-03-09 19:11:25 +01002251 .parent = "buffer_compress_percentage",
Jens Axboef97a43a2012-03-09 19:06:24 +01002252 .help = "Size of compressible region in buffer",
Jens Axboe767a0a62012-03-16 19:08:39 +01002253 .category = FIO_OPT_G_IO_BUF,
Jens Axboef97a43a2012-03-09 19:06:24 +01002254 },
2255 {
Yu-ju Hong83349192011-08-13 00:53:44 +02002256 .name = "clat_percentiles",
2257 .type = FIO_OPT_BOOL,
2258 .off1 = td_var_offset(clat_percentiles),
2259 .help = "Enable the reporting of completion latency percentiles",
Jens Axboe467b35e2011-10-13 08:53:24 +02002260 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01002261 .category = FIO_OPT_G_STAT,
Yu-ju Hong83349192011-08-13 00:53:44 +02002262 },
2263 {
2264 .name = "percentile_list",
2265 .type = FIO_OPT_FLOAT_LIST,
2266 .off1 = td_var_offset(percentile_list),
2267 .off2 = td_var_offset(overwrite_plist),
2268 .help = "Specify a custom list of percentiles to report",
2269 .maxlen = FIO_IO_U_LIST_MAX_LEN,
2270 .minfp = 0.0,
2271 .maxfp = 100.0,
Jens Axboec9c63312012-03-12 10:46:43 +01002272 .category = FIO_OPT_G_STAT,
Yu-ju Hong83349192011-08-13 00:53:44 +02002273 },
2274
Jens Axboe0a839f32007-04-26 09:02:34 +02002275#ifdef FIO_HAVE_DISK_UTIL
2276 {
2277 .name = "disk_util",
2278 .type = FIO_OPT_BOOL,
2279 .off1 = td_var_offset(do_disk_util),
Jens Axboef66ab3c2008-06-05 11:48:22 +02002280 .help = "Log disk utilization statistics",
Jens Axboe0a839f32007-04-26 09:02:34 +02002281 .def = "1",
Jens Axboec9c63312012-03-12 10:46:43 +01002282 .category = FIO_OPT_G_OS | FIO_OPT_G_STAT,
Jens Axboe0a839f32007-04-26 09:02:34 +02002283 },
2284#endif
Jens Axboee9459e52007-04-17 15:46:32 +02002285 {
Jens Axboe993bf482008-11-14 13:04:53 +01002286 .name = "gtod_reduce",
2287 .type = FIO_OPT_BOOL,
2288 .help = "Greatly reduce number of gettimeofday() calls",
2289 .cb = str_gtod_reduce_cb,
2290 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002291 .category = FIO_OPT_G_OS | FIO_OPT_G_MISC | FIO_OPT_G_STAT,
Jens Axboe993bf482008-11-14 13:04:53 +01002292 },
2293 {
Jens Axboe02af0982010-06-24 09:59:34 +02002294 .name = "disable_lat",
2295 .type = FIO_OPT_BOOL,
2296 .off1 = td_var_offset(disable_lat),
2297 .help = "Disable latency numbers",
2298 .parent = "gtod_reduce",
2299 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002300 .category = FIO_OPT_G_OS | FIO_OPT_G_MISC | FIO_OPT_G_STAT,
Jens Axboe02af0982010-06-24 09:59:34 +02002301 },
2302 {
Jens Axboe9520ebb2008-10-16 21:03:27 +02002303 .name = "disable_clat",
2304 .type = FIO_OPT_BOOL,
2305 .off1 = td_var_offset(disable_clat),
2306 .help = "Disable completion latency numbers",
Jens Axboe993bf482008-11-14 13:04:53 +01002307 .parent = "gtod_reduce",
Jens Axboe9520ebb2008-10-16 21:03:27 +02002308 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002309 .category = FIO_OPT_G_OS | FIO_OPT_G_MISC | FIO_OPT_G_STAT,
Jens Axboe9520ebb2008-10-16 21:03:27 +02002310 },
2311 {
2312 .name = "disable_slat",
2313 .type = FIO_OPT_BOOL,
2314 .off1 = td_var_offset(disable_slat),
Bruce Cran03e20d62011-01-02 20:14:54 +01002315 .help = "Disable submission latency numbers",
Jens Axboe993bf482008-11-14 13:04:53 +01002316 .parent = "gtod_reduce",
Jens Axboe9520ebb2008-10-16 21:03:27 +02002317 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002318 .category = FIO_OPT_G_OS | FIO_OPT_G_MISC | FIO_OPT_G_STAT,
Jens Axboe9520ebb2008-10-16 21:03:27 +02002319 },
2320 {
2321 .name = "disable_bw_measurement",
2322 .type = FIO_OPT_BOOL,
2323 .off1 = td_var_offset(disable_bw),
2324 .help = "Disable bandwidth logging",
Jens Axboe993bf482008-11-14 13:04:53 +01002325 .parent = "gtod_reduce",
Jens Axboe9520ebb2008-10-16 21:03:27 +02002326 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002327 .category = FIO_OPT_G_OS | FIO_OPT_G_MISC | FIO_OPT_G_STAT,
Jens Axboe9520ebb2008-10-16 21:03:27 +02002328 },
2329 {
Jens Axboebe4ecfd2008-12-08 14:10:52 +01002330 .name = "gtod_cpu",
2331 .type = FIO_OPT_INT,
2332 .cb = str_gtod_cpu_cb,
Bruce Cran03e20d62011-01-02 20:14:54 +01002333 .help = "Set up dedicated gettimeofday() thread on this CPU",
Jens Axboe29d43ff2009-07-01 10:42:18 +02002334 .verify = gtod_cpu_verify,
Jens Axboec9c63312012-03-12 10:46:43 +01002335 .category = FIO_OPT_G_OS | FIO_OPT_G_MISC | FIO_OPT_G_STAT,
Jens Axboebe4ecfd2008-12-08 14:10:52 +01002336 },
2337 {
Radha Ramachandranf2bba182009-06-15 08:40:16 +02002338 .name = "continue_on_error",
Steven Lang06842022011-11-17 09:45:17 +01002339 .type = FIO_OPT_STR,
Radha Ramachandranf2bba182009-06-15 08:40:16 +02002340 .off1 = td_var_offset(continue_on_error),
Bruce Cran03e20d62011-01-02 20:14:54 +01002341 .help = "Continue on non-fatal errors during IO",
Steven Lang06842022011-11-17 09:45:17 +01002342 .def = "none",
Jens Axboec9c63312012-03-12 10:46:43 +01002343 .category = FIO_OPT_G_MISC | FIO_OPT_G_ERR,
Steven Lang06842022011-11-17 09:45:17 +01002344 .posval = {
2345 { .ival = "none",
2346 .oval = ERROR_TYPE_NONE,
2347 .help = "Exit when an error is encountered",
2348 },
2349 { .ival = "read",
2350 .oval = ERROR_TYPE_READ,
2351 .help = "Continue on read errors only",
2352 },
2353 { .ival = "write",
2354 .oval = ERROR_TYPE_WRITE,
2355 .help = "Continue on write errors only",
2356 },
2357 { .ival = "io",
2358 .oval = ERROR_TYPE_READ | ERROR_TYPE_WRITE,
2359 .help = "Continue on any IO errors",
2360 },
2361 { .ival = "verify",
2362 .oval = ERROR_TYPE_VERIFY,
2363 .help = "Continue on verify errors only",
2364 },
2365 { .ival = "all",
2366 .oval = ERROR_TYPE_ANY,
2367 .help = "Continue on all io and verify errors",
2368 },
2369 { .ival = "0",
2370 .oval = ERROR_TYPE_NONE,
2371 .help = "Alias for 'none'",
2372 },
2373 { .ival = "1",
2374 .oval = ERROR_TYPE_ANY,
2375 .help = "Alias for 'all'",
2376 },
2377 },
Radha Ramachandranf2bba182009-06-15 08:40:16 +02002378 },
2379 {
Jens Axboe9ac8a792009-11-13 21:23:07 +01002380 .name = "profile",
Jens Axboe79d16312010-03-04 12:43:20 +01002381 .type = FIO_OPT_STR_STORE,
Jens Axboe9ac8a792009-11-13 21:23:07 +01002382 .off1 = td_var_offset(profile),
Jens Axboe9ac8a792009-11-13 21:23:07 +01002383 .help = "Select a specific builtin performance test",
Jens Axboec9c63312012-03-12 10:46:43 +01002384 .category = FIO_OPT_G_MISC | FIO_OPT_G_JOB,
Jens Axboe9ac8a792009-11-13 21:23:07 +01002385 },
2386 {
Jens Axboea696fa22009-12-04 10:05:02 +01002387 .name = "cgroup",
2388 .type = FIO_OPT_STR_STORE,
2389 .off1 = td_var_offset(cgroup),
2390 .help = "Add job to cgroup of this name",
Jens Axboec9c63312012-03-12 10:46:43 +01002391 .category = FIO_OPT_G_MISC | FIO_OPT_G_OS,
Jens Axboea696fa22009-12-04 10:05:02 +01002392 },
2393 {
2394 .name = "cgroup_weight",
2395 .type = FIO_OPT_INT,
2396 .off1 = td_var_offset(cgroup_weight),
2397 .help = "Use given weight for cgroup",
2398 .minval = 100,
2399 .maxval = 1000,
Jens Axboec9c63312012-03-12 10:46:43 +01002400 .category = FIO_OPT_G_MISC | FIO_OPT_G_OS,
Jens Axboea696fa22009-12-04 10:05:02 +01002401 },
2402 {
Vivek Goyal7de87092010-03-31 22:55:15 +02002403 .name = "cgroup_nodelete",
2404 .type = FIO_OPT_BOOL,
2405 .off1 = td_var_offset(cgroup_nodelete),
2406 .help = "Do not delete cgroups after job completion",
2407 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002408 .category = FIO_OPT_G_MISC | FIO_OPT_G_OS,
Vivek Goyal7de87092010-03-31 22:55:15 +02002409 },
2410 {
Jens Axboee0b0d892009-12-08 10:10:14 +01002411 .name = "uid",
2412 .type = FIO_OPT_INT,
2413 .off1 = td_var_offset(uid),
2414 .help = "Run job with this user ID",
Jens Axboec9c63312012-03-12 10:46:43 +01002415 .category = FIO_OPT_G_OS | FIO_OPT_G_JOB,
Jens Axboee0b0d892009-12-08 10:10:14 +01002416 },
2417 {
2418 .name = "gid",
2419 .type = FIO_OPT_INT,
2420 .off1 = td_var_offset(gid),
2421 .help = "Run job with this group ID",
Jens Axboec9c63312012-03-12 10:46:43 +01002422 .category = FIO_OPT_G_OS | FIO_OPT_G_JOB,
Jens Axboee0b0d892009-12-08 10:10:14 +01002423 },
2424 {
Dan Ehrenberg9e684a42012-02-20 11:05:14 +01002425 .name = "flow_id",
2426 .type = FIO_OPT_INT,
2427 .off1 = td_var_offset(flow_id),
2428 .help = "The flow index ID to use",
2429 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002430 .category = FIO_OPT_G_IO,
Dan Ehrenberg9e684a42012-02-20 11:05:14 +01002431 },
2432 {
2433 .name = "flow",
2434 .type = FIO_OPT_INT,
2435 .off1 = td_var_offset(flow),
2436 .help = "Weight for flow control of this job",
2437 .parent = "flow_id",
2438 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002439 .category = FIO_OPT_G_IO,
Dan Ehrenberg9e684a42012-02-20 11:05:14 +01002440 },
2441 {
2442 .name = "flow_watermark",
2443 .type = FIO_OPT_INT,
2444 .off1 = td_var_offset(flow_watermark),
2445 .help = "High watermark for flow control. This option"
2446 " should be set to the same value for all threads"
2447 " with non-zero flow.",
2448 .parent = "flow_id",
2449 .def = "1024",
Jens Axboec9c63312012-03-12 10:46:43 +01002450 .category = FIO_OPT_G_IO,
Dan Ehrenberg9e684a42012-02-20 11:05:14 +01002451 },
2452 {
2453 .name = "flow_sleep",
2454 .type = FIO_OPT_INT,
2455 .off1 = td_var_offset(flow_sleep),
2456 .help = "How many microseconds to sleep after being held"
2457 " back by the flow control mechanism",
2458 .parent = "flow_id",
2459 .def = "0",
Jens Axboec9c63312012-03-12 10:46:43 +01002460 .category = FIO_OPT_G_IO,
Dan Ehrenberg9e684a42012-02-20 11:05:14 +01002461 },
2462 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01002463 .name = NULL,
2464 },
2465};
2466
Jens Axboe17af15d2010-04-13 10:38:16 +02002467static void add_to_lopt(struct option *lopt, struct fio_option *o,
Steven Langde890a12011-11-09 14:03:34 +01002468 const char *name, int val)
Jens Axboe9f817362010-03-04 14:38:10 +01002469{
Jens Axboe17af15d2010-04-13 10:38:16 +02002470 lopt->name = (char *) name;
Steven Langde890a12011-11-09 14:03:34 +01002471 lopt->val = val;
Jens Axboe9f817362010-03-04 14:38:10 +01002472 if (o->type == FIO_OPT_STR_SET)
2473 lopt->has_arg = no_argument;
2474 else
2475 lopt->has_arg = required_argument;
2476}
2477
Steven Langde890a12011-11-09 14:03:34 +01002478static void options_to_lopts(struct fio_option *opts,
2479 struct option *long_options,
2480 int i, int option_type)
2481{
2482 struct fio_option *o = &opts[0];
2483 while (o->name) {
2484 add_to_lopt(&long_options[i], o, o->name, option_type);
2485 if (o->alias) {
2486 i++;
2487 add_to_lopt(&long_options[i], o, o->alias, option_type);
2488 }
2489
2490 i++;
2491 o++;
2492 assert(i < FIO_NR_OPTIONS);
2493 }
2494}
2495
2496void fio_options_set_ioengine_opts(struct option *long_options,
2497 struct thread_data *td)
2498{
2499 unsigned int i;
2500
2501 i = 0;
2502 while (long_options[i].name) {
2503 if (long_options[i].val == FIO_GETOPT_IOENGINE) {
2504 memset(&long_options[i], 0, sizeof(*long_options));
2505 break;
2506 }
2507 i++;
2508 }
2509
2510 /*
2511 * Just clear out the prior ioengine options.
2512 */
2513 if (!td || !td->eo)
2514 return;
2515
2516 options_to_lopts(td->io_ops->options, long_options, i,
2517 FIO_GETOPT_IOENGINE);
2518}
2519
Jens Axboe214e1ec2007-03-15 10:48:13 +01002520void fio_options_dup_and_init(struct option *long_options)
2521{
Jens Axboe214e1ec2007-03-15 10:48:13 +01002522 unsigned int i;
2523
Jens Axboe9af4a242012-03-16 10:13:49 +01002524 options_init(fio_options);
Jens Axboe214e1ec2007-03-15 10:48:13 +01002525
2526 i = 0;
2527 while (long_options[i].name)
2528 i++;
2529
Jens Axboe9af4a242012-03-16 10:13:49 +01002530 options_to_lopts(fio_options, long_options, i, FIO_GETOPT_JOB);
Jens Axboe214e1ec2007-03-15 10:48:13 +01002531}
2532
Jens Axboe74929ac2009-08-05 11:42:37 +02002533struct fio_keyword {
2534 const char *word;
2535 const char *desc;
2536 char *replace;
2537};
2538
2539static struct fio_keyword fio_keywords[] = {
2540 {
2541 .word = "$pagesize",
2542 .desc = "Page size in the system",
2543 },
2544 {
2545 .word = "$mb_memory",
2546 .desc = "Megabytes of memory online",
2547 },
2548 {
2549 .word = "$ncpus",
2550 .desc = "Number of CPUs online in the system",
2551 },
2552 {
2553 .word = NULL,
2554 },
2555};
2556
2557void fio_keywords_init(void)
2558{
Jens Axboe3b2e1462009-12-15 08:58:10 +01002559 unsigned long long mb_memory;
Jens Axboe74929ac2009-08-05 11:42:37 +02002560 char buf[128];
2561 long l;
2562
2563 sprintf(buf, "%lu", page_size);
2564 fio_keywords[0].replace = strdup(buf);
2565
Jens Axboe8eb016d2011-07-11 10:24:20 +02002566 mb_memory = os_phys_mem() / (1024 * 1024);
Jens Axboe3b2e1462009-12-15 08:58:10 +01002567 sprintf(buf, "%llu", mb_memory);
Jens Axboe74929ac2009-08-05 11:42:37 +02002568 fio_keywords[1].replace = strdup(buf);
2569
Jens Axboec00a2282011-07-08 20:56:06 +02002570 l = cpus_online();
Jens Axboe74929ac2009-08-05 11:42:37 +02002571 sprintf(buf, "%lu", l);
2572 fio_keywords[2].replace = strdup(buf);
2573}
2574
Jens Axboe892a6ff2009-11-13 12:19:49 +01002575#define BC_APP "bc"
2576
2577static char *bc_calc(char *str)
2578{
Steven Langd0c814e2011-10-28 08:37:13 +02002579 char buf[128], *tmp;
Jens Axboe892a6ff2009-11-13 12:19:49 +01002580 FILE *f;
2581 int ret;
2582
2583 /*
2584 * No math, just return string
2585 */
Steven Langd0c814e2011-10-28 08:37:13 +02002586 if ((!strchr(str, '+') && !strchr(str, '-') && !strchr(str, '*') &&
2587 !strchr(str, '/')) || strchr(str, '\''))
Jens Axboe892a6ff2009-11-13 12:19:49 +01002588 return str;
2589
2590 /*
2591 * Split option from value, we only need to calculate the value
2592 */
2593 tmp = strchr(str, '=');
2594 if (!tmp)
2595 return str;
2596
2597 tmp++;
Jens Axboe892a6ff2009-11-13 12:19:49 +01002598
Steven Langd0c814e2011-10-28 08:37:13 +02002599 /*
2600 * Prevent buffer overflows; such a case isn't reasonable anyway
2601 */
2602 if (strlen(str) >= 128 || strlen(tmp) > 100)
2603 return str;
Jens Axboe892a6ff2009-11-13 12:19:49 +01002604
2605 sprintf(buf, "which %s > /dev/null", BC_APP);
2606 if (system(buf)) {
2607 log_err("fio: bc is needed for performing math\n");
Jens Axboe892a6ff2009-11-13 12:19:49 +01002608 return NULL;
2609 }
2610
Steven Langd0c814e2011-10-28 08:37:13 +02002611 sprintf(buf, "echo '%s' | %s", tmp, BC_APP);
Jens Axboe892a6ff2009-11-13 12:19:49 +01002612 f = popen(buf, "r");
2613 if (!f) {
Jens Axboe892a6ff2009-11-13 12:19:49 +01002614 return NULL;
2615 }
2616
Steven Langd0c814e2011-10-28 08:37:13 +02002617 ret = fread(&buf[tmp - str], 1, 128 - (tmp - str), f);
Jens Axboe892a6ff2009-11-13 12:19:49 +01002618 if (ret <= 0) {
Jens Axboe892a6ff2009-11-13 12:19:49 +01002619 return NULL;
2620 }
2621
Jens Axboe892a6ff2009-11-13 12:19:49 +01002622 pclose(f);
Steven Langd0c814e2011-10-28 08:37:13 +02002623 buf[(tmp - str) + ret - 1] = '\0';
2624 memcpy(buf, str, tmp - str);
Jens Axboe892a6ff2009-11-13 12:19:49 +01002625 free(str);
Steven Langd0c814e2011-10-28 08:37:13 +02002626 return strdup(buf);
2627}
2628
2629/*
2630 * Return a copy of the input string with substrings of the form ${VARNAME}
2631 * substituted with the value of the environment variable VARNAME. The
2632 * substitution always occurs, even if VARNAME is empty or the corresponding
2633 * environment variable undefined.
2634 */
2635static char *option_dup_subs(const char *opt)
2636{
2637 char out[OPT_LEN_MAX+1];
2638 char in[OPT_LEN_MAX+1];
2639 char *outptr = out;
2640 char *inptr = in;
2641 char *ch1, *ch2, *env;
2642 ssize_t nchr = OPT_LEN_MAX;
2643 size_t envlen;
2644
2645 if (strlen(opt) + 1 > OPT_LEN_MAX) {
2646 log_err("OPT_LEN_MAX (%d) is too small\n", OPT_LEN_MAX);
2647 return NULL;
2648 }
2649
2650 in[OPT_LEN_MAX] = '\0';
2651 strncpy(in, opt, OPT_LEN_MAX);
2652
2653 while (*inptr && nchr > 0) {
2654 if (inptr[0] == '$' && inptr[1] == '{') {
2655 ch2 = strchr(inptr, '}');
2656 if (ch2 && inptr+1 < ch2) {
2657 ch1 = inptr+2;
2658 inptr = ch2+1;
2659 *ch2 = '\0';
2660
2661 env = getenv(ch1);
2662 if (env) {
2663 envlen = strlen(env);
2664 if (envlen <= nchr) {
2665 memcpy(outptr, env, envlen);
2666 outptr += envlen;
2667 nchr -= envlen;
2668 }
2669 }
2670
2671 continue;
2672 }
2673 }
2674
2675 *outptr++ = *inptr++;
2676 --nchr;
2677 }
2678
2679 *outptr = '\0';
2680 return strdup(out);
Jens Axboe892a6ff2009-11-13 12:19:49 +01002681}
2682
Jens Axboe74929ac2009-08-05 11:42:37 +02002683/*
2684 * Look for reserved variable names and replace them with real values
2685 */
2686static char *fio_keyword_replace(char *opt)
2687{
2688 char *s;
2689 int i;
Steven Langd0c814e2011-10-28 08:37:13 +02002690 int docalc = 0;
Jens Axboe74929ac2009-08-05 11:42:37 +02002691
2692 for (i = 0; fio_keywords[i].word != NULL; i++) {
2693 struct fio_keyword *kw = &fio_keywords[i];
2694
2695 while ((s = strstr(opt, kw->word)) != NULL) {
2696 char *new = malloc(strlen(opt) + 1);
2697 char *o_org = opt;
2698 int olen = s - opt;
2699 int len;
2700
2701 /*
2702 * Copy part of the string before the keyword and
2703 * sprintf() the replacement after it.
2704 */
2705 memcpy(new, opt, olen);
2706 len = sprintf(new + olen, "%s", kw->replace);
2707
2708 /*
2709 * If there's more in the original string, copy that
2710 * in too
2711 */
2712 opt += strlen(kw->word) + olen;
2713 if (strlen(opt))
2714 memcpy(new + olen + len, opt, opt - o_org - 1);
2715
2716 /*
2717 * replace opt and free the old opt
2718 */
2719 opt = new;
Steven Langd0c814e2011-10-28 08:37:13 +02002720 free(o_org);
Jens Axboe7a958bd2009-11-13 12:33:54 +01002721
Steven Langd0c814e2011-10-28 08:37:13 +02002722 docalc = 1;
Jens Axboe74929ac2009-08-05 11:42:37 +02002723 }
2724 }
2725
Steven Langd0c814e2011-10-28 08:37:13 +02002726 /*
2727 * Check for potential math and invoke bc, if possible
2728 */
2729 if (docalc)
2730 opt = bc_calc(opt);
2731
Jens Axboe7a958bd2009-11-13 12:33:54 +01002732 return opt;
Jens Axboe74929ac2009-08-05 11:42:37 +02002733}
2734
Steven Langd0c814e2011-10-28 08:37:13 +02002735static char **dup_and_sub_options(char **opts, int num_opts)
2736{
2737 int i;
2738 char **opts_copy = malloc(num_opts * sizeof(*opts));
2739 for (i = 0; i < num_opts; i++) {
2740 opts_copy[i] = option_dup_subs(opts[i]);
2741 if (!opts_copy[i])
2742 continue;
2743 opts_copy[i] = fio_keyword_replace(opts_copy[i]);
2744 }
2745 return opts_copy;
2746}
2747
Jens Axboe3b8b7132008-06-10 19:46:23 +02002748int fio_options_parse(struct thread_data *td, char **opts, int num_opts)
Jens Axboe214e1ec2007-03-15 10:48:13 +01002749{
Steven Langde890a12011-11-09 14:03:34 +01002750 int i, ret, unknown;
Steven Langd0c814e2011-10-28 08:37:13 +02002751 char **opts_copy;
Jens Axboe3b8b7132008-06-10 19:46:23 +02002752
Jens Axboe9af4a242012-03-16 10:13:49 +01002753 sort_options(opts, fio_options, num_opts);
Steven Langd0c814e2011-10-28 08:37:13 +02002754 opts_copy = dup_and_sub_options(opts, num_opts);
Jens Axboe3b8b7132008-06-10 19:46:23 +02002755
Steven Langde890a12011-11-09 14:03:34 +01002756 for (ret = 0, i = 0, unknown = 0; i < num_opts; i++) {
2757 struct fio_option *o;
Jens Axboe9af4a242012-03-16 10:13:49 +01002758 int newret = parse_option(opts_copy[i], opts[i], fio_options,
2759 &o, td);
Steven Langd0c814e2011-10-28 08:37:13 +02002760
Steven Langde890a12011-11-09 14:03:34 +01002761 if (opts_copy[i]) {
2762 if (newret && !o) {
2763 unknown++;
2764 continue;
2765 }
Steven Langd0c814e2011-10-28 08:37:13 +02002766 free(opts_copy[i]);
Steven Langde890a12011-11-09 14:03:34 +01002767 opts_copy[i] = NULL;
2768 }
2769
2770 ret |= newret;
2771 }
2772
2773 if (unknown) {
2774 ret |= ioengine_load(td);
2775 if (td->eo) {
2776 sort_options(opts_copy, td->io_ops->options, num_opts);
2777 opts = opts_copy;
2778 }
2779 for (i = 0; i < num_opts; i++) {
2780 struct fio_option *o = NULL;
2781 int newret = 1;
2782 if (!opts_copy[i])
2783 continue;
2784
2785 if (td->eo)
2786 newret = parse_option(opts_copy[i], opts[i],
2787 td->io_ops->options, &o,
2788 td->eo);
2789
2790 ret |= newret;
2791 if (!o)
2792 log_err("Bad option <%s>\n", opts[i]);
2793
2794 free(opts_copy[i]);
2795 opts_copy[i] = NULL;
2796 }
Jens Axboe74929ac2009-08-05 11:42:37 +02002797 }
Jens Axboe3b8b7132008-06-10 19:46:23 +02002798
Steven Langd0c814e2011-10-28 08:37:13 +02002799 free(opts_copy);
Jens Axboe3b8b7132008-06-10 19:46:23 +02002800 return ret;
Jens Axboe214e1ec2007-03-15 10:48:13 +01002801}
2802
2803int fio_cmd_option_parse(struct thread_data *td, const char *opt, char *val)
2804{
Jens Axboe9af4a242012-03-16 10:13:49 +01002805 return parse_cmd_option(opt, val, fio_options, td);
Jens Axboe214e1ec2007-03-15 10:48:13 +01002806}
2807
Steven Langde890a12011-11-09 14:03:34 +01002808int fio_cmd_ioengine_option_parse(struct thread_data *td, const char *opt,
2809 char *val)
2810{
2811 return parse_cmd_option(opt, val, td->io_ops->options, td);
2812}
2813
Jens Axboe214e1ec2007-03-15 10:48:13 +01002814void fio_fill_default_options(struct thread_data *td)
2815{
Jens Axboe9af4a242012-03-16 10:13:49 +01002816 fill_default_options(td, fio_options);
Jens Axboe214e1ec2007-03-15 10:48:13 +01002817}
2818
2819int fio_show_option_help(const char *opt)
2820{
Jens Axboe9af4a242012-03-16 10:13:49 +01002821 return show_cmd_help(fio_options, opt);
Jens Axboe214e1ec2007-03-15 10:48:13 +01002822}
Jens Axboed23bb322007-03-23 15:57:56 +01002823
Steven Langde890a12011-11-09 14:03:34 +01002824void options_mem_dupe(void *data, struct fio_option *options)
2825{
2826 struct fio_option *o;
2827 char **ptr;
2828
2829 for (o = &options[0]; o->name; o++) {
2830 if (o->type != FIO_OPT_STR_STORE)
2831 continue;
2832
2833 ptr = td_var(data, o->off1);
2834 if (*ptr)
2835 *ptr = strdup(*ptr);
2836 }
2837}
2838
Jens Axboe7e356b22011-10-14 10:55:16 +02002839/*
2840 * dupe FIO_OPT_STR_STORE options
2841 */
Steven Langde890a12011-11-09 14:03:34 +01002842void fio_options_mem_dupe(struct thread_data *td)
Jens Axboed23bb322007-03-23 15:57:56 +01002843{
Jens Axboe9af4a242012-03-16 10:13:49 +01002844 options_mem_dupe(&td->o, fio_options);
Jens Axboe1647f592011-11-09 20:25:21 +01002845
2846 if (td->eo && td->io_ops) {
Steven Langde890a12011-11-09 14:03:34 +01002847 void *oldeo = td->eo;
Jens Axboe1647f592011-11-09 20:25:21 +01002848
Steven Langde890a12011-11-09 14:03:34 +01002849 td->eo = malloc(td->io_ops->option_struct_size);
2850 memcpy(td->eo, oldeo, td->io_ops->option_struct_size);
2851 options_mem_dupe(td->eo, td->io_ops->options);
Jens Axboed23bb322007-03-23 15:57:56 +01002852 }
2853}
2854
Jens Axboed6978a32009-07-18 21:04:09 +02002855unsigned int fio_get_kb_base(void *data)
2856{
2857 struct thread_data *td = data;
2858 unsigned int kb_base = 0;
2859
2860 if (td)
2861 kb_base = td->o.kb_base;
2862 if (!kb_base)
2863 kb_base = 1024;
2864
2865 return kb_base;
2866}
Jens Axboe9f988e22010-03-04 10:42:38 +01002867
Jens Axboe07b32322010-03-05 09:48:44 +01002868int add_option(struct fio_option *o)
Jens Axboe9f988e22010-03-04 10:42:38 +01002869{
Jens Axboe07b32322010-03-05 09:48:44 +01002870 struct fio_option *__o;
2871 int opt_index = 0;
2872
Jens Axboe9af4a242012-03-16 10:13:49 +01002873 __o = fio_options;
Jens Axboe07b32322010-03-05 09:48:44 +01002874 while (__o->name) {
2875 opt_index++;
2876 __o++;
2877 }
2878
Jens Axboe9af4a242012-03-16 10:13:49 +01002879 memcpy(&fio_options[opt_index], o, sizeof(*o));
Jens Axboe07b32322010-03-05 09:48:44 +01002880 return 0;
Jens Axboe9f988e22010-03-04 10:42:38 +01002881}
Jens Axboee2de69d2010-03-04 14:05:48 +01002882
Jens Axboe07b32322010-03-05 09:48:44 +01002883void invalidate_profile_options(const char *prof_name)
Jens Axboee2de69d2010-03-04 14:05:48 +01002884{
Jens Axboe07b32322010-03-05 09:48:44 +01002885 struct fio_option *o;
Jens Axboee2de69d2010-03-04 14:05:48 +01002886
Jens Axboe9af4a242012-03-16 10:13:49 +01002887 o = fio_options;
Jens Axboe07b32322010-03-05 09:48:44 +01002888 while (o->name) {
2889 if (o->prof_name && !strcmp(o->prof_name, prof_name)) {
2890 o->type = FIO_OPT_INVALID;
2891 o->prof_name = NULL;
2892 }
2893 o++;
Jens Axboee2de69d2010-03-04 14:05:48 +01002894 }
2895}
Jens Axboef5b6bb82010-03-05 10:09:59 +01002896
2897void add_opt_posval(const char *optname, const char *ival, const char *help)
2898{
2899 struct fio_option *o;
2900 unsigned int i;
2901
Jens Axboe9af4a242012-03-16 10:13:49 +01002902 o = find_option(fio_options, optname);
Jens Axboef5b6bb82010-03-05 10:09:59 +01002903 if (!o)
2904 return;
2905
2906 for (i = 0; i < PARSE_MAX_VP; i++) {
2907 if (o->posval[i].ival)
2908 continue;
2909
2910 o->posval[i].ival = ival;
2911 o->posval[i].help = help;
2912 break;
2913 }
2914}
2915
2916void del_opt_posval(const char *optname, const char *ival)
2917{
2918 struct fio_option *o;
2919 unsigned int i;
2920
Jens Axboe9af4a242012-03-16 10:13:49 +01002921 o = find_option(fio_options, optname);
Jens Axboef5b6bb82010-03-05 10:09:59 +01002922 if (!o)
2923 return;
2924
2925 for (i = 0; i < PARSE_MAX_VP; i++) {
2926 if (!o->posval[i].ival)
2927 continue;
2928 if (strcmp(o->posval[i].ival, ival))
2929 continue;
2930
2931 o->posval[i].ival = NULL;
2932 o->posval[i].help = NULL;
2933 }
2934}
Jens Axboe7e356b22011-10-14 10:55:16 +02002935
2936void fio_options_free(struct thread_data *td)
2937{
Jens Axboe9af4a242012-03-16 10:13:49 +01002938 options_free(fio_options, td);
Steven Langde890a12011-11-09 14:03:34 +01002939 if (td->eo && td->io_ops && td->io_ops->options) {
2940 options_free(td->io_ops->options, td->eo);
2941 free(td->eo);
2942 td->eo = NULL;
2943 }
Jens Axboe7e356b22011-10-14 10:55:16 +02002944}