blob: 42a2ea0716c38306ba109b31385002fbc33da98c [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;
163
164}
165
166static int str_bssplit_cb(void *data, const char *input)
167{
168 struct thread_data *td = data;
Shaohua Li6eaf09d2012-09-14 08:49:43 +0200169 char *str, *p, *odir, *ddir;
Jens Axboe720e84a2009-04-21 08:29:55 +0200170 int ret = 0;
171
172 p = str = strdup(input);
173
174 strip_blank_front(&str);
175 strip_blank_end(str);
176
177 odir = strchr(str, ',');
178 if (odir) {
Shaohua Li6eaf09d2012-09-14 08:49:43 +0200179 ddir = strchr(odir + 1, ',');
180 if (ddir) {
181 ret = bssplit_ddir(td, DDIR_TRIM, ddir + 1);
182 if (!ret)
183 *ddir = '\0';
184 } else {
185 char *op;
186
187 op = strdup(odir + 1);
188 ret = bssplit_ddir(td, DDIR_TRIM, op);
189
190 free(op);
191 }
192 if (!ret)
193 ret = bssplit_ddir(td, DDIR_WRITE, odir + 1);
Jens Axboe720e84a2009-04-21 08:29:55 +0200194 if (!ret) {
195 *odir = '\0';
196 ret = bssplit_ddir(td, DDIR_READ, str);
197 }
198 } else {
199 char *op;
200
201 op = strdup(str);
Shaohua Li6eaf09d2012-09-14 08:49:43 +0200202 ret = bssplit_ddir(td, DDIR_WRITE, op);
Jens Axboe720e84a2009-04-21 08:29:55 +0200203 free(op);
Shaohua Li6eaf09d2012-09-14 08:49:43 +0200204
205 if (!ret) {
206 op = strdup(str);
207 ret = bssplit_ddir(td, DDIR_TRIM, op);
208 free(op);
209 }
210 ret = bssplit_ddir(td, DDIR_READ, str);
Jens Axboe720e84a2009-04-21 08:29:55 +0200211 }
Jens Axboe564ca972007-12-14 12:21:19 +0100212
213 free(p);
Jens Axboe720e84a2009-04-21 08:29:55 +0200214 return ret;
Jens Axboe564ca972007-12-14 12:21:19 +0100215}
216
Dmitry Monakhov8b28bd42012-09-23 15:46:09 +0400217static int str2error(char *str)
218{
219 const char * err[] = {"EPERM", "ENOENT", "ESRCH", "EINTR", "EIO",
220 "ENXIO", "E2BIG", "ENOEXEC", "EBADF",
221 "ECHILD", "EAGAIN", "ENOMEM", "EACCES",
222 "EFAULT", "ENOTBLK", "EBUSY", "EEXIST",
223 "EXDEV", "ENODEV", "ENOTDIR", "EISDIR",
224 "EINVAL", "ENFILE", "EMFILE", "ENOTTY",
225 "ETXTBSY","EFBIG", "ENOSPC", "ESPIPE",
226 "EROFS","EMLINK", "EPIPE", "EDOM", "ERANGE"};
227 int i = 0, num = sizeof(err) / sizeof(void *);
228
229 while( i < num) {
230 if (!strcmp(err[i], str))
231 return i + 1;
232 i++;
233 }
234 return 0;
235}
236
237static int ignore_error_type(struct thread_data *td, int etype, char *str)
238{
239 unsigned int i;
240 int *error;
241 char *fname;
242
243 if (etype >= ERROR_TYPE_CNT) {
244 log_err("Illegal error type\n");
245 return 1;
246 }
247
248 td->o.ignore_error_nr[etype] = 4;
249 error = malloc(4 * sizeof(struct bssplit));
250
251 i = 0;
252 while ((fname = strsep(&str, ":")) != NULL) {
253
254 if (!strlen(fname))
255 break;
256
257 /*
258 * grow struct buffer, if needed
259 */
260 if (i == td->o.ignore_error_nr[etype]) {
261 td->o.ignore_error_nr[etype] <<= 1;
262 error = realloc(error, td->o.ignore_error_nr[etype]
263 * sizeof(int));
264 }
265 if (fname[0] == 'E') {
266 error[i] = str2error(fname);
267 } else {
268 error[i] = atoi(fname);
269 if (error[i] < 0)
270 error[i] = error[i];
271 }
272 if (!error[i]) {
273 log_err("Unknown error %s, please use number value \n",
274 fname);
275 return 1;
276 }
277 i++;
278 }
279 if (i) {
280 td->o.continue_on_error |= 1 << etype;
281 td->o.ignore_error_nr[etype] = i;
282 td->o.ignore_error[etype] = error;
283 }
284 return 0;
285
286}
287
288static int str_ignore_error_cb(void *data, const char *input)
289{
290 struct thread_data *td = data;
291 char *str, *p, *n;
292 int type = 0, ret = 1;
293 p = str = strdup(input);
294
295 strip_blank_front(&str);
296 strip_blank_end(str);
297
298 while (p) {
299 n = strchr(p, ',');
300 if (n)
301 *n++ = '\0';
302 ret = ignore_error_type(td, type, p);
303 if (ret)
304 break;
305 p = n;
306 type++;
307 }
308 free(str);
309 return ret;
310}
311
Jens Axboe211097b2007-03-22 18:56:45 +0100312static int str_rw_cb(void *data, const char *str)
313{
314 struct thread_data *td = data;
315 char *nr = get_opt_postfix(str);
316
Jens Axboe5736c102010-07-20 12:03:25 -0600317 td->o.ddir_seq_nr = 1;
Jens Axboe059b0802011-08-25 09:09:37 +0200318 td->o.ddir_seq_add = 0;
319
320 if (!nr)
321 return 0;
322
323 if (td_random(td))
Jens Axboe5736c102010-07-20 12:03:25 -0600324 td->o.ddir_seq_nr = atoi(nr);
Jens Axboe059b0802011-08-25 09:09:37 +0200325 else {
326 long long val;
327
Jens Axboe6925dd32011-09-07 22:10:11 +0200328 if (str_to_decimal(nr, &val, 1, td)) {
Jens Axboe059b0802011-08-25 09:09:37 +0200329 log_err("fio: rw postfix parsing failed\n");
330 free(nr);
331 return 1;
332 }
333
334 td->o.ddir_seq_add = val;
Jens Axboe182ec6e2008-11-14 13:06:06 +0100335 }
Jens Axboe211097b2007-03-22 18:56:45 +0100336
Jens Axboe059b0802011-08-25 09:09:37 +0200337 free(nr);
Jens Axboe211097b2007-03-22 18:56:45 +0100338 return 0;
339}
340
Jens Axboe214e1ec2007-03-15 10:48:13 +0100341static int str_mem_cb(void *data, const char *mem)
342{
343 struct thread_data *td = data;
344
Shaohua Lid9759b12013-01-17 13:28:15 +0100345 if (td->o.mem_type == MEM_MMAPHUGE || td->o.mem_type == MEM_MMAP)
Jens Axboe214e1ec2007-03-15 10:48:13 +0100346 td->mmapfile = get_opt_postfix(mem);
Jens Axboe214e1ec2007-03-15 10:48:13 +0100347
348 return 0;
349}
350
Jens Axboe5d7c5d32010-06-21 15:08:17 +0200351static int str_verify_cb(void *data, const char *mem)
352{
353 struct thread_data *td = data;
354
Jens Axboee3aaafc2012-02-22 20:28:17 +0100355 if (td->o.verify == VERIFY_CRC32C_INTEL ||
356 td->o.verify == VERIFY_CRC32C) {
357 crc32c_intel_probe();
Jens Axboe5d7c5d32010-06-21 15:08:17 +0200358 }
359
360 return 0;
361}
362
Jens Axboec223da82010-03-24 13:23:53 +0100363static int fio_clock_source_cb(void *data, const char *str)
364{
365 struct thread_data *td = data;
366
367 fio_clock_source = td->o.clocksource;
Jens Axboefa80fea2012-12-09 20:29:00 +0100368 fio_clock_source_set = 1;
Jens Axboe01423ea2012-12-14 20:37:06 +0100369 fio_clock_init();
Jens Axboec223da82010-03-24 13:23:53 +0100370 return 0;
371}
372
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400373static int str_lockmem_cb(void fio_unused *data, unsigned long long *val)
Jens Axboe214e1ec2007-03-15 10:48:13 +0100374{
375 mlock_size = *val;
376 return 0;
377}
378
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400379static int str_rwmix_read_cb(void *data, unsigned long long *val)
Jens Axboecb499fc2008-05-28 10:33:32 +0200380{
381 struct thread_data *td = data;
382
383 td->o.rwmix[DDIR_READ] = *val;
384 td->o.rwmix[DDIR_WRITE] = 100 - *val;
385 return 0;
386}
387
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400388static int str_rwmix_write_cb(void *data, unsigned long long *val)
Jens Axboecb499fc2008-05-28 10:33:32 +0200389{
390 struct thread_data *td = data;
391
392 td->o.rwmix[DDIR_WRITE] = *val;
393 td->o.rwmix[DDIR_READ] = 100 - *val;
394 return 0;
395}
396
Jens Axboe214e1ec2007-03-15 10:48:13 +0100397#ifdef FIO_HAVE_IOPRIO
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400398static int str_prioclass_cb(void *data, unsigned long long *val)
Jens Axboe214e1ec2007-03-15 10:48:13 +0100399{
400 struct thread_data *td = data;
Jens Axboe6cefbe32007-04-18 12:46:56 +0200401 unsigned short mask;
402
403 /*
404 * mask off old class bits, str_prio_cb() may have set a default class
405 */
406 mask = (1 << IOPRIO_CLASS_SHIFT) - 1;
407 td->ioprio &= mask;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100408
409 td->ioprio |= *val << IOPRIO_CLASS_SHIFT;
Jens Axboeac684782007-11-08 08:29:07 +0100410 td->ioprio_set = 1;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100411 return 0;
412}
413
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400414static int str_prio_cb(void *data, unsigned long long *val)
Jens Axboe214e1ec2007-03-15 10:48:13 +0100415{
416 struct thread_data *td = data;
417
418 td->ioprio |= *val;
Jens Axboe6cefbe32007-04-18 12:46:56 +0200419
420 /*
421 * If no class is set, assume BE
422 */
423 if ((td->ioprio >> IOPRIO_CLASS_SHIFT) == 0)
424 td->ioprio |= IOPRIO_CLASS_BE << IOPRIO_CLASS_SHIFT;
425
Jens Axboeac684782007-11-08 08:29:07 +0100426 td->ioprio_set = 1;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100427 return 0;
428}
429#endif
430
431static int str_exitall_cb(void)
432{
433 exitall_on_terminate = 1;
434 return 0;
435}
436
Jens Axboe214e1ec2007-03-15 10:48:13 +0100437#ifdef FIO_HAVE_CPU_AFFINITY
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400438static int str_cpumask_cb(void *data, unsigned long long *val)
Jens Axboe214e1ec2007-03-15 10:48:13 +0100439{
440 struct thread_data *td = data;
Jens Axboed2e268b2007-06-15 10:33:49 +0200441 unsigned int i;
Jens Axboeb03daaf2008-12-08 20:31:43 +0100442 long max_cpu;
Jens Axboed2ce18b2008-12-12 20:51:40 +0100443 int ret;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100444
Jens Axboed2ce18b2008-12-12 20:51:40 +0100445 ret = fio_cpuset_init(&td->o.cpumask);
446 if (ret < 0) {
447 log_err("fio: cpuset_init failed\n");
448 td_verror(td, ret, "fio_cpuset_init");
449 return 1;
450 }
451
Jens Axboec00a2282011-07-08 20:56:06 +0200452 max_cpu = cpus_online();
Jens Axboed2e268b2007-06-15 10:33:49 +0200453
Jens Axboe62a72732008-12-08 11:37:01 +0100454 for (i = 0; i < sizeof(int) * 8; i++) {
455 if ((1 << i) & *val) {
Jens Axboeb03daaf2008-12-08 20:31:43 +0100456 if (i > max_cpu) {
457 log_err("fio: CPU %d too large (max=%ld)\n", i,
458 max_cpu);
459 return 1;
460 }
Jens Axboe62a72732008-12-08 11:37:01 +0100461 dprint(FD_PARSE, "set cpu allowed %d\n", i);
Jens Axboe6d459ee2008-12-12 20:02:58 +0100462 fio_cpu_set(&td->o.cpumask, i);
Jens Axboe62a72732008-12-08 11:37:01 +0100463 }
464 }
Jens Axboed2e268b2007-06-15 10:33:49 +0200465
Jens Axboe375b2692007-05-22 09:13:02 +0200466 td->o.cpumask_set = 1;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100467 return 0;
468}
469
Jens Axboee8462bd2009-07-06 12:59:04 +0200470static int set_cpus_allowed(struct thread_data *td, os_cpu_mask_t *mask,
471 const char *input)
Jens Axboed2e268b2007-06-15 10:33:49 +0200472{
Jens Axboed2e268b2007-06-15 10:33:49 +0200473 char *cpu, *str, *p;
Jens Axboeb03daaf2008-12-08 20:31:43 +0100474 long max_cpu;
Jens Axboe19608d62008-12-08 15:03:12 +0100475 int ret = 0;
Jens Axboed2e268b2007-06-15 10:33:49 +0200476
Jens Axboee8462bd2009-07-06 12:59:04 +0200477 ret = fio_cpuset_init(mask);
Jens Axboed2ce18b2008-12-12 20:51:40 +0100478 if (ret < 0) {
479 log_err("fio: cpuset_init failed\n");
480 td_verror(td, ret, "fio_cpuset_init");
481 return 1;
482 }
Jens Axboed2e268b2007-06-15 10:33:49 +0200483
484 p = str = strdup(input);
485
486 strip_blank_front(&str);
487 strip_blank_end(str);
488
Jens Axboec00a2282011-07-08 20:56:06 +0200489 max_cpu = cpus_online();
Jens Axboeb03daaf2008-12-08 20:31:43 +0100490
Jens Axboed2e268b2007-06-15 10:33:49 +0200491 while ((cpu = strsep(&str, ",")) != NULL) {
Jens Axboe62a72732008-12-08 11:37:01 +0100492 char *str2, *cpu2;
493 int icpu, icpu2;
494
Jens Axboed2e268b2007-06-15 10:33:49 +0200495 if (!strlen(cpu))
496 break;
Jens Axboe62a72732008-12-08 11:37:01 +0100497
498 str2 = cpu;
499 icpu2 = -1;
500 while ((cpu2 = strsep(&str2, "-")) != NULL) {
501 if (!strlen(cpu2))
502 break;
503
504 icpu2 = atoi(cpu2);
505 }
506
507 icpu = atoi(cpu);
508 if (icpu2 == -1)
509 icpu2 = icpu;
510 while (icpu <= icpu2) {
Jens Axboe6d459ee2008-12-12 20:02:58 +0100511 if (icpu >= FIO_MAX_CPUS) {
Jens Axboe19608d62008-12-08 15:03:12 +0100512 log_err("fio: your OS only supports up to"
Jens Axboe6d459ee2008-12-12 20:02:58 +0100513 " %d CPUs\n", (int) FIO_MAX_CPUS);
Jens Axboe19608d62008-12-08 15:03:12 +0100514 ret = 1;
515 break;
516 }
Jens Axboeb03daaf2008-12-08 20:31:43 +0100517 if (icpu > max_cpu) {
518 log_err("fio: CPU %d too large (max=%ld)\n",
519 icpu, max_cpu);
520 ret = 1;
521 break;
522 }
Jens Axboe0b9d69e2009-09-11 22:29:54 +0200523
Jens Axboe62a72732008-12-08 11:37:01 +0100524 dprint(FD_PARSE, "set cpu allowed %d\n", icpu);
Jens Axboee8462bd2009-07-06 12:59:04 +0200525 fio_cpu_set(mask, icpu);
Jens Axboe62a72732008-12-08 11:37:01 +0100526 icpu++;
527 }
Jens Axboe19608d62008-12-08 15:03:12 +0100528 if (ret)
529 break;
Jens Axboed2e268b2007-06-15 10:33:49 +0200530 }
531
532 free(p);
Jens Axboe19608d62008-12-08 15:03:12 +0100533 if (!ret)
534 td->o.cpumask_set = 1;
535 return ret;
Jens Axboed2e268b2007-06-15 10:33:49 +0200536}
Jens Axboee8462bd2009-07-06 12:59:04 +0200537
538static int str_cpus_allowed_cb(void *data, const char *input)
539{
540 struct thread_data *td = data;
541 int ret;
542
543 ret = set_cpus_allowed(td, &td->o.cpumask, input);
544 if (!ret)
545 td->o.cpumask_set = 1;
546
547 return ret;
548}
549
550static int str_verify_cpus_allowed_cb(void *data, const char *input)
551{
552 struct thread_data *td = data;
553 int ret;
554
555 ret = set_cpus_allowed(td, &td->o.verify_cpumask, input);
556 if (!ret)
557 td->o.verify_cpumask_set = 1;
558
559 return ret;
560}
Jens Axboed2e268b2007-06-15 10:33:49 +0200561#endif
562
Jens Axboe67bf9822013-01-10 11:23:19 +0100563#ifdef CONFIG_LIBNUMA
Yufei Rend0b937e2012-10-19 23:11:52 -0400564static int str_numa_cpunodes_cb(void *data, char *input)
565{
566 struct thread_data *td = data;
567
568 /* numa_parse_nodestring() parses a character string list
569 * of nodes into a bit mask. The bit mask is allocated by
570 * numa_allocate_nodemask(), so it should be freed by
571 * numa_free_nodemask().
572 */
573 td->o.numa_cpunodesmask = numa_parse_nodestring(input);
574 if (td->o.numa_cpunodesmask == NULL) {
575 log_err("fio: numa_parse_nodestring failed\n");
576 td_verror(td, 1, "str_numa_cpunodes_cb");
577 return 1;
578 }
579
580 td->o.numa_cpumask_set = 1;
581 return 0;
582}
583
584static int str_numa_mpol_cb(void *data, char *input)
585{
586 struct thread_data *td = data;
587 const char * const policy_types[] =
588 { "default", "prefer", "bind", "interleave", "local" };
589 int i;
590
591 char *nodelist = strchr(input, ':');
592 if (nodelist) {
593 /* NUL-terminate mode */
594 *nodelist++ = '\0';
595 }
596
597 for (i = 0; i <= MPOL_LOCAL; i++) {
598 if (!strcmp(input, policy_types[i])) {
599 td->o.numa_mem_mode = i;
600 break;
601 }
602 }
603 if (i > MPOL_LOCAL) {
604 log_err("fio: memory policy should be: default, prefer, bind, interleave, local\n");
605 goto out;
606 }
607
608 switch (td->o.numa_mem_mode) {
609 case MPOL_PREFERRED:
610 /*
611 * Insist on a nodelist of one node only
612 */
613 if (nodelist) {
614 char *rest = nodelist;
615 while (isdigit(*rest))
616 rest++;
617 if (*rest) {
618 log_err("fio: one node only for \'prefer\'\n");
619 goto out;
620 }
621 } else {
622 log_err("fio: one node is needed for \'prefer\'\n");
623 goto out;
624 }
625 break;
626 case MPOL_INTERLEAVE:
627 /*
628 * Default to online nodes with memory if no nodelist
629 */
630 if (!nodelist)
631 nodelist = strdup("all");
632 break;
633 case MPOL_LOCAL:
634 case MPOL_DEFAULT:
635 /*
636 * Don't allow a nodelist
637 */
638 if (nodelist) {
639 log_err("fio: NO nodelist for \'local\'\n");
640 goto out;
641 }
642 break;
643 case MPOL_BIND:
644 /*
645 * Insist on a nodelist
646 */
647 if (!nodelist) {
648 log_err("fio: a nodelist is needed for \'bind\'\n");
649 goto out;
650 }
651 break;
652 }
653
654
655 /* numa_parse_nodestring() parses a character string list
656 * of nodes into a bit mask. The bit mask is allocated by
657 * numa_allocate_nodemask(), so it should be freed by
658 * numa_free_nodemask().
659 */
660 switch (td->o.numa_mem_mode) {
661 case MPOL_PREFERRED:
662 td->o.numa_mem_prefer_node = atoi(nodelist);
663 break;
664 case MPOL_INTERLEAVE:
665 case MPOL_BIND:
666 td->o.numa_memnodesmask = numa_parse_nodestring(nodelist);
667 if (td->o.numa_memnodesmask == NULL) {
668 log_err("fio: numa_parse_nodestring failed\n");
669 td_verror(td, 1, "str_numa_memnodes_cb");
670 return 1;
671 }
672 break;
673 case MPOL_LOCAL:
674 case MPOL_DEFAULT:
675 default:
676 break;
677 }
678
679 td->o.numa_memmask_set = 1;
680 return 0;
681
682out:
683 return 1;
684}
685#endif
686
Jens Axboe0d29de82010-09-01 13:54:15 +0200687#ifdef FIO_HAVE_TRIM
688static int str_verify_trim_cb(void *data, unsigned long long *val)
689{
690 struct thread_data *td = data;
691
692 td->o.trim_percentage = *val;
693 return 0;
694}
695#endif
696
Jens Axboe214e1ec2007-03-15 10:48:13 +0100697static int str_fst_cb(void *data, const char *str)
698{
699 struct thread_data *td = data;
700 char *nr = get_opt_postfix(str);
701
702 td->file_service_nr = 1;
Jens Axboe182ec6e2008-11-14 13:06:06 +0100703 if (nr) {
Jens Axboe214e1ec2007-03-15 10:48:13 +0100704 td->file_service_nr = atoi(nr);
Jens Axboe182ec6e2008-11-14 13:06:06 +0100705 free(nr);
706 }
Jens Axboe214e1ec2007-03-15 10:48:13 +0100707
708 return 0;
709}
710
Jens Axboe67bf9822013-01-10 11:23:19 +0100711#ifdef CONFIG_SYNC_FILE_RANGE
Jens Axboe44f29692010-03-09 20:09:44 +0100712static int str_sfr_cb(void *data, const char *str)
713{
714 struct thread_data *td = data;
715 char *nr = get_opt_postfix(str);
716
717 td->sync_file_range_nr = 1;
718 if (nr) {
719 td->sync_file_range_nr = atoi(nr);
720 free(nr);
721 }
722
723 return 0;
724}
Jens Axboe3ae06372010-03-19 19:17:15 +0100725#endif
Jens Axboe44f29692010-03-09 20:09:44 +0100726
Jens Axboee25839d2012-11-06 10:49:42 +0100727static int str_random_distribution_cb(void *data, const char *str)
728{
729 struct thread_data *td = data;
730 double val;
731 char *nr;
732
Jens Axboe925fee32012-11-06 13:50:32 +0100733 if (td->o.random_distribution == FIO_RAND_DIST_ZIPF)
734 val = 1.1;
735 else if (td->o.random_distribution == FIO_RAND_DIST_PARETO)
736 val = 0.2;
737 else
Jens Axboee25839d2012-11-06 10:49:42 +0100738 return 0;
739
740 nr = get_opt_postfix(str);
Jens Axboe925fee32012-11-06 13:50:32 +0100741 if (nr && !str_to_float(nr, &val)) {
Jens Axboee25839d2012-11-06 10:49:42 +0100742 log_err("fio: random postfix parsing failed\n");
743 free(nr);
744 return 1;
745 }
746
Jens Axboe078189c2012-11-07 13:47:22 +0100747 free(nr);
748
Jens Axboe18ded912012-11-08 08:36:00 +0100749 if (td->o.random_distribution == FIO_RAND_DIST_ZIPF) {
750 if (val == 1.00) {
751 log_err("fio: zipf theta must different than 1.0\n");
752 return 1;
753 }
Jens Axboe925fee32012-11-06 13:50:32 +0100754 td->o.zipf_theta = val;
Jens Axboe18ded912012-11-08 08:36:00 +0100755 } else {
Jens Axboe078189c2012-11-07 13:47:22 +0100756 if (val <= 0.00 || val >= 1.00) {
757 log_err("fio: pareto input out of range (0 < input < 1.0)\n");
758 return 1;
759 }
Jens Axboe925fee32012-11-06 13:50:32 +0100760 td->o.pareto_h = val;
Jens Axboe078189c2012-11-07 13:47:22 +0100761 }
Jens Axboe925fee32012-11-06 13:50:32 +0100762
Jens Axboee25839d2012-11-06 10:49:42 +0100763 return 0;
764}
765
Jens Axboe921c7662008-03-26 09:17:55 +0100766static int check_dir(struct thread_data *td, char *fname)
767{
Jens Axboe3f0ca9b2011-05-24 21:36:24 +0200768#if 0
Jens Axboe921c7662008-03-26 09:17:55 +0100769 char file[PATH_MAX], *dir;
Jens Axboebc838912008-04-07 09:00:54 +0200770 int elen = 0;
Jens Axboe921c7662008-03-26 09:17:55 +0100771
Jens Axboebc838912008-04-07 09:00:54 +0200772 if (td->o.directory) {
773 strcpy(file, td->o.directory);
Jens Axboefcef0b32008-05-26 14:53:24 +0200774 strcat(file, "/");
Jens Axboebc838912008-04-07 09:00:54 +0200775 elen = strlen(file);
776 }
777
Jens Axboefcef0b32008-05-26 14:53:24 +0200778 sprintf(file + elen, "%s", fname);
Jens Axboe921c7662008-03-26 09:17:55 +0100779 dir = dirname(file);
780
Jens Axboefcef0b32008-05-26 14:53:24 +0200781 {
782 struct stat sb;
783 /*
784 * We can't do this on FIO_DISKLESSIO engines. The engine isn't loaded
785 * yet, so we can't do this check right here...
786 */
Jens Axboe921c7662008-03-26 09:17:55 +0100787 if (lstat(dir, &sb) < 0) {
788 int ret = errno;
789
790 log_err("fio: %s is not a directory\n", dir);
791 td_verror(td, ret, "lstat");
792 return 1;
793 }
794
795 if (!S_ISDIR(sb.st_mode)) {
796 log_err("fio: %s is not a directory\n", dir);
797 return 1;
798 }
Jens Axboefcef0b32008-05-26 14:53:24 +0200799 }
800#endif
Jens Axboe921c7662008-03-26 09:17:55 +0100801
802 return 0;
803}
804
Jens Axboe8e827d32009-08-04 09:51:48 +0200805/*
806 * Return next file in the string. Files are separated with ':'. If the ':'
807 * is escaped with a '\', then that ':' is part of the filename and does not
808 * indicate a new file.
809 */
810static char *get_next_file_name(char **ptr)
811{
812 char *str = *ptr;
813 char *p, *start;
814
815 if (!str || !strlen(str))
816 return NULL;
817
818 start = str;
819 do {
820 /*
821 * No colon, we are done
822 */
823 p = strchr(str, ':');
824 if (!p) {
825 *ptr = NULL;
826 break;
827 }
828
829 /*
830 * We got a colon, but it's the first character. Skip and
831 * continue
832 */
833 if (p == start) {
834 str = ++start;
835 continue;
836 }
837
838 if (*(p - 1) != '\\') {
839 *p = '\0';
840 *ptr = p + 1;
841 break;
842 }
843
844 memmove(p - 1, p, strlen(p) + 1);
845 str = p;
846 } while (1);
847
848 return start;
849}
850
Jens Axboe214e1ec2007-03-15 10:48:13 +0100851static int str_filename_cb(void *data, const char *input)
852{
853 struct thread_data *td = data;
854 char *fname, *str, *p;
855
856 p = str = strdup(input);
857
858 strip_blank_front(&str);
859 strip_blank_end(str);
860
861 if (!td->files_index)
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100862 td->o.nr_files = 0;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100863
Jens Axboe8e827d32009-08-04 09:51:48 +0200864 while ((fname = get_next_file_name(&str)) != NULL) {
Jens Axboe214e1ec2007-03-15 10:48:13 +0100865 if (!strlen(fname))
866 break;
Jens Axboe921c7662008-03-26 09:17:55 +0100867 if (check_dir(td, fname)) {
868 free(p);
869 return 1;
870 }
Jens Axboe214e1ec2007-03-15 10:48:13 +0100871 add_file(td, fname);
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100872 td->o.nr_files++;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100873 }
874
875 free(p);
876 return 0;
877}
878
879static int str_directory_cb(void *data, const char fio_unused *str)
880{
881 struct thread_data *td = data;
882 struct stat sb;
883
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100884 if (lstat(td->o.directory, &sb) < 0) {
Jens Axboe921c7662008-03-26 09:17:55 +0100885 int ret = errno;
886
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100887 log_err("fio: %s is not a directory\n", td->o.directory);
Jens Axboe921c7662008-03-26 09:17:55 +0100888 td_verror(td, ret, "lstat");
Jens Axboe214e1ec2007-03-15 10:48:13 +0100889 return 1;
890 }
891 if (!S_ISDIR(sb.st_mode)) {
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100892 log_err("fio: %s is not a directory\n", td->o.directory);
Jens Axboe214e1ec2007-03-15 10:48:13 +0100893 return 1;
894 }
895
896 return 0;
897}
898
899static int str_opendir_cb(void *data, const char fio_unused *str)
900{
901 struct thread_data *td = data;
902
903 if (!td->files_index)
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100904 td->o.nr_files = 0;
Jens Axboe214e1ec2007-03-15 10:48:13 +0100905
Jens Axboe2dc1bbe2007-03-15 15:01:33 +0100906 return add_dir_files(td, td->o.opendir);
Jens Axboe214e1ec2007-03-15 10:48:13 +0100907}
908
Cigy Cyriac85bc8332010-08-10 19:21:09 -0400909static int str_verify_offset_cb(void *data, unsigned long long *off)
Shawn Lewis546a9142007-07-28 21:11:37 +0200910{
911 struct thread_data *td = data;
Jens Axboea59e1702007-07-30 08:53:27 +0200912
Shawn Lewis546a9142007-07-28 21:11:37 +0200913 if (*off && *off < sizeof(struct verify_header)) {
Jens Axboea59e1702007-07-30 08:53:27 +0200914 log_err("fio: verify_offset too small\n");
Shawn Lewis546a9142007-07-28 21:11:37 +0200915 return 1;
916 }
Jens Axboea59e1702007-07-30 08:53:27 +0200917
918 td->o.verify_offset = *off;
Shawn Lewis546a9142007-07-28 21:11:37 +0200919 return 0;
920}
921
Radha Ramachandran0e92f872009-10-27 20:14:27 +0100922static int str_verify_pattern_cb(void *data, const char *input)
Jens Axboe90059d62007-07-30 09:33:12 +0200923{
924 struct thread_data *td = data;
Radha Ramachandran0e92f872009-10-27 20:14:27 +0100925 long off;
926 int i = 0, j = 0, len, k, base = 10;
927 char* loc1, * loc2;
Jens Axboe90059d62007-07-30 09:33:12 +0200928
Radha Ramachandran0e92f872009-10-27 20:14:27 +0100929 loc1 = strstr(input, "0x");
930 loc2 = strstr(input, "0X");
931 if (loc1 || loc2)
932 base = 16;
933 off = strtol(input, NULL, base);
934 if (off != LONG_MAX || errno != ERANGE) {
935 while (off) {
936 td->o.verify_pattern[i] = off & 0xff;
937 off >>= 8;
938 i++;
939 }
940 } else {
941 len = strlen(input);
942 k = len - 1;
943 if (base == 16) {
944 if (loc1)
945 j = loc1 - input + 2;
946 else
947 j = loc2 - input + 2;
948 } else
949 return 1;
950 if (len - j < MAX_PATTERN_SIZE * 2) {
951 while (k >= j) {
952 off = converthexchartoint(input[k--]);
953 if (k >= j)
954 off += (converthexchartoint(input[k--])
955 * 16);
956 td->o.verify_pattern[i++] = (char) off;
957 }
958 }
959 }
Steven Langefcd9dc2012-02-02 20:22:04 +0100960
961 /*
962 * Fill the pattern all the way to the end. This greatly reduces
963 * the number of memcpy's we have to do when verifying the IO.
964 */
965 while (i > 1 && i * 2 <= MAX_PATTERN_SIZE) {
966 memcpy(&td->o.verify_pattern[i], &td->o.verify_pattern[0], i);
967 i *= 2;
968 }
Steven Lang9a2a86d2012-02-07 09:42:59 +0100969 if (i == 1) {
970 /*
971 * The code in verify_io_u_pattern assumes a single byte pattern
972 * fills the whole verify pattern buffer.
973 */
974 memset(td->o.verify_pattern, td->o.verify_pattern[0],
975 MAX_PATTERN_SIZE);
976 }
Steven Langefcd9dc2012-02-02 20:22:04 +0100977
Radha Ramachandran0e92f872009-10-27 20:14:27 +0100978 td->o.verify_pattern_bytes = i;
Steven Langefcd9dc2012-02-02 20:22:04 +0100979
Jens Axboe92bf48d2011-01-14 21:20:42 +0100980 /*
981 * VERIFY_META could already be set
982 */
983 if (td->o.verify == VERIFY_NONE)
984 td->o.verify = VERIFY_PATTERN;
Steven Langefcd9dc2012-02-02 20:22:04 +0100985
Jens Axboe90059d62007-07-30 09:33:12 +0200986 return 0;
987}
Jens Axboe214e1ec2007-03-15 10:48:13 +0100988
Jens Axboe4d4e80f2008-03-04 10:18:56 +0100989static int str_lockfile_cb(void *data, const char *str)
990{
991 struct thread_data *td = data;
992 char *nr = get_opt_postfix(str);
993
994 td->o.lockfile_batch = 1;
Jens Axboe182ec6e2008-11-14 13:06:06 +0100995 if (nr) {
Jens Axboe4d4e80f2008-03-04 10:18:56 +0100996 td->o.lockfile_batch = atoi(nr);
Jens Axboe182ec6e2008-11-14 13:06:06 +0100997 free(nr);
998 }
Jens Axboe4d4e80f2008-03-04 10:18:56 +0100999
1000 return 0;
1001}
1002
Jens Axboee3cedca2008-11-19 19:57:52 +01001003static int str_write_bw_log_cb(void *data, const char *str)
1004{
1005 struct thread_data *td = data;
1006
1007 if (str)
1008 td->o.bw_log_file = strdup(str);
1009
1010 td->o.write_bw_log = 1;
1011 return 0;
1012}
1013
1014static int str_write_lat_log_cb(void *data, const char *str)
1015{
1016 struct thread_data *td = data;
1017
1018 if (str)
1019 td->o.lat_log_file = strdup(str);
1020
1021 td->o.write_lat_log = 1;
1022 return 0;
1023}
1024
Jens Axboec8eeb9d2011-10-05 14:02:22 +02001025static int str_write_iops_log_cb(void *data, const char *str)
1026{
1027 struct thread_data *td = data;
1028
1029 if (str)
1030 td->o.iops_log_file = strdup(str);
1031
1032 td->o.write_iops_log = 1;
1033 return 0;
1034}
1035
Jens Axboe993bf482008-11-14 13:04:53 +01001036static int str_gtod_reduce_cb(void *data, int *il)
1037{
1038 struct thread_data *td = data;
1039 int val = *il;
1040
Jens Axboe02af0982010-06-24 09:59:34 +02001041 td->o.disable_lat = !!val;
Jens Axboe993bf482008-11-14 13:04:53 +01001042 td->o.disable_clat = !!val;
1043 td->o.disable_slat = !!val;
1044 td->o.disable_bw = !!val;
Jens Axboe0dc1bc02011-10-13 08:55:29 +02001045 td->o.clat_percentiles = !val;
Jens Axboe993bf482008-11-14 13:04:53 +01001046 if (val)
1047 td->tv_cache_mask = 63;
1048
1049 return 0;
1050}
1051
Cigy Cyriac85bc8332010-08-10 19:21:09 -04001052static int str_gtod_cpu_cb(void *data, long long *il)
Jens Axboebe4ecfd2008-12-08 14:10:52 +01001053{
1054 struct thread_data *td = data;
1055 int val = *il;
1056
1057 td->o.gtod_cpu = val;
1058 td->o.gtod_offload = 1;
1059 return 0;
1060}
1061
Jens Axboe7bb59102011-07-12 19:47:03 +02001062static int str_size_cb(void *data, unsigned long long *__val)
1063{
1064 struct thread_data *td = data;
1065 unsigned long long v = *__val;
1066
1067 if (parse_is_percent(v)) {
1068 td->o.size = 0;
1069 td->o.size_percent = -1ULL - v;
1070 } else
1071 td->o.size = v;
1072
1073 return 0;
1074}
1075
Jens Axboe896cac22009-07-01 10:38:35 +02001076static int rw_verify(struct fio_option *o, void *data)
1077{
1078 struct thread_data *td = data;
1079
1080 if (read_only && td_write(td)) {
1081 log_err("fio: job <%s> has write bit set, but fio is in"
1082 " read-only mode\n", td->o.name);
1083 return 1;
1084 }
1085
1086 return 0;
1087}
1088
Jens Axboe276ca4f2009-07-01 10:43:05 +02001089static int gtod_cpu_verify(struct fio_option *o, void *data)
Jens Axboe29d43ff2009-07-01 10:42:18 +02001090{
Jens Axboe276ca4f2009-07-01 10:43:05 +02001091#ifndef FIO_HAVE_CPU_AFFINITY
Jens Axboe29d43ff2009-07-01 10:42:18 +02001092 struct thread_data *td = data;
1093
Jens Axboe29d43ff2009-07-01 10:42:18 +02001094 if (td->o.gtod_cpu) {
1095 log_err("fio: platform must support CPU affinity for"
1096 "gettimeofday() offloading\n");
1097 return 1;
1098 }
1099#endif
1100
1101 return 0;
1102}
1103
Jens Axboe90fef2d2009-07-17 22:33:32 +02001104static int kb_base_verify(struct fio_option *o, void *data)
1105{
1106 struct thread_data *td = data;
1107
1108 if (td->o.kb_base != 1024 && td->o.kb_base != 1000) {
1109 log_err("fio: kb_base set to nonsensical value: %u\n",
1110 td->o.kb_base);
1111 return 1;
1112 }
1113
1114 return 0;
1115}
1116
Jens Axboe214e1ec2007-03-15 10:48:13 +01001117/*
1118 * Map of job/command line options
1119 */
Jens Axboe07b32322010-03-05 09:48:44 +01001120static struct fio_option options[FIO_MAX_OPTS] = {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001121 {
1122 .name = "description",
1123 .type = FIO_OPT_STR_STORE,
1124 .off1 = td_var_offset(description),
1125 .help = "Text job description",
1126 },
1127 {
1128 .name = "name",
1129 .type = FIO_OPT_STR_STORE,
1130 .off1 = td_var_offset(name),
1131 .help = "Name of this job",
1132 },
1133 {
1134 .name = "directory",
1135 .type = FIO_OPT_STR_STORE,
1136 .off1 = td_var_offset(directory),
1137 .cb = str_directory_cb,
1138 .help = "Directory to store files in",
1139 },
1140 {
1141 .name = "filename",
1142 .type = FIO_OPT_STR_STORE,
1143 .off1 = td_var_offset(filename),
1144 .cb = str_filename_cb,
Jens Axboef0d524b2009-04-27 08:00:48 +02001145 .prio = -1, /* must come after "directory" */
Jens Axboe214e1ec2007-03-15 10:48:13 +01001146 .help = "File(s) to use for the workload",
1147 },
1148 {
Jens Axboe90fef2d2009-07-17 22:33:32 +02001149 .name = "kb_base",
1150 .type = FIO_OPT_INT,
1151 .off1 = td_var_offset(kb_base),
Jens Axboe90fef2d2009-07-17 22:33:32 +02001152 .verify = kb_base_verify,
Jens Axboea639f0b2009-07-18 08:25:35 +02001153 .prio = 1,
Jens Axboe90fef2d2009-07-17 22:33:32 +02001154 .def = "1024",
Jens Axboea639f0b2009-07-18 08:25:35 +02001155 .help = "How many bytes per KB for reporting (1000 or 1024)",
Jens Axboe90fef2d2009-07-17 22:33:32 +02001156 },
1157 {
Jens Axboe29c13492008-03-01 19:25:20 +01001158 .name = "lockfile",
Jens Axboe4d4e80f2008-03-04 10:18:56 +01001159 .type = FIO_OPT_STR,
1160 .cb = str_lockfile_cb,
1161 .off1 = td_var_offset(file_lock_mode),
Jens Axboe29c13492008-03-01 19:25:20 +01001162 .help = "Lock file when doing IO to it",
1163 .parent = "filename",
Jens Axboe4d4e80f2008-03-04 10:18:56 +01001164 .def = "none",
1165 .posval = {
1166 { .ival = "none",
1167 .oval = FILE_LOCK_NONE,
1168 .help = "No file locking",
1169 },
1170 { .ival = "exclusive",
1171 .oval = FILE_LOCK_EXCLUSIVE,
1172 .help = "Exclusive file lock",
1173 },
1174 {
1175 .ival = "readwrite",
1176 .oval = FILE_LOCK_READWRITE,
1177 .help = "Read vs write lock",
1178 },
1179 },
Jens Axboe29c13492008-03-01 19:25:20 +01001180 },
1181 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001182 .name = "opendir",
1183 .type = FIO_OPT_STR_STORE,
1184 .off1 = td_var_offset(opendir),
1185 .cb = str_opendir_cb,
1186 .help = "Recursively add files from this directory and down",
1187 },
1188 {
1189 .name = "rw",
Jens Axboed3aad8f2007-03-15 14:12:05 +01001190 .alias = "readwrite",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001191 .type = FIO_OPT_STR,
Jens Axboe211097b2007-03-22 18:56:45 +01001192 .cb = str_rw_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001193 .off1 = td_var_offset(td_ddir),
1194 .help = "IO direction",
1195 .def = "read",
Jens Axboe896cac22009-07-01 10:38:35 +02001196 .verify = rw_verify,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001197 .posval = {
1198 { .ival = "read",
1199 .oval = TD_DDIR_READ,
1200 .help = "Sequential read",
1201 },
1202 { .ival = "write",
1203 .oval = TD_DDIR_WRITE,
1204 .help = "Sequential write",
1205 },
Shaohua Li6eaf09d2012-09-14 08:49:43 +02001206 { .ival = "trim",
1207 .oval = TD_DDIR_TRIM,
1208 .help = "Sequential trim",
1209 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01001210 { .ival = "randread",
1211 .oval = TD_DDIR_RANDREAD,
1212 .help = "Random read",
1213 },
1214 { .ival = "randwrite",
1215 .oval = TD_DDIR_RANDWRITE,
1216 .help = "Random write",
1217 },
Shaohua Li6eaf09d2012-09-14 08:49:43 +02001218 { .ival = "randtrim",
1219 .oval = TD_DDIR_RANDTRIM,
1220 .help = "Random trim",
1221 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01001222 { .ival = "rw",
1223 .oval = TD_DDIR_RW,
1224 .help = "Sequential read and write mix",
1225 },
Jens Axboe10b023d2012-03-23 13:40:06 +01001226 { .ival = "readwrite",
1227 .oval = TD_DDIR_RW,
1228 .help = "Sequential read and write mix",
1229 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01001230 { .ival = "randrw",
1231 .oval = TD_DDIR_RANDRW,
1232 .help = "Random read and write mix"
1233 },
1234 },
1235 },
1236 {
Jens Axboe38dad622010-07-20 14:46:00 -06001237 .name = "rw_sequencer",
1238 .type = FIO_OPT_STR,
1239 .off1 = td_var_offset(rw_seq),
1240 .help = "IO offset generator modifier",
1241 .def = "sequential",
1242 .posval = {
1243 { .ival = "sequential",
1244 .oval = RW_SEQ_SEQ,
1245 .help = "Generate sequential offsets",
1246 },
1247 { .ival = "identical",
1248 .oval = RW_SEQ_IDENT,
1249 .help = "Generate identical offsets",
1250 },
1251 },
1252 },
1253
1254 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001255 .name = "ioengine",
1256 .type = FIO_OPT_STR_STORE,
1257 .off1 = td_var_offset(ioengine),
1258 .help = "IO engine to use",
Jens Axboe58483fa2011-01-19 11:09:58 -07001259 .def = FIO_PREFERRED_ENGINE,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001260 .posval = {
1261 { .ival = "sync",
1262 .help = "Use read/write",
1263 },
gurudas paia31041e2007-10-23 15:12:30 +02001264 { .ival = "psync",
1265 .help = "Use pread/pwrite",
1266 },
Jens Axboe1d2af022008-02-04 10:59:07 +01001267 { .ival = "vsync",
Bruce Cran03e20d62011-01-02 20:14:54 +01001268 .help = "Use readv/writev",
Jens Axboe1d2af022008-02-04 10:59:07 +01001269 },
Jens Axboe67bf9822013-01-10 11:23:19 +01001270#ifdef CONFIG_LIBAIO
Jens Axboe214e1ec2007-03-15 10:48:13 +01001271 { .ival = "libaio",
1272 .help = "Linux native asynchronous IO",
1273 },
1274#endif
Jens Axboe67bf9822013-01-10 11:23:19 +01001275#ifdef CONFIG_POSIXAIO
Jens Axboe214e1ec2007-03-15 10:48:13 +01001276 { .ival = "posixaio",
1277 .help = "POSIX asynchronous IO",
1278 },
1279#endif
Jens Axboe997843c2013-01-24 15:27:40 -07001280#ifdef CONFIG_SOLARISAIO
Jens Axboe417f0062008-06-02 11:59:30 +02001281 { .ival = "solarisaio",
1282 .help = "Solaris native asynchronous IO",
1283 },
1284#endif
Jens Axboe4700b232013-01-24 15:33:33 -07001285#ifdef CONFIG_WINDOWSAIO
Bruce Cran03e20d62011-01-02 20:14:54 +01001286 { .ival = "windowsaio",
Jens Axboe3be80072011-01-19 11:07:28 -07001287 .help = "Windows native asynchronous IO"
Steven Langde890a12011-11-09 14:03:34 +01001288 },
Jens Axboe3be80072011-01-19 11:07:28 -07001289#endif
Jens Axboe214e1ec2007-03-15 10:48:13 +01001290 { .ival = "mmap",
Bruce Cran03e20d62011-01-02 20:14:54 +01001291 .help = "Memory mapped IO"
Jens Axboe214e1ec2007-03-15 10:48:13 +01001292 },
Jens Axboe67bf9822013-01-10 11:23:19 +01001293#ifdef CONFIG_LINUX_SPLICE
Jens Axboe214e1ec2007-03-15 10:48:13 +01001294 { .ival = "splice",
1295 .help = "splice/vmsplice based IO",
1296 },
Jens Axboe9cce02e2007-06-22 15:42:21 +02001297 { .ival = "netsplice",
1298 .help = "splice/vmsplice to/from the network",
1299 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01001300#endif
1301#ifdef FIO_HAVE_SGIO
1302 { .ival = "sg",
1303 .help = "SCSI generic v3 IO",
1304 },
1305#endif
1306 { .ival = "null",
1307 .help = "Testing engine (no data transfer)",
1308 },
1309 { .ival = "net",
1310 .help = "Network IO",
1311 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01001312 { .ival = "cpuio",
Bruce Cran03e20d62011-01-02 20:14:54 +01001313 .help = "CPU cycle burner engine",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001314 },
Jens Axboe67bf9822013-01-10 11:23:19 +01001315#ifdef CONFIG_GUASI
Jens Axboeb8c82a42007-03-21 08:48:26 +01001316 { .ival = "guasi",
1317 .help = "GUASI IO engine",
1318 },
1319#endif
Jens Axboe79a43182010-09-07 13:28:58 +02001320#ifdef FIO_HAVE_BINJECT
1321 { .ival = "binject",
1322 .help = "binject direct inject block engine",
1323 },
1324#endif
Jens Axboe67bf9822013-01-10 11:23:19 +01001325#ifdef CONFIG_RDMA
ren yufei21b8aee2011-08-01 10:01:57 +02001326 { .ival = "rdma",
1327 .help = "RDMA IO engine",
1328 },
1329#endif
Jens Axboe67bf9822013-01-10 11:23:19 +01001330#ifdef CONFIG_FUSION_AW
Jens Axboe8200b8c2012-09-18 23:55:43 +02001331 { .ival = "fusion-aw-sync",
1332 .help = "Fusion-io atomic write engine",
1333 },
1334#endif
Jens Axboe997843c2013-01-24 15:27:40 -07001335#ifdef CONFIG_LINUX_EXT4_MOVE_EXTENT
Jens Axboe1ecc95c2012-09-20 13:46:34 +02001336 { .ival = "e4defrag",
1337 .help = "ext4 defrag engine",
1338 },
1339#endif
Jens Axboe997843c2013-01-24 15:27:40 -07001340#ifdef CONFIG_LINUX_FALLOCATE
Jens Axboe1ecc95c2012-09-20 13:46:34 +02001341 { .ival = "falloc",
1342 .help = "fallocate() file based engine",
1343 },
1344#endif
Jens Axboe214e1ec2007-03-15 10:48:13 +01001345 { .ival = "external",
1346 .help = "Load external engine (append name)",
1347 },
1348 },
1349 },
1350 {
1351 .name = "iodepth",
1352 .type = FIO_OPT_INT,
1353 .off1 = td_var_offset(iodepth),
Bruce Cran03e20d62011-01-02 20:14:54 +01001354 .help = "Number of IO buffers to keep in flight",
Jens Axboe757aff42007-12-12 19:42:13 +01001355 .minval = 1,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001356 .def = "1",
1357 },
1358 {
1359 .name = "iodepth_batch",
Jens Axboe49504212008-06-05 09:03:30 +02001360 .alias = "iodepth_batch_submit",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001361 .type = FIO_OPT_INT,
1362 .off1 = td_var_offset(iodepth_batch),
Jens Axboed65db442009-01-16 19:15:33 +01001363 .help = "Number of IO buffers to submit in one go",
Jens Axboeafdf9352007-07-31 16:14:34 +02001364 .parent = "iodepth",
Jens Axboea2e6f8a2008-01-18 10:28:11 +01001365 .minval = 1,
1366 .def = "1",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001367 },
1368 {
Jens Axboe49504212008-06-05 09:03:30 +02001369 .name = "iodepth_batch_complete",
1370 .type = FIO_OPT_INT,
1371 .off1 = td_var_offset(iodepth_batch_complete),
Jens Axboed65db442009-01-16 19:15:33 +01001372 .help = "Number of IO buffers to retrieve in one go",
Jens Axboe49504212008-06-05 09:03:30 +02001373 .parent = "iodepth",
1374 .minval = 0,
1375 .def = "1",
1376 },
1377 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001378 .name = "iodepth_low",
1379 .type = FIO_OPT_INT,
1380 .off1 = td_var_offset(iodepth_low),
1381 .help = "Low water mark for queuing depth",
Jens Axboeafdf9352007-07-31 16:14:34 +02001382 .parent = "iodepth",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001383 },
1384 {
1385 .name = "size",
1386 .type = FIO_OPT_STR_VAL,
Jens Axboe7bb59102011-07-12 19:47:03 +02001387 .cb = str_size_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001388 .help = "Total size of device or files",
1389 },
1390 {
Shawn Lewisaa31f1f2008-01-11 09:45:11 +01001391 .name = "fill_device",
Jens Axboe74586c12011-01-20 10:16:03 -07001392 .alias = "fill_fs",
Shawn Lewisaa31f1f2008-01-11 09:45:11 +01001393 .type = FIO_OPT_BOOL,
1394 .off1 = td_var_offset(fill_device),
1395 .help = "Write until an ENOSPC error occurs",
1396 .def = "0",
1397 },
1398 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001399 .name = "filesize",
1400 .type = FIO_OPT_STR_VAL,
1401 .off1 = td_var_offset(file_size_low),
1402 .off2 = td_var_offset(file_size_high),
Jens Axboec3edbdb2007-07-20 14:25:31 +02001403 .minval = 1,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001404 .help = "Size of individual files",
1405 },
1406 {
Jens Axboe67a10002007-07-31 23:12:16 +02001407 .name = "offset",
1408 .alias = "fileoffset",
1409 .type = FIO_OPT_STR_VAL,
1410 .off1 = td_var_offset(start_offset),
1411 .help = "Start IO from this offset",
1412 .def = "0",
1413 },
1414 {
Jens Axboe2d7cd862012-03-15 14:53:38 +01001415 .name = "offset_increment",
1416 .type = FIO_OPT_STR_VAL,
1417 .off1 = td_var_offset(offset_increment),
1418 .help = "What is the increment from one offset to the next",
1419 .parent = "offset",
1420 .def = "0",
1421 },
1422 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001423 .name = "bs",
Jens Axboed3aad8f2007-03-15 14:12:05 +01001424 .alias = "blocksize",
Jens Axboee01b22b2009-06-09 15:43:25 +02001425 .type = FIO_OPT_INT,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001426 .off1 = td_var_offset(bs[DDIR_READ]),
1427 .off2 = td_var_offset(bs[DDIR_WRITE]),
Shaohua Li6eaf09d2012-09-14 08:49:43 +02001428 .off3 = td_var_offset(bs[DDIR_TRIM]),
Jens Axboec3edbdb2007-07-20 14:25:31 +02001429 .minval = 1,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001430 .help = "Block size unit",
1431 .def = "4k",
Jens Axboe67a10002007-07-31 23:12:16 +02001432 .parent = "rw",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001433 },
1434 {
Jens Axboe2b7a01d2009-03-11 11:00:13 +01001435 .name = "ba",
1436 .alias = "blockalign",
Jens Axboee01b22b2009-06-09 15:43:25 +02001437 .type = FIO_OPT_INT,
Jens Axboe2b7a01d2009-03-11 11:00:13 +01001438 .off1 = td_var_offset(ba[DDIR_READ]),
1439 .off2 = td_var_offset(ba[DDIR_WRITE]),
Shaohua Li6eaf09d2012-09-14 08:49:43 +02001440 .off3 = td_var_offset(ba[DDIR_TRIM]),
Jens Axboe2b7a01d2009-03-11 11:00:13 +01001441 .minval = 1,
1442 .help = "IO block offset alignment",
1443 .parent = "rw",
1444 },
1445 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001446 .name = "bsrange",
Jens Axboed3aad8f2007-03-15 14:12:05 +01001447 .alias = "blocksize_range",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001448 .type = FIO_OPT_RANGE,
1449 .off1 = td_var_offset(min_bs[DDIR_READ]),
1450 .off2 = td_var_offset(max_bs[DDIR_READ]),
1451 .off3 = td_var_offset(min_bs[DDIR_WRITE]),
1452 .off4 = td_var_offset(max_bs[DDIR_WRITE]),
Shaohua Li6eaf09d2012-09-14 08:49:43 +02001453 .off5 = td_var_offset(min_bs[DDIR_TRIM]),
1454 .off6 = td_var_offset(max_bs[DDIR_TRIM]),
Jens Axboec3edbdb2007-07-20 14:25:31 +02001455 .minval = 1,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001456 .help = "Set block size range (in more detail than bs)",
Jens Axboe67a10002007-07-31 23:12:16 +02001457 .parent = "rw",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001458 },
1459 {
Jens Axboe564ca972007-12-14 12:21:19 +01001460 .name = "bssplit",
1461 .type = FIO_OPT_STR,
1462 .cb = str_bssplit_cb,
1463 .help = "Set a specific mix of block sizes",
1464 .parent = "rw",
1465 },
1466 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001467 .name = "bs_unaligned",
Jens Axboed3aad8f2007-03-15 14:12:05 +01001468 .alias = "blocksize_unaligned",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001469 .type = FIO_OPT_STR_SET,
1470 .off1 = td_var_offset(bs_unaligned),
1471 .help = "Don't sector align IO buffer sizes",
Jens Axboe67a10002007-07-31 23:12:16 +02001472 .parent = "rw",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001473 },
1474 {
1475 .name = "randrepeat",
1476 .type = FIO_OPT_BOOL,
1477 .off1 = td_var_offset(rand_repeatable),
1478 .help = "Use repeatable random IO pattern",
1479 .def = "1",
Jens Axboe67a10002007-07-31 23:12:16 +02001480 .parent = "rw",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001481 },
1482 {
Jens Axboe2615cc42011-03-28 09:35:09 +02001483 .name = "use_os_rand",
1484 .type = FIO_OPT_BOOL,
1485 .off1 = td_var_offset(use_os_rand),
1486 .help = "Set to use OS random generator",
1487 .def = "0",
1488 .parent = "rw",
1489 },
1490 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001491 .name = "norandommap",
1492 .type = FIO_OPT_STR_SET,
1493 .off1 = td_var_offset(norandommap),
1494 .help = "Accept potential duplicate random blocks",
Jens Axboe67a10002007-07-31 23:12:16 +02001495 .parent = "rw",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001496 },
1497 {
Jens Axboe2b386d22008-03-26 10:32:57 +01001498 .name = "softrandommap",
1499 .type = FIO_OPT_BOOL,
1500 .off1 = td_var_offset(softrandommap),
Jens Axboef66ab3c2008-06-05 11:48:22 +02001501 .help = "Set norandommap if randommap allocation fails",
Jens Axboe2b386d22008-03-26 10:32:57 +01001502 .parent = "norandommap",
1503 .def = "0",
1504 },
1505 {
Jens Axboe8055e412012-11-26 08:43:47 +01001506 .name = "random_generator",
1507 .type = FIO_OPT_STR,
1508 .off1 = td_var_offset(random_generator),
1509 .help = "Type of random number generator to use",
1510 .def = "tausworthe",
1511 .posval = {
1512 { .ival = "tausworthe",
1513 .oval = FIO_RAND_GEN_TAUSWORTHE,
1514 .help = "Strong Tausworthe generator",
1515 },
1516 { .ival = "lfsr",
1517 .oval = FIO_RAND_GEN_LFSR,
1518 .help = "Variable length LFSR",
1519 },
1520 },
1521 },
1522 {
Jens Axboee25839d2012-11-06 10:49:42 +01001523 .name = "random_distribution",
1524 .type = FIO_OPT_STR,
1525 .off1 = td_var_offset(random_distribution),
1526 .cb = str_random_distribution_cb,
1527 .help = "Random offset distribution generator",
1528 .def = "random",
1529 .posval = {
1530 { .ival = "random",
1531 .oval = FIO_RAND_DIST_RANDOM,
1532 .help = "Completely random",
1533 },
1534 { .ival = "zipf",
1535 .oval = FIO_RAND_DIST_ZIPF,
1536 .help = "Zipf distribution",
1537 },
Jens Axboe925fee32012-11-06 13:50:32 +01001538 { .ival = "pareto",
1539 .oval = FIO_RAND_DIST_PARETO,
1540 .help = "Pareto distribution",
1541 },
Jens Axboee25839d2012-11-06 10:49:42 +01001542 },
1543 },
1544 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001545 .name = "nrfiles",
Jens Axboed7c8be02010-11-25 08:21:39 +01001546 .alias = "nr_files",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001547 .type = FIO_OPT_INT,
1548 .off1 = td_var_offset(nr_files),
1549 .help = "Split job workload between this number of files",
1550 .def = "1",
1551 },
1552 {
1553 .name = "openfiles",
1554 .type = FIO_OPT_INT,
1555 .off1 = td_var_offset(open_files),
1556 .help = "Number of files to keep open at the same time",
1557 },
1558 {
1559 .name = "file_service_type",
1560 .type = FIO_OPT_STR,
1561 .cb = str_fst_cb,
1562 .off1 = td_var_offset(file_service_type),
1563 .help = "How to select which file to service next",
1564 .def = "roundrobin",
1565 .posval = {
1566 { .ival = "random",
1567 .oval = FIO_FSERVICE_RANDOM,
1568 .help = "Choose a file at random",
1569 },
1570 { .ival = "roundrobin",
1571 .oval = FIO_FSERVICE_RR,
1572 .help = "Round robin select files",
1573 },
Jens Axboea086c252009-03-04 08:27:37 +01001574 { .ival = "sequential",
1575 .oval = FIO_FSERVICE_SEQ,
1576 .help = "Finish one file before moving to the next",
1577 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01001578 },
Jens Axboe67a10002007-07-31 23:12:16 +02001579 .parent = "nrfiles",
1580 },
Jens Axboe97ac9922013-01-24 15:00:25 -07001581#ifdef CONFIG_POSIX_FALLOCATE
Jens Axboe7bc8c2c2010-01-28 11:31:31 +01001582 {
1583 .name = "fallocate",
Eric Gourioua596f042011-06-17 09:11:45 +02001584 .type = FIO_OPT_STR,
1585 .off1 = td_var_offset(fallocate_mode),
1586 .help = "Whether pre-allocation is performed when laying out files",
1587 .def = "posix",
1588 .posval = {
1589 { .ival = "none",
1590 .oval = FIO_FALLOCATE_NONE,
1591 .help = "Do not pre-allocate space",
1592 },
1593 { .ival = "posix",
1594 .oval = FIO_FALLOCATE_POSIX,
1595 .help = "Use posix_fallocate()",
1596 },
Jens Axboe97ac9922013-01-24 15:00:25 -07001597#ifdef CONFIG_LINUX_FALLOCATE
Eric Gourioua596f042011-06-17 09:11:45 +02001598 { .ival = "keep",
1599 .oval = FIO_FALLOCATE_KEEP_SIZE,
1600 .help = "Use fallocate(..., FALLOC_FL_KEEP_SIZE, ...)",
1601 },
Jens Axboe7bc8c2c2010-01-28 11:31:31 +01001602#endif
Eric Gourioua596f042011-06-17 09:11:45 +02001603 /* Compatibility with former boolean values */
1604 { .ival = "0",
1605 .oval = FIO_FALLOCATE_NONE,
1606 .help = "Alias for 'none'",
1607 },
1608 { .ival = "1",
1609 .oval = FIO_FALLOCATE_POSIX,
1610 .help = "Alias for 'posix'",
1611 },
1612 },
1613 },
Jens Axboe97ac9922013-01-24 15:00:25 -07001614#endif /* CONFIG_POSIX_FALLOCATE */
Jens Axboe67a10002007-07-31 23:12:16 +02001615 {
1616 .name = "fadvise_hint",
1617 .type = FIO_OPT_BOOL,
1618 .off1 = td_var_offset(fadvise_hint),
1619 .help = "Use fadvise() to advise the kernel on IO pattern",
1620 .def = "1",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001621 },
1622 {
1623 .name = "fsync",
1624 .type = FIO_OPT_INT,
1625 .off1 = td_var_offset(fsync_blocks),
1626 .help = "Issue fsync for writes every given number of blocks",
1627 .def = "0",
1628 },
1629 {
Jens Axboe5f9099e2009-06-16 22:40:26 +02001630 .name = "fdatasync",
1631 .type = FIO_OPT_INT,
1632 .off1 = td_var_offset(fdatasync_blocks),
1633 .help = "Issue fdatasync for writes every given number of blocks",
1634 .def = "0",
1635 },
Jens Axboe1ef2b6b2010-10-08 15:07:01 +02001636 {
1637 .name = "write_barrier",
1638 .type = FIO_OPT_INT,
1639 .off1 = td_var_offset(barrier_blocks),
1640 .help = "Make every Nth write a barrier write",
1641 .def = "0",
1642 },
Jens Axboe67bf9822013-01-10 11:23:19 +01001643#ifdef CONFIG_SYNC_FILE_RANGE
Jens Axboe44f29692010-03-09 20:09:44 +01001644 {
1645 .name = "sync_file_range",
1646 .posval = {
1647 { .ival = "wait_before",
1648 .oval = SYNC_FILE_RANGE_WAIT_BEFORE,
1649 .help = "SYNC_FILE_RANGE_WAIT_BEFORE",
Jens Axboe3843deb2010-03-09 20:41:15 +01001650 .or = 1,
Jens Axboe44f29692010-03-09 20:09:44 +01001651 },
1652 { .ival = "write",
1653 .oval = SYNC_FILE_RANGE_WRITE,
1654 .help = "SYNC_FILE_RANGE_WRITE",
Jens Axboe3843deb2010-03-09 20:41:15 +01001655 .or = 1,
Jens Axboe44f29692010-03-09 20:09:44 +01001656 },
1657 {
1658 .ival = "wait_after",
1659 .oval = SYNC_FILE_RANGE_WAIT_AFTER,
1660 .help = "SYNC_FILE_RANGE_WAIT_AFTER",
Jens Axboe3843deb2010-03-09 20:41:15 +01001661 .or = 1,
Jens Axboe44f29692010-03-09 20:09:44 +01001662 },
1663 },
Jens Axboe3843deb2010-03-09 20:41:15 +01001664 .type = FIO_OPT_STR_MULTI,
Jens Axboe44f29692010-03-09 20:09:44 +01001665 .cb = str_sfr_cb,
1666 .off1 = td_var_offset(sync_file_range),
1667 .help = "Use sync_file_range()",
1668 },
1669#endif
Jens Axboe5f9099e2009-06-16 22:40:26 +02001670 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001671 .name = "direct",
1672 .type = FIO_OPT_BOOL,
1673 .off1 = td_var_offset(odirect),
1674 .help = "Use O_DIRECT IO (negates buffered)",
1675 .def = "0",
1676 },
1677 {
1678 .name = "buffered",
1679 .type = FIO_OPT_BOOL,
1680 .off1 = td_var_offset(odirect),
1681 .neg = 1,
1682 .help = "Use buffered IO (negates direct)",
1683 .def = "1",
1684 },
1685 {
1686 .name = "overwrite",
1687 .type = FIO_OPT_BOOL,
1688 .off1 = td_var_offset(overwrite),
1689 .help = "When writing, set whether to overwrite current data",
1690 .def = "0",
1691 },
1692 {
1693 .name = "loops",
1694 .type = FIO_OPT_INT,
1695 .off1 = td_var_offset(loops),
1696 .help = "Number of times to run the job",
1697 .def = "1",
1698 },
1699 {
1700 .name = "numjobs",
1701 .type = FIO_OPT_INT,
1702 .off1 = td_var_offset(numjobs),
1703 .help = "Duplicate this job this many times",
1704 .def = "1",
1705 },
1706 {
1707 .name = "startdelay",
Jens Axboea5737c92010-06-29 10:40:30 +02001708 .type = FIO_OPT_STR_VAL_TIME,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001709 .off1 = td_var_offset(start_delay),
1710 .help = "Only start job when this period has passed",
1711 .def = "0",
1712 },
1713 {
1714 .name = "runtime",
1715 .alias = "timeout",
1716 .type = FIO_OPT_STR_VAL_TIME,
1717 .off1 = td_var_offset(timeout),
1718 .help = "Stop workload when this amount of time has passed",
1719 .def = "0",
1720 },
1721 {
Jens Axboecf4464c2007-04-17 20:14:42 +02001722 .name = "time_based",
1723 .type = FIO_OPT_STR_SET,
1724 .off1 = td_var_offset(time_based),
1725 .help = "Keep running until runtime/timeout is met",
1726 },
1727 {
Jens Axboe721938a2008-09-10 09:46:16 +02001728 .name = "ramp_time",
1729 .type = FIO_OPT_STR_VAL_TIME,
1730 .off1 = td_var_offset(ramp_time),
1731 .help = "Ramp up time before measuring performance",
1732 },
1733 {
Jens Axboec223da82010-03-24 13:23:53 +01001734 .name = "clocksource",
1735 .type = FIO_OPT_STR,
1736 .cb = fio_clock_source_cb,
1737 .off1 = td_var_offset(clocksource),
1738 .help = "What type of timing source to use",
Jens Axboec223da82010-03-24 13:23:53 +01001739 .posval = {
Jens Axboe67bf9822013-01-10 11:23:19 +01001740#ifdef CONFIG_GETTIMEOFDAY
Jens Axboec223da82010-03-24 13:23:53 +01001741 { .ival = "gettimeofday",
1742 .oval = CS_GTOD,
1743 .help = "Use gettimeofday(2) for timing",
1744 },
Jens Axboe67bf9822013-01-10 11:23:19 +01001745#endif
1746#ifdef CONFIG_CLOCK_GETTIME
Jens Axboec223da82010-03-24 13:23:53 +01001747 { .ival = "clock_gettime",
1748 .oval = CS_CGETTIME,
1749 .help = "Use clock_gettime(2) for timing",
1750 },
Jens Axboe67bf9822013-01-10 11:23:19 +01001751#endif
Jens Axboec223da82010-03-24 13:23:53 +01001752#ifdef ARCH_HAVE_CPU_CLOCK
1753 { .ival = "cpu",
1754 .oval = CS_CPUCLOCK,
1755 .help = "Use CPU private clock",
1756 },
1757#endif
1758 },
1759 },
1760 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001761 .name = "mem",
Jens Axboed3aad8f2007-03-15 14:12:05 +01001762 .alias = "iomem",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001763 .type = FIO_OPT_STR,
1764 .cb = str_mem_cb,
1765 .off1 = td_var_offset(mem_type),
1766 .help = "Backing type for IO buffers",
1767 .def = "malloc",
1768 .posval = {
1769 { .ival = "malloc",
1770 .oval = MEM_MALLOC,
1771 .help = "Use malloc(3) for IO buffers",
1772 },
Jens Axboeb370e462007-03-19 10:51:49 +01001773 { .ival = "shm",
1774 .oval = MEM_SHM,
1775 .help = "Use shared memory segments for IO buffers",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001776 },
1777#ifdef FIO_HAVE_HUGETLB
Jens Axboe37c8cdf2007-03-19 13:14:03 +01001778 { .ival = "shmhuge",
1779 .oval = MEM_SHMHUGE,
1780 .help = "Like shm, but use huge pages",
Jens Axboe214e1ec2007-03-15 10:48:13 +01001781 },
1782#endif
Jens Axboeb370e462007-03-19 10:51:49 +01001783 { .ival = "mmap",
1784 .oval = MEM_MMAP,
1785 .help = "Use mmap(2) (file or anon) for IO buffers",
1786 },
Jens Axboe37c8cdf2007-03-19 13:14:03 +01001787#ifdef FIO_HAVE_HUGETLB
1788 { .ival = "mmaphuge",
1789 .oval = MEM_MMAPHUGE,
1790 .help = "Like mmap, but use huge pages",
1791 },
1792#endif
Jens Axboe214e1ec2007-03-15 10:48:13 +01001793 },
1794 },
1795 {
Jens Axboed529ee12009-07-01 10:33:03 +02001796 .name = "iomem_align",
1797 .alias = "mem_align",
1798 .type = FIO_OPT_INT,
1799 .off1 = td_var_offset(mem_align),
1800 .minval = 0,
1801 .help = "IO memory buffer offset alignment",
1802 .def = "0",
1803 .parent = "iomem",
1804 },
1805 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01001806 .name = "verify",
1807 .type = FIO_OPT_STR,
1808 .off1 = td_var_offset(verify),
1809 .help = "Verify data written",
Jens Axboe5d7c5d32010-06-21 15:08:17 +02001810 .cb = str_verify_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01001811 .def = "0",
1812 .posval = {
1813 { .ival = "0",
1814 .oval = VERIFY_NONE,
1815 .help = "Don't do IO verification",
1816 },
Jens Axboefcca4b52007-07-27 15:42:00 +02001817 { .ival = "md5",
1818 .oval = VERIFY_MD5,
1819 .help = "Use md5 checksums for verification",
1820 },
Jens Axboed77a7af2007-07-27 15:35:06 +02001821 { .ival = "crc64",
1822 .oval = VERIFY_CRC64,
1823 .help = "Use crc64 checksums for verification",
1824 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01001825 { .ival = "crc32",
1826 .oval = VERIFY_CRC32,
1827 .help = "Use crc32 checksums for verification",
1828 },
Jens Axboeaf497e62008-08-04 15:40:35 +02001829 { .ival = "crc32c-intel",
Jens Axboee3aaafc2012-02-22 20:28:17 +01001830 .oval = VERIFY_CRC32C,
1831 .help = "Use crc32c checksums for verification (hw assisted, if available)",
Jens Axboeaf497e62008-08-04 15:40:35 +02001832 },
Jens Axboebac39e02008-06-11 20:46:19 +02001833 { .ival = "crc32c",
1834 .oval = VERIFY_CRC32C,
Jens Axboee3aaafc2012-02-22 20:28:17 +01001835 .help = "Use crc32c checksums for verification (hw assisted, if available)",
Jens Axboebac39e02008-06-11 20:46:19 +02001836 },
Jens Axboe969f7ed2007-07-27 09:07:17 +02001837 { .ival = "crc16",
1838 .oval = VERIFY_CRC16,
1839 .help = "Use crc16 checksums for verification",
1840 },
Jens Axboe1e154bd2007-07-27 09:52:40 +02001841 { .ival = "crc7",
1842 .oval = VERIFY_CRC7,
1843 .help = "Use crc7 checksums for verification",
1844 },
Jens Axboe7c353ce2009-08-09 22:40:33 +02001845 { .ival = "sha1",
1846 .oval = VERIFY_SHA1,
1847 .help = "Use sha1 checksums for verification",
1848 },
Jens Axboecd14cc12007-07-30 10:59:33 +02001849 { .ival = "sha256",
1850 .oval = VERIFY_SHA256,
1851 .help = "Use sha256 checksums for verification",
1852 },
1853 { .ival = "sha512",
1854 .oval = VERIFY_SHA512,
1855 .help = "Use sha512 checksums for verification",
1856 },
Shawn Lewis7437ee82007-08-02 21:05:58 +02001857 { .ival = "meta",
1858 .oval = VERIFY_META,
1859 .help = "Use io information",
1860 },
Jens Axboe36690c92007-03-26 10:23:34 +02001861 {
1862 .ival = "null",
1863 .oval = VERIFY_NULL,
1864 .help = "Pretend to verify",
1865 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01001866 },
1867 },
1868 {
Jens Axboe005c5652007-08-02 22:21:36 +02001869 .name = "do_verify",
Jens Axboe68e1f292007-08-10 10:32:14 +02001870 .type = FIO_OPT_BOOL,
Jens Axboe005c5652007-08-02 22:21:36 +02001871 .off1 = td_var_offset(do_verify),
1872 .help = "Run verification stage after write",
1873 .def = "1",
1874 .parent = "verify",
1875 },
1876 {
Jens Axboe160b9662007-03-27 10:59:49 +02001877 .name = "verifysort",
1878 .type = FIO_OPT_BOOL,
1879 .off1 = td_var_offset(verifysort),
1880 .help = "Sort written verify blocks for read back",
1881 .def = "1",
Jens Axboec83f2df2007-07-31 22:51:47 +02001882 .parent = "verify",
Jens Axboe160b9662007-03-27 10:59:49 +02001883 },
1884 {
Jens Axboe1ae83d42013-01-12 01:44:15 -07001885 .name = "verifysort_nr",
1886 .type = FIO_OPT_INT,
1887 .off1 = td_var_offset(verifysort_nr),
1888 .help = "Pre-load and sort verify blocks for a read workload",
1889 .minval = 0,
1890 .maxval = 131072,
1891 .def = "1024",
1892 .parent = "verify",
1893 },
1894 {
Jens Axboea59e1702007-07-30 08:53:27 +02001895 .name = "verify_interval",
Jens Axboee01b22b2009-06-09 15:43:25 +02001896 .type = FIO_OPT_INT,
Jens Axboea59e1702007-07-30 08:53:27 +02001897 .off1 = td_var_offset(verify_interval),
Jens Axboe819a9682007-07-28 21:30:31 +02001898 .minval = 2 * sizeof(struct verify_header),
Jens Axboea59e1702007-07-30 08:53:27 +02001899 .help = "Store verify buffer header every N bytes",
Jens Axboeafdf9352007-07-31 16:14:34 +02001900 .parent = "verify",
Shawn Lewis3f9f4e22007-07-28 21:10:37 +02001901 },
1902 {
Jens Axboea59e1702007-07-30 08:53:27 +02001903 .name = "verify_offset",
Jens Axboee01b22b2009-06-09 15:43:25 +02001904 .type = FIO_OPT_INT,
Jens Axboea59e1702007-07-30 08:53:27 +02001905 .help = "Offset verify header location by N bytes",
Shawn Lewis546a9142007-07-28 21:11:37 +02001906 .def = "0",
Jens Axboe5ec10ea2008-03-06 15:42:00 +01001907 .cb = str_verify_offset_cb,
Jens Axboeafdf9352007-07-31 16:14:34 +02001908 .parent = "verify",
Shawn Lewis546a9142007-07-28 21:11:37 +02001909 },
1910 {
Shawn Lewise28218f2008-01-16 11:01:33 +01001911 .name = "verify_pattern",
Radha Ramachandran0e92f872009-10-27 20:14:27 +01001912 .type = FIO_OPT_STR,
Shawn Lewise28218f2008-01-16 11:01:33 +01001913 .cb = str_verify_pattern_cb,
1914 .help = "Fill pattern for IO buffers",
1915 .parent = "verify",
1916 },
1917 {
Jens Axboea12a3b42007-08-09 10:20:54 +02001918 .name = "verify_fatal",
Jens Axboe68e1f292007-08-10 10:32:14 +02001919 .type = FIO_OPT_BOOL,
Jens Axboea12a3b42007-08-09 10:20:54 +02001920 .off1 = td_var_offset(verify_fatal),
1921 .def = "0",
1922 .help = "Exit on a single verify failure, don't continue",
1923 .parent = "verify",
1924 },
1925 {
Jens Axboeb463e932011-01-12 09:03:23 +01001926 .name = "verify_dump",
1927 .type = FIO_OPT_BOOL,
1928 .off1 = td_var_offset(verify_dump),
Jens Axboeef71e312011-10-25 22:43:36 +02001929 .def = "0",
Jens Axboeb463e932011-01-12 09:03:23 +01001930 .help = "Dump contents of good and bad blocks on failure",
1931 .parent = "verify",
1932 },
1933 {
Jens Axboee8462bd2009-07-06 12:59:04 +02001934 .name = "verify_async",
1935 .type = FIO_OPT_INT,
1936 .off1 = td_var_offset(verify_async),
1937 .def = "0",
1938 .help = "Number of async verifier threads to use",
1939 .parent = "verify",
1940 },
Jens Axboe9e144182010-06-15 14:25:36 +02001941 {
1942 .name = "verify_backlog",
1943 .type = FIO_OPT_STR_VAL,
1944 .off1 = td_var_offset(verify_backlog),
1945 .help = "Verify after this number of blocks are written",
1946 .parent = "verify",
1947 },
1948 {
1949 .name = "verify_backlog_batch",
1950 .type = FIO_OPT_INT,
1951 .off1 = td_var_offset(verify_batch),
1952 .help = "Verify this number of IO blocks",
Jens Axboe0d29de82010-09-01 13:54:15 +02001953 .parent = "verify",
Jens Axboe9e144182010-06-15 14:25:36 +02001954 },
Jens Axboee8462bd2009-07-06 12:59:04 +02001955#ifdef FIO_HAVE_CPU_AFFINITY
1956 {
1957 .name = "verify_async_cpus",
1958 .type = FIO_OPT_STR,
1959 .cb = str_verify_cpus_allowed_cb,
1960 .help = "Set CPUs allowed for async verify threads",
1961 .parent = "verify_async",
1962 },
1963#endif
Jens Axboe51aa2da2013-01-21 10:55:02 -07001964 {
1965 .name = "experimental_verify",
1966 .off1 = td_var_offset(experimental_verify),
1967 .type = FIO_OPT_BOOL,
Jens Axboeb31eaac2013-01-24 15:29:58 -07001968 .help = "Enable experimental verification",
Jens Axboe51aa2da2013-01-21 10:55:02 -07001969 },
Jens Axboe0d29de82010-09-01 13:54:15 +02001970#ifdef FIO_HAVE_TRIM
1971 {
1972 .name = "trim_percentage",
1973 .type = FIO_OPT_INT,
1974 .cb = str_verify_trim_cb,
1975 .maxval = 100,
1976 .help = "Number of verify blocks to discard/trim",
1977 .parent = "verify",
1978 .def = "0",
1979 },
1980 {
1981 .name = "trim_verify_zero",
1982 .type = FIO_OPT_INT,
1983 .help = "Verify that trim/discarded blocks are returned as zeroes",
1984 .off1 = td_var_offset(trim_zero),
1985 .parent = "trim_percentage",
1986 .def = "1",
1987 },
1988 {
1989 .name = "trim_backlog",
1990 .type = FIO_OPT_STR_VAL,
1991 .off1 = td_var_offset(trim_backlog),
1992 .help = "Trim after this number of blocks are written",
1993 .parent = "trim_percentage",
1994 },
1995 {
1996 .name = "trim_backlog_batch",
1997 .type = FIO_OPT_INT,
1998 .off1 = td_var_offset(trim_batch),
1999 .help = "Trim this number of IO blocks",
2000 .parent = "trim_percentage",
2001 },
2002#endif
Jens Axboee8462bd2009-07-06 12:59:04 +02002003 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01002004 .name = "write_iolog",
2005 .type = FIO_OPT_STR_STORE,
2006 .off1 = td_var_offset(write_iolog_file),
2007 .help = "Store IO pattern to file",
2008 },
2009 {
2010 .name = "read_iolog",
2011 .type = FIO_OPT_STR_STORE,
2012 .off1 = td_var_offset(read_iolog_file),
2013 .help = "Playback IO pattern from file",
2014 },
2015 {
David Nellans64bbb862010-08-24 22:13:30 +02002016 .name = "replay_no_stall",
2017 .type = FIO_OPT_INT,
2018 .off1 = td_var_offset(no_stall),
2019 .def = "0",
Jens Axboe87e7a972010-08-25 09:01:25 +02002020 .parent = "read_iolog",
David Nellans64bbb862010-08-24 22:13:30 +02002021 .help = "Playback IO pattern file as fast as possible without stalls",
2022 },
2023 {
David Nellansd1c46c02010-08-31 21:20:47 +02002024 .name = "replay_redirect",
2025 .type = FIO_OPT_STR_STORE,
2026 .off1 = td_var_offset(replay_redirect),
2027 .parent = "read_iolog",
2028 .help = "Replay all I/O onto this device, regardless of trace device",
2029 },
2030 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01002031 .name = "exec_prerun",
2032 .type = FIO_OPT_STR_STORE,
2033 .off1 = td_var_offset(exec_prerun),
2034 .help = "Execute this file prior to running job",
2035 },
2036 {
2037 .name = "exec_postrun",
2038 .type = FIO_OPT_STR_STORE,
2039 .off1 = td_var_offset(exec_postrun),
2040 .help = "Execute this file after running job",
2041 },
2042#ifdef FIO_HAVE_IOSCHED_SWITCH
2043 {
2044 .name = "ioscheduler",
2045 .type = FIO_OPT_STR_STORE,
2046 .off1 = td_var_offset(ioscheduler),
2047 .help = "Use this IO scheduler on the backing device",
2048 },
2049#endif
2050 {
2051 .name = "zonesize",
2052 .type = FIO_OPT_STR_VAL,
2053 .off1 = td_var_offset(zone_size),
Steven Noonaned335852012-01-31 13:58:00 +01002054 .help = "Amount of data to read per zone",
2055 .def = "0",
2056 },
2057 {
2058 .name = "zonerange",
2059 .type = FIO_OPT_STR_VAL,
2060 .off1 = td_var_offset(zone_range),
Jens Axboe214e1ec2007-03-15 10:48:13 +01002061 .help = "Give size of an IO zone",
2062 .def = "0",
2063 },
2064 {
2065 .name = "zoneskip",
2066 .type = FIO_OPT_STR_VAL,
2067 .off1 = td_var_offset(zone_skip),
2068 .help = "Space between IO zones",
2069 .def = "0",
2070 },
2071 {
2072 .name = "lockmem",
2073 .type = FIO_OPT_STR_VAL,
2074 .cb = str_lockmem_cb,
2075 .help = "Lock down this amount of memory",
2076 .def = "0",
2077 },
2078 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01002079 .name = "rwmixread",
2080 .type = FIO_OPT_INT,
Jens Axboecb499fc2008-05-28 10:33:32 +02002081 .cb = str_rwmix_read_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002082 .maxval = 100,
2083 .help = "Percentage of mixed workload that is reads",
2084 .def = "50",
2085 },
2086 {
2087 .name = "rwmixwrite",
2088 .type = FIO_OPT_INT,
Jens Axboecb499fc2008-05-28 10:33:32 +02002089 .cb = str_rwmix_write_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002090 .maxval = 100,
2091 .help = "Percentage of mixed workload that is writes",
2092 .def = "50",
2093 },
2094 {
Jens Axboeafdf9352007-07-31 16:14:34 +02002095 .name = "rwmixcycle",
Jens Axboe15ca1502008-04-07 09:26:02 +02002096 .type = FIO_OPT_DEPRECATED,
Jens Axboeafdf9352007-07-31 16:14:34 +02002097 },
2098 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01002099 .name = "nice",
2100 .type = FIO_OPT_INT,
2101 .off1 = td_var_offset(nice),
2102 .help = "Set job CPU nice value",
2103 .minval = -19,
2104 .maxval = 20,
2105 .def = "0",
2106 },
2107#ifdef FIO_HAVE_IOPRIO
2108 {
2109 .name = "prio",
2110 .type = FIO_OPT_INT,
2111 .cb = str_prio_cb,
2112 .help = "Set job IO priority value",
2113 .minval = 0,
2114 .maxval = 7,
2115 },
2116 {
2117 .name = "prioclass",
2118 .type = FIO_OPT_INT,
2119 .cb = str_prioclass_cb,
2120 .help = "Set job IO priority class",
2121 .minval = 0,
2122 .maxval = 3,
2123 },
2124#endif
2125 {
2126 .name = "thinktime",
2127 .type = FIO_OPT_INT,
2128 .off1 = td_var_offset(thinktime),
2129 .help = "Idle time between IO buffers (usec)",
2130 .def = "0",
2131 },
2132 {
2133 .name = "thinktime_spin",
2134 .type = FIO_OPT_INT,
2135 .off1 = td_var_offset(thinktime_spin),
2136 .help = "Start think time by spinning this amount (usec)",
2137 .def = "0",
Jens Axboeafdf9352007-07-31 16:14:34 +02002138 .parent = "thinktime",
Jens Axboe214e1ec2007-03-15 10:48:13 +01002139 },
2140 {
2141 .name = "thinktime_blocks",
2142 .type = FIO_OPT_INT,
2143 .off1 = td_var_offset(thinktime_blocks),
2144 .help = "IO buffer period between 'thinktime'",
2145 .def = "1",
Jens Axboeafdf9352007-07-31 16:14:34 +02002146 .parent = "thinktime",
Jens Axboe214e1ec2007-03-15 10:48:13 +01002147 },
2148 {
2149 .name = "rate",
Jens Axboee01b22b2009-06-09 15:43:25 +02002150 .type = FIO_OPT_INT,
Shaohua Li6eaf09d2012-09-14 08:49:43 +02002151 .off1 = td_var_offset(rate[DDIR_READ]),
2152 .off2 = td_var_offset(rate[DDIR_WRITE]),
2153 .off3 = td_var_offset(rate[DDIR_TRIM]),
Jens Axboe214e1ec2007-03-15 10:48:13 +01002154 .help = "Set bandwidth rate",
2155 },
2156 {
2157 .name = "ratemin",
Jens Axboee01b22b2009-06-09 15:43:25 +02002158 .type = FIO_OPT_INT,
Shaohua Li6eaf09d2012-09-14 08:49:43 +02002159 .off1 = td_var_offset(ratemin[DDIR_READ]),
2160 .off2 = td_var_offset(ratemin[DDIR_WRITE]),
2161 .off3 = td_var_offset(ratemin[DDIR_TRIM]),
Jens Axboe4e991c22007-03-15 11:41:11 +01002162 .help = "Job must meet this rate or it will be shutdown",
Jens Axboeafdf9352007-07-31 16:14:34 +02002163 .parent = "rate",
Jens Axboe4e991c22007-03-15 11:41:11 +01002164 },
2165 {
2166 .name = "rate_iops",
Jens Axboee01b22b2009-06-09 15:43:25 +02002167 .type = FIO_OPT_INT,
Shaohua Li6eaf09d2012-09-14 08:49:43 +02002168 .off1 = td_var_offset(rate_iops[DDIR_READ]),
2169 .off2 = td_var_offset(rate_iops[DDIR_WRITE]),
2170 .off3 = td_var_offset(rate_iops[DDIR_TRIM]),
Jens Axboe4e991c22007-03-15 11:41:11 +01002171 .help = "Limit IO used to this number of IO operations/sec",
2172 },
2173 {
2174 .name = "rate_iops_min",
Jens Axboee01b22b2009-06-09 15:43:25 +02002175 .type = FIO_OPT_INT,
Shaohua Li6eaf09d2012-09-14 08:49:43 +02002176 .off1 = td_var_offset(rate_iops_min[DDIR_READ]),
2177 .off2 = td_var_offset(rate_iops_min[DDIR_WRITE]),
2178 .off3 = td_var_offset(rate_iops_min[DDIR_TRIM]),
Bruce Cran03e20d62011-01-02 20:14:54 +01002179 .help = "Job must meet this rate or it will be shut down",
Jens Axboeafdf9352007-07-31 16:14:34 +02002180 .parent = "rate_iops",
Jens Axboe214e1ec2007-03-15 10:48:13 +01002181 },
2182 {
2183 .name = "ratecycle",
2184 .type = FIO_OPT_INT,
2185 .off1 = td_var_offset(ratecycle),
2186 .help = "Window average for rate limits (msec)",
2187 .def = "1000",
Jens Axboeafdf9352007-07-31 16:14:34 +02002188 .parent = "rate",
Jens Axboe214e1ec2007-03-15 10:48:13 +01002189 },
2190 {
Jens Axboe15501532012-10-24 16:37:45 +02002191 .name = "max_latency",
2192 .type = FIO_OPT_INT,
2193 .off1 = td_var_offset(max_latency),
2194 .help = "Maximum tolerated IO latency (usec)",
2195 },
2196 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01002197 .name = "invalidate",
2198 .type = FIO_OPT_BOOL,
2199 .off1 = td_var_offset(invalidate_cache),
2200 .help = "Invalidate buffer/page cache prior to running job",
2201 .def = "1",
2202 },
2203 {
2204 .name = "sync",
2205 .type = FIO_OPT_BOOL,
2206 .off1 = td_var_offset(sync_io),
2207 .help = "Use O_SYNC for buffered writes",
2208 .def = "0",
Jens Axboe67a10002007-07-31 23:12:16 +02002209 .parent = "buffered",
Jens Axboe214e1ec2007-03-15 10:48:13 +01002210 },
2211 {
2212 .name = "bwavgtime",
2213 .type = FIO_OPT_INT,
2214 .off1 = td_var_offset(bw_avg_time),
Jens Axboe5ec10ea2008-03-06 15:42:00 +01002215 .help = "Time window over which to calculate bandwidth"
2216 " (msec)",
Jens Axboe214e1ec2007-03-15 10:48:13 +01002217 .def = "500",
Jens Axboec8eeb9d2011-10-05 14:02:22 +02002218 .parent = "write_bw_log",
2219 },
2220 {
2221 .name = "iopsavgtime",
2222 .type = FIO_OPT_INT,
2223 .off1 = td_var_offset(iops_avg_time),
2224 .help = "Time window over which to calculate IOPS (msec)",
2225 .def = "500",
2226 .parent = "write_iops_log",
Jens Axboe214e1ec2007-03-15 10:48:13 +01002227 },
2228 {
2229 .name = "create_serialize",
2230 .type = FIO_OPT_BOOL,
2231 .off1 = td_var_offset(create_serialize),
2232 .help = "Serialize creating of job files",
2233 .def = "1",
2234 },
2235 {
2236 .name = "create_fsync",
2237 .type = FIO_OPT_BOOL,
2238 .off1 = td_var_offset(create_fsync),
Bruce Cran03e20d62011-01-02 20:14:54 +01002239 .help = "fsync file after creation",
Jens Axboe214e1ec2007-03-15 10:48:13 +01002240 .def = "1",
2241 },
2242 {
Jens Axboe814452b2009-03-04 12:53:13 +01002243 .name = "create_on_open",
2244 .type = FIO_OPT_BOOL,
2245 .off1 = td_var_offset(create_on_open),
2246 .help = "Create files when they are opened for IO",
2247 .def = "0",
2248 },
Jens Axboe0b9d69e2009-09-11 22:29:54 +02002249 {
Jens Axboe25460cf2012-05-02 13:58:02 +02002250 .name = "create_only",
2251 .type = FIO_OPT_BOOL,
2252 .off1 = td_var_offset(create_only),
2253 .help = "Only perform file creation phase",
2254 .def = "0",
2255 },
2256 {
Zhang, Yanminafad68f2009-05-20 11:30:55 +02002257 .name = "pre_read",
2258 .type = FIO_OPT_BOOL,
2259 .off1 = td_var_offset(pre_read),
Bruce Cran03e20d62011-01-02 20:14:54 +01002260 .help = "Pre-read files before starting official testing",
Zhang, Yanminafad68f2009-05-20 11:30:55 +02002261 .def = "0",
2262 },
Jens Axboe814452b2009-03-04 12:53:13 +01002263 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01002264 .name = "cpuload",
2265 .type = FIO_OPT_INT,
2266 .off1 = td_var_offset(cpuload),
2267 .help = "Use this percentage of CPU",
2268 },
2269 {
2270 .name = "cpuchunks",
2271 .type = FIO_OPT_INT,
2272 .off1 = td_var_offset(cpucycle),
2273 .help = "Length of the CPU burn cycles (usecs)",
2274 .def = "50000",
Jens Axboe67a10002007-07-31 23:12:16 +02002275 .parent = "cpuload",
Jens Axboe214e1ec2007-03-15 10:48:13 +01002276 },
2277#ifdef FIO_HAVE_CPU_AFFINITY
2278 {
2279 .name = "cpumask",
2280 .type = FIO_OPT_INT,
2281 .cb = str_cpumask_cb,
2282 .help = "CPU affinity mask",
2283 },
Jens Axboed2e268b2007-06-15 10:33:49 +02002284 {
2285 .name = "cpus_allowed",
2286 .type = FIO_OPT_STR,
2287 .cb = str_cpus_allowed_cb,
2288 .help = "Set CPUs allowed",
2289 },
Jens Axboe214e1ec2007-03-15 10:48:13 +01002290#endif
Jens Axboe67bf9822013-01-10 11:23:19 +01002291#ifdef CONFIG_LIBNUMA
Yufei Rend0b937e2012-10-19 23:11:52 -04002292 {
2293 .name = "numa_cpu_nodes",
2294 .type = FIO_OPT_STR,
2295 .cb = str_numa_cpunodes_cb,
2296 .help = "NUMA CPU nodes bind",
2297 },
2298 {
2299 .name = "numa_mem_policy",
2300 .type = FIO_OPT_STR,
2301 .cb = str_numa_mpol_cb,
2302 .help = "NUMA memory policy setup",
2303 },
2304#endif
Jens Axboe214e1ec2007-03-15 10:48:13 +01002305 {
2306 .name = "end_fsync",
2307 .type = FIO_OPT_BOOL,
2308 .off1 = td_var_offset(end_fsync),
2309 .help = "Include fsync at the end of job",
2310 .def = "0",
2311 },
2312 {
2313 .name = "fsync_on_close",
2314 .type = FIO_OPT_BOOL,
2315 .off1 = td_var_offset(fsync_on_close),
2316 .help = "fsync files on close",
2317 .def = "0",
2318 },
2319 {
2320 .name = "unlink",
2321 .type = FIO_OPT_BOOL,
2322 .off1 = td_var_offset(unlink),
2323 .help = "Unlink created files after job has completed",
2324 .def = "0",
2325 },
2326 {
2327 .name = "exitall",
2328 .type = FIO_OPT_STR_SET,
2329 .cb = str_exitall_cb,
2330 .help = "Terminate all jobs when one exits",
2331 },
2332 {
2333 .name = "stonewall",
Jens Axboed3923652011-08-03 12:38:39 +02002334 .alias = "wait_for_previous",
Jens Axboe214e1ec2007-03-15 10:48:13 +01002335 .type = FIO_OPT_STR_SET,
2336 .off1 = td_var_offset(stonewall),
2337 .help = "Insert a hard barrier between this job and previous",
2338 },
2339 {
Jens Axboeb3d62a72007-03-20 14:23:26 +01002340 .name = "new_group",
2341 .type = FIO_OPT_STR_SET,
2342 .off1 = td_var_offset(new_group),
2343 .help = "Mark the start of a new group (for reporting)",
2344 },
2345 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01002346 .name = "thread",
2347 .type = FIO_OPT_STR_SET,
2348 .off1 = td_var_offset(use_thread),
2349 .help = "Use threads instead of forks",
2350 },
2351 {
2352 .name = "write_bw_log",
Jens Axboee3cedca2008-11-19 19:57:52 +01002353 .type = FIO_OPT_STR,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002354 .off1 = td_var_offset(write_bw_log),
Jens Axboee3cedca2008-11-19 19:57:52 +01002355 .cb = str_write_bw_log_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002356 .help = "Write log of bandwidth during run",
2357 },
2358 {
2359 .name = "write_lat_log",
Jens Axboee3cedca2008-11-19 19:57:52 +01002360 .type = FIO_OPT_STR,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002361 .off1 = td_var_offset(write_lat_log),
Jens Axboee3cedca2008-11-19 19:57:52 +01002362 .cb = str_write_lat_log_cb,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002363 .help = "Write log of latency during run",
2364 },
2365 {
Jens Axboec8eeb9d2011-10-05 14:02:22 +02002366 .name = "write_iops_log",
2367 .type = FIO_OPT_STR,
2368 .off1 = td_var_offset(write_iops_log),
2369 .cb = str_write_iops_log_cb,
2370 .help = "Write log of IOPS during run",
2371 },
2372 {
Jens Axboeb8bc8cb2011-12-01 09:04:31 +01002373 .name = "log_avg_msec",
2374 .type = FIO_OPT_INT,
2375 .off1 = td_var_offset(log_avg_msec),
2376 .help = "Average bw/iops/lat logs over this period of time",
2377 .def = "0",
2378 },
2379 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01002380 .name = "hugepage-size",
Jens Axboee01b22b2009-06-09 15:43:25 +02002381 .type = FIO_OPT_INT,
Jens Axboe214e1ec2007-03-15 10:48:13 +01002382 .off1 = td_var_offset(hugepage_size),
2383 .help = "When using hugepages, specify size of each page",
Jens Axboe81179ee2011-10-04 12:42:06 +02002384 .def = __fio_stringify(FIO_HUGE_PAGE),
Jens Axboe214e1ec2007-03-15 10:48:13 +01002385 },
2386 {
2387 .name = "group_reporting",
2388 .type = FIO_OPT_STR_SET,
2389 .off1 = td_var_offset(group_reporting),
2390 .help = "Do reporting on a per-group basis",
2391 },
2392 {
Jens Axboee9459e52007-04-17 15:46:32 +02002393 .name = "zero_buffers",
2394 .type = FIO_OPT_STR_SET,
2395 .off1 = td_var_offset(zero_buffers),
2396 .help = "Init IO buffers to all zeroes",
2397 },
Jens Axboe5973caf2008-05-21 19:52:35 +02002398 {
2399 .name = "refill_buffers",
2400 .type = FIO_OPT_STR_SET,
2401 .off1 = td_var_offset(refill_buffers),
2402 .help = "Refill IO buffers on every IO submit",
2403 },
Yu-ju Hong83349192011-08-13 00:53:44 +02002404 {
Jens Axboefd684182011-09-19 09:24:44 +02002405 .name = "scramble_buffers",
2406 .type = FIO_OPT_BOOL,
2407 .off1 = td_var_offset(scramble_buffers),
2408 .help = "Slightly scramble buffers on every IO submit",
2409 .def = "1",
2410 },
2411 {
Jens Axboe9c426842012-03-02 21:02:12 +01002412 .name = "buffer_compress_percentage",
2413 .type = FIO_OPT_INT,
2414 .off1 = td_var_offset(compress_percentage),
2415 .maxval = 100,
2416 .minval = 1,
2417 .help = "How compressible the buffer is (approximately)",
2418 },
2419 {
Jens Axboef97a43a2012-03-09 19:06:24 +01002420 .name = "buffer_compress_chunk",
2421 .type = FIO_OPT_INT,
2422 .off1 = td_var_offset(compress_chunk),
Jens Axboe207b18e2012-03-09 19:11:25 +01002423 .parent = "buffer_compress_percentage",
Jens Axboef97a43a2012-03-09 19:06:24 +01002424 .help = "Size of compressible region in buffer",
2425 },
2426 {
Yu-ju Hong83349192011-08-13 00:53:44 +02002427 .name = "clat_percentiles",
2428 .type = FIO_OPT_BOOL,
2429 .off1 = td_var_offset(clat_percentiles),
2430 .help = "Enable the reporting of completion latency percentiles",
Jens Axboe467b35e2011-10-13 08:53:24 +02002431 .def = "1",
Yu-ju Hong83349192011-08-13 00:53:44 +02002432 },
2433 {
2434 .name = "percentile_list",
2435 .type = FIO_OPT_FLOAT_LIST,
2436 .off1 = td_var_offset(percentile_list),
Vincent Kang Fu435d1952013-02-06 08:43:40 +01002437 .off2 = td_var_offset(percentile_precision),
Yu-ju Hong83349192011-08-13 00:53:44 +02002438 .help = "Specify a custom list of percentiles to report",
Vincent Kang Fufd112d32013-02-02 09:28:55 +01002439 .def = "1:5:10:20:30:40:50:60:70:80:90:95:99:99.5:99.9:99.95:99.99",
Yu-ju Hong83349192011-08-13 00:53:44 +02002440 .maxlen = FIO_IO_U_LIST_MAX_LEN,
2441 .minfp = 0.0,
2442 .maxfp = 100.0,
2443 },
2444
Jens Axboe0a839f32007-04-26 09:02:34 +02002445#ifdef FIO_HAVE_DISK_UTIL
2446 {
2447 .name = "disk_util",
2448 .type = FIO_OPT_BOOL,
2449 .off1 = td_var_offset(do_disk_util),
Jens Axboef66ab3c2008-06-05 11:48:22 +02002450 .help = "Log disk utilization statistics",
Jens Axboe0a839f32007-04-26 09:02:34 +02002451 .def = "1",
2452 },
2453#endif
Jens Axboee9459e52007-04-17 15:46:32 +02002454 {
Jens Axboe993bf482008-11-14 13:04:53 +01002455 .name = "gtod_reduce",
2456 .type = FIO_OPT_BOOL,
2457 .help = "Greatly reduce number of gettimeofday() calls",
2458 .cb = str_gtod_reduce_cb,
2459 .def = "0",
2460 },
2461 {
Jens Axboe02af0982010-06-24 09:59:34 +02002462 .name = "disable_lat",
2463 .type = FIO_OPT_BOOL,
2464 .off1 = td_var_offset(disable_lat),
2465 .help = "Disable latency numbers",
2466 .parent = "gtod_reduce",
2467 .def = "0",
2468 },
2469 {
Jens Axboe9520ebb2008-10-16 21:03:27 +02002470 .name = "disable_clat",
2471 .type = FIO_OPT_BOOL,
2472 .off1 = td_var_offset(disable_clat),
2473 .help = "Disable completion latency numbers",
Jens Axboe993bf482008-11-14 13:04:53 +01002474 .parent = "gtod_reduce",
Jens Axboe9520ebb2008-10-16 21:03:27 +02002475 .def = "0",
2476 },
2477 {
2478 .name = "disable_slat",
2479 .type = FIO_OPT_BOOL,
2480 .off1 = td_var_offset(disable_slat),
Bruce Cran03e20d62011-01-02 20:14:54 +01002481 .help = "Disable submission latency numbers",
Jens Axboe993bf482008-11-14 13:04:53 +01002482 .parent = "gtod_reduce",
Jens Axboe9520ebb2008-10-16 21:03:27 +02002483 .def = "0",
2484 },
2485 {
2486 .name = "disable_bw_measurement",
2487 .type = FIO_OPT_BOOL,
2488 .off1 = td_var_offset(disable_bw),
2489 .help = "Disable bandwidth logging",
Jens Axboe993bf482008-11-14 13:04:53 +01002490 .parent = "gtod_reduce",
Jens Axboe9520ebb2008-10-16 21:03:27 +02002491 .def = "0",
2492 },
2493 {
Jens Axboebe4ecfd2008-12-08 14:10:52 +01002494 .name = "gtod_cpu",
2495 .type = FIO_OPT_INT,
2496 .cb = str_gtod_cpu_cb,
Bruce Cran03e20d62011-01-02 20:14:54 +01002497 .help = "Set up dedicated gettimeofday() thread on this CPU",
Jens Axboe29d43ff2009-07-01 10:42:18 +02002498 .verify = gtod_cpu_verify,
Jens Axboebe4ecfd2008-12-08 14:10:52 +01002499 },
2500 {
Jens Axboe771e58b2013-01-30 12:56:23 +01002501 .name = "unified_rw_reporting",
2502 .type = FIO_OPT_BOOL,
2503 .off1 = td_var_offset(unified_rw_rep),
2504 .help = "Unify reporting across data direction",
2505 .def = "0",
2506 },
2507 {
Radha Ramachandranf2bba182009-06-15 08:40:16 +02002508 .name = "continue_on_error",
Steven Lang06842022011-11-17 09:45:17 +01002509 .type = FIO_OPT_STR,
Radha Ramachandranf2bba182009-06-15 08:40:16 +02002510 .off1 = td_var_offset(continue_on_error),
Bruce Cran03e20d62011-01-02 20:14:54 +01002511 .help = "Continue on non-fatal errors during IO",
Steven Lang06842022011-11-17 09:45:17 +01002512 .def = "none",
2513 .posval = {
2514 { .ival = "none",
2515 .oval = ERROR_TYPE_NONE,
2516 .help = "Exit when an error is encountered",
2517 },
2518 { .ival = "read",
2519 .oval = ERROR_TYPE_READ,
2520 .help = "Continue on read errors only",
2521 },
2522 { .ival = "write",
2523 .oval = ERROR_TYPE_WRITE,
2524 .help = "Continue on write errors only",
2525 },
2526 { .ival = "io",
2527 .oval = ERROR_TYPE_READ | ERROR_TYPE_WRITE,
2528 .help = "Continue on any IO errors",
2529 },
2530 { .ival = "verify",
2531 .oval = ERROR_TYPE_VERIFY,
2532 .help = "Continue on verify errors only",
2533 },
2534 { .ival = "all",
2535 .oval = ERROR_TYPE_ANY,
2536 .help = "Continue on all io and verify errors",
2537 },
2538 { .ival = "0",
2539 .oval = ERROR_TYPE_NONE,
2540 .help = "Alias for 'none'",
2541 },
2542 { .ival = "1",
2543 .oval = ERROR_TYPE_ANY,
2544 .help = "Alias for 'all'",
2545 },
2546 },
Radha Ramachandranf2bba182009-06-15 08:40:16 +02002547 },
2548 {
Dmitry Monakhov8b28bd42012-09-23 15:46:09 +04002549 .name = "ignore_error",
2550 .type = FIO_OPT_STR,
2551 .cb = str_ignore_error_cb,
2552 .help = "Set a specific list of errors to ignore",
2553 .parent = "rw",
2554 },
2555 {
2556 .name = "error_dump",
2557 .type = FIO_OPT_BOOL,
2558 .off1 = td_var_offset(error_dump),
2559 .def = "0",
2560 .help = "Dump info on each error",
2561 },
2562
2563 {
Jens Axboe9ac8a792009-11-13 21:23:07 +01002564 .name = "profile",
Jens Axboe79d16312010-03-04 12:43:20 +01002565 .type = FIO_OPT_STR_STORE,
Jens Axboe9ac8a792009-11-13 21:23:07 +01002566 .off1 = td_var_offset(profile),
Jens Axboe9ac8a792009-11-13 21:23:07 +01002567 .help = "Select a specific builtin performance test",
2568 },
2569 {
Jens Axboea696fa22009-12-04 10:05:02 +01002570 .name = "cgroup",
2571 .type = FIO_OPT_STR_STORE,
2572 .off1 = td_var_offset(cgroup),
2573 .help = "Add job to cgroup of this name",
2574 },
2575 {
2576 .name = "cgroup_weight",
2577 .type = FIO_OPT_INT,
2578 .off1 = td_var_offset(cgroup_weight),
2579 .help = "Use given weight for cgroup",
2580 .minval = 100,
2581 .maxval = 1000,
Jens Axboea696fa22009-12-04 10:05:02 +01002582 },
2583 {
Vivek Goyal7de87092010-03-31 22:55:15 +02002584 .name = "cgroup_nodelete",
2585 .type = FIO_OPT_BOOL,
2586 .off1 = td_var_offset(cgroup_nodelete),
2587 .help = "Do not delete cgroups after job completion",
2588 .def = "0",
2589 },
2590 {
Jens Axboee0b0d892009-12-08 10:10:14 +01002591 .name = "uid",
2592 .type = FIO_OPT_INT,
2593 .off1 = td_var_offset(uid),
2594 .help = "Run job with this user ID",
2595 },
2596 {
2597 .name = "gid",
2598 .type = FIO_OPT_INT,
2599 .off1 = td_var_offset(gid),
2600 .help = "Run job with this group ID",
2601 },
2602 {
Dan Ehrenberg9e684a42012-02-20 11:05:14 +01002603 .name = "flow_id",
2604 .type = FIO_OPT_INT,
2605 .off1 = td_var_offset(flow_id),
2606 .help = "The flow index ID to use",
2607 .def = "0",
2608 },
2609 {
2610 .name = "flow",
2611 .type = FIO_OPT_INT,
2612 .off1 = td_var_offset(flow),
2613 .help = "Weight for flow control of this job",
2614 .parent = "flow_id",
2615 .def = "0",
2616 },
2617 {
2618 .name = "flow_watermark",
2619 .type = FIO_OPT_INT,
2620 .off1 = td_var_offset(flow_watermark),
2621 .help = "High watermark for flow control. This option"
2622 " should be set to the same value for all threads"
2623 " with non-zero flow.",
2624 .parent = "flow_id",
2625 .def = "1024",
2626 },
2627 {
2628 .name = "flow_sleep",
2629 .type = FIO_OPT_INT,
2630 .off1 = td_var_offset(flow_sleep),
2631 .help = "How many microseconds to sleep after being held"
2632 " back by the flow control mechanism",
2633 .parent = "flow_id",
2634 .def = "0",
2635 },
2636 {
Jens Axboe214e1ec2007-03-15 10:48:13 +01002637 .name = NULL,
2638 },
2639};
2640
Jens Axboe17af15d2010-04-13 10:38:16 +02002641static void add_to_lopt(struct option *lopt, struct fio_option *o,
Steven Langde890a12011-11-09 14:03:34 +01002642 const char *name, int val)
Jens Axboe9f817362010-03-04 14:38:10 +01002643{
Jens Axboe17af15d2010-04-13 10:38:16 +02002644 lopt->name = (char *) name;
Steven Langde890a12011-11-09 14:03:34 +01002645 lopt->val = val;
Jens Axboe9f817362010-03-04 14:38:10 +01002646 if (o->type == FIO_OPT_STR_SET)
2647 lopt->has_arg = no_argument;
2648 else
2649 lopt->has_arg = required_argument;
2650}
2651
Steven Langde890a12011-11-09 14:03:34 +01002652static void options_to_lopts(struct fio_option *opts,
2653 struct option *long_options,
2654 int i, int option_type)
2655{
2656 struct fio_option *o = &opts[0];
2657 while (o->name) {
2658 add_to_lopt(&long_options[i], o, o->name, option_type);
2659 if (o->alias) {
2660 i++;
2661 add_to_lopt(&long_options[i], o, o->alias, option_type);
2662 }
2663
2664 i++;
2665 o++;
2666 assert(i < FIO_NR_OPTIONS);
2667 }
2668}
2669
2670void fio_options_set_ioengine_opts(struct option *long_options,
2671 struct thread_data *td)
2672{
2673 unsigned int i;
2674
2675 i = 0;
2676 while (long_options[i].name) {
2677 if (long_options[i].val == FIO_GETOPT_IOENGINE) {
2678 memset(&long_options[i], 0, sizeof(*long_options));
2679 break;
2680 }
2681 i++;
2682 }
2683
2684 /*
2685 * Just clear out the prior ioengine options.
2686 */
2687 if (!td || !td->eo)
2688 return;
2689
2690 options_to_lopts(td->io_ops->options, long_options, i,
2691 FIO_GETOPT_IOENGINE);
2692}
2693
Jens Axboe214e1ec2007-03-15 10:48:13 +01002694void fio_options_dup_and_init(struct option *long_options)
2695{
Jens Axboe214e1ec2007-03-15 10:48:13 +01002696 unsigned int i;
2697
2698 options_init(options);
2699
2700 i = 0;
2701 while (long_options[i].name)
2702 i++;
2703
Steven Langde890a12011-11-09 14:03:34 +01002704 options_to_lopts(options, long_options, i, FIO_GETOPT_JOB);
Jens Axboe214e1ec2007-03-15 10:48:13 +01002705}
2706
Jens Axboe74929ac2009-08-05 11:42:37 +02002707struct fio_keyword {
2708 const char *word;
2709 const char *desc;
2710 char *replace;
2711};
2712
2713static struct fio_keyword fio_keywords[] = {
2714 {
2715 .word = "$pagesize",
2716 .desc = "Page size in the system",
2717 },
2718 {
2719 .word = "$mb_memory",
2720 .desc = "Megabytes of memory online",
2721 },
2722 {
2723 .word = "$ncpus",
2724 .desc = "Number of CPUs online in the system",
2725 },
2726 {
2727 .word = NULL,
2728 },
2729};
2730
2731void fio_keywords_init(void)
2732{
Jens Axboe3b2e1462009-12-15 08:58:10 +01002733 unsigned long long mb_memory;
Jens Axboe74929ac2009-08-05 11:42:37 +02002734 char buf[128];
2735 long l;
2736
Jens Axboea4cfc472012-10-09 10:30:48 -06002737 sprintf(buf, "%lu", (unsigned long) page_size);
Jens Axboe74929ac2009-08-05 11:42:37 +02002738 fio_keywords[0].replace = strdup(buf);
2739
Jens Axboe8eb016d2011-07-11 10:24:20 +02002740 mb_memory = os_phys_mem() / (1024 * 1024);
Jens Axboe3b2e1462009-12-15 08:58:10 +01002741 sprintf(buf, "%llu", mb_memory);
Jens Axboe74929ac2009-08-05 11:42:37 +02002742 fio_keywords[1].replace = strdup(buf);
2743
Jens Axboec00a2282011-07-08 20:56:06 +02002744 l = cpus_online();
Jens Axboe74929ac2009-08-05 11:42:37 +02002745 sprintf(buf, "%lu", l);
2746 fio_keywords[2].replace = strdup(buf);
2747}
2748
Jens Axboe892a6ff2009-11-13 12:19:49 +01002749#define BC_APP "bc"
2750
2751static char *bc_calc(char *str)
2752{
Steven Langd0c814e2011-10-28 08:37:13 +02002753 char buf[128], *tmp;
Jens Axboe892a6ff2009-11-13 12:19:49 +01002754 FILE *f;
2755 int ret;
2756
2757 /*
2758 * No math, just return string
2759 */
Steven Langd0c814e2011-10-28 08:37:13 +02002760 if ((!strchr(str, '+') && !strchr(str, '-') && !strchr(str, '*') &&
2761 !strchr(str, '/')) || strchr(str, '\''))
Jens Axboe892a6ff2009-11-13 12:19:49 +01002762 return str;
2763
2764 /*
2765 * Split option from value, we only need to calculate the value
2766 */
2767 tmp = strchr(str, '=');
2768 if (!tmp)
2769 return str;
2770
2771 tmp++;
Jens Axboe892a6ff2009-11-13 12:19:49 +01002772
Steven Langd0c814e2011-10-28 08:37:13 +02002773 /*
2774 * Prevent buffer overflows; such a case isn't reasonable anyway
2775 */
2776 if (strlen(str) >= 128 || strlen(tmp) > 100)
2777 return str;
Jens Axboe892a6ff2009-11-13 12:19:49 +01002778
2779 sprintf(buf, "which %s > /dev/null", BC_APP);
2780 if (system(buf)) {
2781 log_err("fio: bc is needed for performing math\n");
Jens Axboe892a6ff2009-11-13 12:19:49 +01002782 return NULL;
2783 }
2784
Steven Langd0c814e2011-10-28 08:37:13 +02002785 sprintf(buf, "echo '%s' | %s", tmp, BC_APP);
Jens Axboe892a6ff2009-11-13 12:19:49 +01002786 f = popen(buf, "r");
2787 if (!f) {
Jens Axboe892a6ff2009-11-13 12:19:49 +01002788 return NULL;
2789 }
2790
Steven Langd0c814e2011-10-28 08:37:13 +02002791 ret = fread(&buf[tmp - str], 1, 128 - (tmp - str), f);
Jens Axboe892a6ff2009-11-13 12:19:49 +01002792 if (ret <= 0) {
Jens Axboe892a6ff2009-11-13 12:19:49 +01002793 return NULL;
2794 }
2795
Jens Axboe892a6ff2009-11-13 12:19:49 +01002796 pclose(f);
Steven Langd0c814e2011-10-28 08:37:13 +02002797 buf[(tmp - str) + ret - 1] = '\0';
2798 memcpy(buf, str, tmp - str);
Jens Axboe892a6ff2009-11-13 12:19:49 +01002799 free(str);
Steven Langd0c814e2011-10-28 08:37:13 +02002800 return strdup(buf);
2801}
2802
2803/*
2804 * Return a copy of the input string with substrings of the form ${VARNAME}
2805 * substituted with the value of the environment variable VARNAME. The
2806 * substitution always occurs, even if VARNAME is empty or the corresponding
2807 * environment variable undefined.
2808 */
2809static char *option_dup_subs(const char *opt)
2810{
2811 char out[OPT_LEN_MAX+1];
2812 char in[OPT_LEN_MAX+1];
2813 char *outptr = out;
2814 char *inptr = in;
2815 char *ch1, *ch2, *env;
2816 ssize_t nchr = OPT_LEN_MAX;
2817 size_t envlen;
2818
2819 if (strlen(opt) + 1 > OPT_LEN_MAX) {
2820 log_err("OPT_LEN_MAX (%d) is too small\n", OPT_LEN_MAX);
2821 return NULL;
2822 }
2823
2824 in[OPT_LEN_MAX] = '\0';
2825 strncpy(in, opt, OPT_LEN_MAX);
2826
2827 while (*inptr && nchr > 0) {
2828 if (inptr[0] == '$' && inptr[1] == '{') {
2829 ch2 = strchr(inptr, '}');
2830 if (ch2 && inptr+1 < ch2) {
2831 ch1 = inptr+2;
2832 inptr = ch2+1;
2833 *ch2 = '\0';
2834
2835 env = getenv(ch1);
2836 if (env) {
2837 envlen = strlen(env);
2838 if (envlen <= nchr) {
2839 memcpy(outptr, env, envlen);
2840 outptr += envlen;
2841 nchr -= envlen;
2842 }
2843 }
2844
2845 continue;
2846 }
2847 }
2848
2849 *outptr++ = *inptr++;
2850 --nchr;
2851 }
2852
2853 *outptr = '\0';
2854 return strdup(out);
Jens Axboe892a6ff2009-11-13 12:19:49 +01002855}
2856
Jens Axboe74929ac2009-08-05 11:42:37 +02002857/*
2858 * Look for reserved variable names and replace them with real values
2859 */
2860static char *fio_keyword_replace(char *opt)
2861{
2862 char *s;
2863 int i;
Steven Langd0c814e2011-10-28 08:37:13 +02002864 int docalc = 0;
Jens Axboe74929ac2009-08-05 11:42:37 +02002865
2866 for (i = 0; fio_keywords[i].word != NULL; i++) {
2867 struct fio_keyword *kw = &fio_keywords[i];
2868
2869 while ((s = strstr(opt, kw->word)) != NULL) {
2870 char *new = malloc(strlen(opt) + 1);
2871 char *o_org = opt;
2872 int olen = s - opt;
2873 int len;
2874
2875 /*
2876 * Copy part of the string before the keyword and
2877 * sprintf() the replacement after it.
2878 */
2879 memcpy(new, opt, olen);
2880 len = sprintf(new + olen, "%s", kw->replace);
2881
2882 /*
2883 * If there's more in the original string, copy that
2884 * in too
2885 */
2886 opt += strlen(kw->word) + olen;
2887 if (strlen(opt))
2888 memcpy(new + olen + len, opt, opt - o_org - 1);
2889
2890 /*
2891 * replace opt and free the old opt
2892 */
2893 opt = new;
Steven Langd0c814e2011-10-28 08:37:13 +02002894 free(o_org);
Jens Axboe7a958bd2009-11-13 12:33:54 +01002895
Steven Langd0c814e2011-10-28 08:37:13 +02002896 docalc = 1;
Jens Axboe74929ac2009-08-05 11:42:37 +02002897 }
2898 }
2899
Steven Langd0c814e2011-10-28 08:37:13 +02002900 /*
2901 * Check for potential math and invoke bc, if possible
2902 */
2903 if (docalc)
2904 opt = bc_calc(opt);
2905
Jens Axboe7a958bd2009-11-13 12:33:54 +01002906 return opt;
Jens Axboe74929ac2009-08-05 11:42:37 +02002907}
2908
Steven Langd0c814e2011-10-28 08:37:13 +02002909static char **dup_and_sub_options(char **opts, int num_opts)
2910{
2911 int i;
2912 char **opts_copy = malloc(num_opts * sizeof(*opts));
2913 for (i = 0; i < num_opts; i++) {
2914 opts_copy[i] = option_dup_subs(opts[i]);
2915 if (!opts_copy[i])
2916 continue;
2917 opts_copy[i] = fio_keyword_replace(opts_copy[i]);
2918 }
2919 return opts_copy;
2920}
2921
Jens Axboe3b8b7132008-06-10 19:46:23 +02002922int fio_options_parse(struct thread_data *td, char **opts, int num_opts)
Jens Axboe214e1ec2007-03-15 10:48:13 +01002923{
Steven Langde890a12011-11-09 14:03:34 +01002924 int i, ret, unknown;
Steven Langd0c814e2011-10-28 08:37:13 +02002925 char **opts_copy;
Jens Axboe3b8b7132008-06-10 19:46:23 +02002926
2927 sort_options(opts, options, num_opts);
Steven Langd0c814e2011-10-28 08:37:13 +02002928 opts_copy = dup_and_sub_options(opts, num_opts);
Jens Axboe3b8b7132008-06-10 19:46:23 +02002929
Steven Langde890a12011-11-09 14:03:34 +01002930 for (ret = 0, i = 0, unknown = 0; i < num_opts; i++) {
2931 struct fio_option *o;
2932 int newret = parse_option(opts_copy[i], opts[i], options, &o,
2933 td);
Steven Langd0c814e2011-10-28 08:37:13 +02002934
Steven Langde890a12011-11-09 14:03:34 +01002935 if (opts_copy[i]) {
2936 if (newret && !o) {
2937 unknown++;
2938 continue;
2939 }
Steven Langd0c814e2011-10-28 08:37:13 +02002940 free(opts_copy[i]);
Steven Langde890a12011-11-09 14:03:34 +01002941 opts_copy[i] = NULL;
2942 }
2943
2944 ret |= newret;
2945 }
2946
2947 if (unknown) {
2948 ret |= ioengine_load(td);
2949 if (td->eo) {
2950 sort_options(opts_copy, td->io_ops->options, num_opts);
2951 opts = opts_copy;
2952 }
2953 for (i = 0; i < num_opts; i++) {
2954 struct fio_option *o = NULL;
2955 int newret = 1;
2956 if (!opts_copy[i])
2957 continue;
2958
2959 if (td->eo)
2960 newret = parse_option(opts_copy[i], opts[i],
2961 td->io_ops->options, &o,
2962 td->eo);
2963
2964 ret |= newret;
2965 if (!o)
2966 log_err("Bad option <%s>\n", opts[i]);
2967
2968 free(opts_copy[i]);
2969 opts_copy[i] = NULL;
2970 }
Jens Axboe74929ac2009-08-05 11:42:37 +02002971 }
Jens Axboe3b8b7132008-06-10 19:46:23 +02002972
Steven Langd0c814e2011-10-28 08:37:13 +02002973 free(opts_copy);
Jens Axboe3b8b7132008-06-10 19:46:23 +02002974 return ret;
Jens Axboe214e1ec2007-03-15 10:48:13 +01002975}
2976
2977int fio_cmd_option_parse(struct thread_data *td, const char *opt, char *val)
2978{
Jens Axboe07b32322010-03-05 09:48:44 +01002979 return parse_cmd_option(opt, val, options, td);
Jens Axboe214e1ec2007-03-15 10:48:13 +01002980}
2981
Steven Langde890a12011-11-09 14:03:34 +01002982int fio_cmd_ioengine_option_parse(struct thread_data *td, const char *opt,
2983 char *val)
2984{
2985 return parse_cmd_option(opt, val, td->io_ops->options, td);
2986}
2987
Jens Axboe214e1ec2007-03-15 10:48:13 +01002988void fio_fill_default_options(struct thread_data *td)
2989{
2990 fill_default_options(td, options);
2991}
2992
2993int fio_show_option_help(const char *opt)
2994{
Jens Axboe07b32322010-03-05 09:48:44 +01002995 return show_cmd_help(options, opt);
Jens Axboe214e1ec2007-03-15 10:48:13 +01002996}
Jens Axboed23bb322007-03-23 15:57:56 +01002997
Steven Langde890a12011-11-09 14:03:34 +01002998void options_mem_dupe(void *data, struct fio_option *options)
2999{
3000 struct fio_option *o;
3001 char **ptr;
3002
3003 for (o = &options[0]; o->name; o++) {
3004 if (o->type != FIO_OPT_STR_STORE)
3005 continue;
3006
3007 ptr = td_var(data, o->off1);
3008 if (*ptr)
3009 *ptr = strdup(*ptr);
3010 }
3011}
3012
Jens Axboe7e356b22011-10-14 10:55:16 +02003013/*
3014 * dupe FIO_OPT_STR_STORE options
3015 */
Steven Langde890a12011-11-09 14:03:34 +01003016void fio_options_mem_dupe(struct thread_data *td)
Jens Axboed23bb322007-03-23 15:57:56 +01003017{
Steven Langde890a12011-11-09 14:03:34 +01003018 options_mem_dupe(&td->o, options);
Jens Axboe1647f592011-11-09 20:25:21 +01003019
3020 if (td->eo && td->io_ops) {
Steven Langde890a12011-11-09 14:03:34 +01003021 void *oldeo = td->eo;
Jens Axboe1647f592011-11-09 20:25:21 +01003022
Steven Langde890a12011-11-09 14:03:34 +01003023 td->eo = malloc(td->io_ops->option_struct_size);
3024 memcpy(td->eo, oldeo, td->io_ops->option_struct_size);
3025 options_mem_dupe(td->eo, td->io_ops->options);
Jens Axboed23bb322007-03-23 15:57:56 +01003026 }
3027}
3028
Jens Axboed6978a32009-07-18 21:04:09 +02003029unsigned int fio_get_kb_base(void *data)
3030{
3031 struct thread_data *td = data;
3032 unsigned int kb_base = 0;
3033
3034 if (td)
3035 kb_base = td->o.kb_base;
3036 if (!kb_base)
3037 kb_base = 1024;
3038
3039 return kb_base;
3040}
Jens Axboe9f988e22010-03-04 10:42:38 +01003041
Jens Axboe07b32322010-03-05 09:48:44 +01003042int add_option(struct fio_option *o)
Jens Axboe9f988e22010-03-04 10:42:38 +01003043{
Jens Axboe07b32322010-03-05 09:48:44 +01003044 struct fio_option *__o;
3045 int opt_index = 0;
3046
3047 __o = options;
3048 while (__o->name) {
3049 opt_index++;
3050 __o++;
3051 }
3052
3053 memcpy(&options[opt_index], o, sizeof(*o));
3054 return 0;
Jens Axboe9f988e22010-03-04 10:42:38 +01003055}
Jens Axboee2de69d2010-03-04 14:05:48 +01003056
Jens Axboe07b32322010-03-05 09:48:44 +01003057void invalidate_profile_options(const char *prof_name)
Jens Axboee2de69d2010-03-04 14:05:48 +01003058{
Jens Axboe07b32322010-03-05 09:48:44 +01003059 struct fio_option *o;
Jens Axboee2de69d2010-03-04 14:05:48 +01003060
Jens Axboe07b32322010-03-05 09:48:44 +01003061 o = options;
3062 while (o->name) {
3063 if (o->prof_name && !strcmp(o->prof_name, prof_name)) {
3064 o->type = FIO_OPT_INVALID;
3065 o->prof_name = NULL;
3066 }
3067 o++;
Jens Axboee2de69d2010-03-04 14:05:48 +01003068 }
3069}
Jens Axboef5b6bb82010-03-05 10:09:59 +01003070
3071void add_opt_posval(const char *optname, const char *ival, const char *help)
3072{
3073 struct fio_option *o;
3074 unsigned int i;
3075
3076 o = find_option(options, optname);
3077 if (!o)
3078 return;
3079
3080 for (i = 0; i < PARSE_MAX_VP; i++) {
3081 if (o->posval[i].ival)
3082 continue;
3083
3084 o->posval[i].ival = ival;
3085 o->posval[i].help = help;
3086 break;
3087 }
3088}
3089
3090void del_opt_posval(const char *optname, const char *ival)
3091{
3092 struct fio_option *o;
3093 unsigned int i;
3094
3095 o = find_option(options, optname);
3096 if (!o)
3097 return;
3098
3099 for (i = 0; i < PARSE_MAX_VP; i++) {
3100 if (!o->posval[i].ival)
3101 continue;
3102 if (strcmp(o->posval[i].ival, ival))
3103 continue;
3104
3105 o->posval[i].ival = NULL;
3106 o->posval[i].help = NULL;
3107 }
3108}
Jens Axboe7e356b22011-10-14 10:55:16 +02003109
3110void fio_options_free(struct thread_data *td)
3111{
3112 options_free(options, td);
Steven Langde890a12011-11-09 14:03:34 +01003113 if (td->eo && td->io_ops && td->io_ops->options) {
3114 options_free(td->io_ops->options, td->eo);
3115 free(td->eo);
3116 td->eo = NULL;
3117 }
Jens Axboe7e356b22011-10-14 10:55:16 +02003118}