init.c revision 5921e80c5dfc9f96d2f21da6ae58f2b5d3a0b373 
1/*
2 * This file contains job initialization and setup functions.
3 */
4#include <stdio.h>
5#include <stdlib.h>
6#include <unistd.h>
7#include <fcntl.h>
8#include <ctype.h>
9#include <string.h>
10#include <errno.h>
11#include <getopt.h>
12#include <sys/ipc.h>
13#include <sys/shm.h>
14#include <sys/types.h>
15#include <sys/stat.h>
16
17#include "fio.h"
18#include "parse.h"
19#include "smalloc.h"
20#include "filehash.h"
21
22static char fio_version_string[] = "fio 1.21-rc3";
23
24#define FIO_RANDSEED		(0xb1899bedUL)
25
26static char **ini_file;
27static int max_jobs = MAX_JOBS;
28static int dump_cmdline;
29
30struct thread_data def_thread;
31struct thread_data *threads = NULL;
32
33int exitall_on_terminate = 0;
34int terse_output = 0;
35int eta_print;
36unsigned long long mlock_size = 0;
37FILE *f_out = NULL;
38FILE *f_err = NULL;
39char *job_section = NULL;
40
41int write_bw_log = 0;
42int read_only = 0;
43
44static int def_timeout;
45static int write_lat_log;
46
47static int prev_group_jobs;
48
49unsigned long fio_debug = 0;
50unsigned int fio_debug_jobno = -1;
51unsigned int *fio_debug_jobp = NULL;
52
53/*
54 * Command line options. These will contain the above, plus a few
55 * extra that only pertain to fio itself and not jobs.
56 */
57static struct option l_opts[FIO_NR_OPTIONS] = {
58	{
59		.name		= "output",
60		.has_arg	= required_argument,
61		.val		= 'o',
62	},
63	{
64		.name		= "timeout",
65		.has_arg	= required_argument,
66		.val		= 't',
67	},
68	{
69		.name		= "latency-log",
70		.has_arg	= required_argument,
71		.val		= 'l',
72	},
73	{
74		.name		= "bandwidth-log",
75		.has_arg	= required_argument,
76		.val		= 'b',
77	},
78	{
79		.name		= "minimal",
80		.has_arg	= optional_argument,
81		.val		= 'm',
82	},
83	{
84		.name		= "version",
85		.has_arg	= no_argument,
86		.val		= 'v',
87	},
88	{
89		.name		= "help",
90		.has_arg	= no_argument,
91		.val		= 'h',
92	},
93	{
94		.name		= "cmdhelp",
95		.has_arg	= optional_argument,
96		.val		= 'c',
97	},
98	{
99		.name		= "showcmd",
100		.has_arg	= no_argument,
101		.val		= 's',
102	},
103	{
104		.name		= "readonly",
105		.has_arg	= no_argument,
106		.val		= 'r',
107	},
108	{
109		.name		= "eta",
110		.has_arg	= required_argument,
111		.val		= 'e',
112	},
113	{
114		.name		= "debug",
115		.has_arg	= required_argument,
116		.val		= 'd',
117	},
118	{
119		.name		= "section",
120		.has_arg	= required_argument,
121		.val		= 'x',
122	},
123	{
124		.name		= "alloc-size",
125		.has_arg	= required_argument,
126		.val		= 'a',
127	},
128	{
129		.name		= NULL,
130	},
131};
132
133FILE *get_f_out()
134{
135	return f_out;
136}
137
138FILE *get_f_err()
139{
140	return f_err;
141}
142
143/*
144 * Return a free job structure.
145 */
146static struct thread_data *get_new_job(int global, struct thread_data *parent)
147{
148	struct thread_data *td;
149
150	if (global)
151		return &def_thread;
152	if (thread_number >= max_jobs)
153		return NULL;
154
155	td = &threads[thread_number++];
156	*td = *parent;
157
158	dup_files(td, parent);
159	options_mem_dupe(td);
160
161	td->thread_number = thread_number;
162	return td;
163}
164
165static void put_job(struct thread_data *td)
166{
167	if (td == &def_thread)
168		return;
169
170	if (td->error)
171		log_info("fio: %s\n", td->verror);
172
173	memset(&threads[td->thread_number - 1], 0, sizeof(*td));
174	thread_number--;
175}
176
177static int setup_rate(struct thread_data *td)
178{
179	unsigned long nr_reads_per_msec;
180	unsigned long long rate;
181	unsigned int bs;
182
183	if (!td->o.rate && !td->o.rate_iops)
184		return 0;
185
186	if (td_rw(td))
187		bs = td->o.rw_min_bs;
188	else if (td_read(td))
189		bs = td->o.min_bs[DDIR_READ];
190	else
191		bs = td->o.min_bs[DDIR_WRITE];
192
193	if (td->o.rate) {
194		rate = td->o.rate;
195		nr_reads_per_msec = (rate * 1024 * 1000LL) / bs;
196	} else
197		nr_reads_per_msec = td->o.rate_iops * 1000UL;
198
199	if (!nr_reads_per_msec) {
200		log_err("rate lower than supported\n");
201		return -1;
202	}
203
204	td->rate_usec_cycle = 1000000000ULL / nr_reads_per_msec;
205	td->rate_pending_usleep = 0;
206	return 0;
207}
208
209/*
210 * Lazy way of fixing up options that depend on each other. We could also
211 * define option callback handlers, but this is easier.
212 */
213static int fixup_options(struct thread_data *td)
214{
215	struct thread_options *o = &td->o;
216
217	if (read_only && td_write(td)) {
218		log_err("fio: job <%s> has write bit set, but fio is in"
219			" read-only mode\n", td->o.name);
220		return 1;
221	}
222
223	if (o->write_iolog_file && o->read_iolog_file) {
224		log_err("fio: read iolog overrides write_iolog\n");
225		free(o->write_iolog_file);
226		o->write_iolog_file = NULL;
227	}
228
229	/*
230	 * only really works for sequential io for now, and with 1 file
231	 */
232	if (o->zone_size && td_random(td) && o->open_files == 1)
233		o->zone_size = 0;
234
235	/*
236	 * Reads can do overwrites, we always need to pre-create the file
237	 */
238	if (td_read(td) || td_rw(td))
239		o->overwrite = 1;
240
241	if (!o->min_bs[DDIR_READ])
242		o->min_bs[DDIR_READ] = o->bs[DDIR_READ];
243	if (!o->max_bs[DDIR_READ])
244		o->max_bs[DDIR_READ] = o->bs[DDIR_READ];
245	if (!o->min_bs[DDIR_WRITE])
246		o->min_bs[DDIR_WRITE] = o->bs[DDIR_WRITE];
247	if (!o->max_bs[DDIR_WRITE])
248		o->max_bs[DDIR_WRITE] = o->bs[DDIR_WRITE];
249
250	o->rw_min_bs = min(o->min_bs[DDIR_READ], o->min_bs[DDIR_WRITE]);
251
252	if (!o->file_size_high)
253		o->file_size_high = o->file_size_low;
254
255	if (o->norandommap && o->verify != VERIFY_NONE) {
256		log_err("fio: norandommap given, verify disabled\n");
257		o->verify = VERIFY_NONE;
258	}
259	if (o->bs_unaligned && (o->odirect || td->io_ops->flags & FIO_RAWIO))
260		log_err("fio: bs_unaligned may not work with raw io\n");
261
262	/*
263	 * thinktime_spin must be less than thinktime
264	 */
265	if (o->thinktime_spin > o->thinktime)
266		o->thinktime_spin = o->thinktime;
267
268	/*
269	 * The low water mark cannot be bigger than the iodepth
270	 */
271	if (o->iodepth_low > o->iodepth || !o->iodepth_low) {
272		/*
273		 * syslet work around - if the workload is sequential,
274		 * we want to let the queue drain all the way down to
275		 * avoid seeking between async threads
276		 */
277		if (!strcmp(td->io_ops->name, "syslet-rw") && !td_random(td))
278			o->iodepth_low = 1;
279		else
280			o->iodepth_low = o->iodepth;
281	}
282
283	/*
284	 * If batch number isn't set, default to the same as iodepth
285	 */
286	if (o->iodepth_batch > o->iodepth || !o->iodepth_batch)
287		o->iodepth_batch = o->iodepth;
288
289	if (o->nr_files > td->files_index)
290		o->nr_files = td->files_index;
291
292	if (o->open_files > o->nr_files || !o->open_files)
293		o->open_files = o->nr_files;
294
295	if ((o->rate && o->rate_iops) || (o->ratemin && o->rate_iops_min)) {
296		log_err("fio: rate and rate_iops are mutually exclusive\n");
297		return 1;
298	}
299	if ((o->rate < o->ratemin) || (o->rate_iops < o->rate_iops_min)) {
300		log_err("fio: minimum rate exceeds rate\n");
301		return 1;
302	}
303
304	if (!o->timeout && o->time_based) {
305		log_err("fio: time_based requires a runtime/timeout setting\n");
306		o->time_based = 0;
307	}
308
309	if (o->fill_device && !o->size)
310		o->size = -1ULL;
311
312	if (td_rw(td) && td->o.verify != VERIFY_NONE)
313		log_info("fio: mixed read/write workload with verify. May not "
314		 "work as expected, unless you pre-populated the file\n");
315
316	if (td->o.verify != VERIFY_NONE)
317		td->o.refill_buffers = 1;
318
319	return 0;
320}
321
322/*
323 * This function leaks the buffer
324 */
325static char *to_kmg(unsigned int val)
326{
327	char *buf = malloc(32);
328	char post[] = { 0, 'K', 'M', 'G', 'P', 'E', 0 };
329	char *p = post;
330
331	do {
332		if (val & 1023)
333			break;
334
335		val >>= 10;
336		p++;
337	} while (*p);
338
339	snprintf(buf, 31, "%u%c", val, *p);
340	return buf;
341}
342
343/* External engines are specified by "external:name.o") */
344static const char *get_engine_name(const char *str)
345{
346	char *p = strstr(str, ":");
347
348	if (!p)
349		return str;
350
351	p++;
352	strip_blank_front(&p);
353	strip_blank_end(p);
354	return p;
355}
356
357static int exists_and_not_file(const char *filename)
358{
359	struct stat sb;
360
361	if (lstat(filename, &sb) == -1)
362		return 0;
363
364	if (S_ISREG(sb.st_mode))
365		return 0;
366
367	return 1;
368}
369
370/*
371 * Initialize the various random states we need (random io, block size ranges,
372 * read/write mix, etc).
373 */
374static int init_random_state(struct thread_data *td)
375{
376	unsigned long seeds[6];
377	int fd;
378
379	fd = open("/dev/urandom", O_RDONLY);
380	if (fd == -1) {
381		td_verror(td, errno, "open");
382		return 1;
383	}
384
385	if (read(fd, seeds, sizeof(seeds)) < (int) sizeof(seeds)) {
386		td_verror(td, EIO, "read");
387		close(fd);
388		return 1;
389	}
390
391	close(fd);
392
393	os_random_seed(seeds[0], &td->bsrange_state);
394	os_random_seed(seeds[1], &td->verify_state);
395	os_random_seed(seeds[2], &td->rwmix_state);
396
397	if (td->o.file_service_type == FIO_FSERVICE_RANDOM)
398		os_random_seed(seeds[3], &td->next_file_state);
399
400	os_random_seed(seeds[5], &td->file_size_state);
401
402	if (!td_random(td))
403		return 0;
404
405	if (td->o.rand_repeatable)
406		seeds[4] = FIO_RANDSEED * td->thread_number;
407
408	os_random_seed(seeds[4], &td->random_state);
409	return 0;
410}
411
412/*
413 * Adds a job to the list of things todo. Sanitizes the various options
414 * to make sure we don't have conflicts, and initializes various
415 * members of td.
416 */
417static int add_job(struct thread_data *td, const char *jobname, int job_add_num)
418{
419	const char *ddir_str[] = { NULL, "read", "write", "rw", NULL,
420				   "randread", "randwrite", "randrw" };
421	unsigned int i;
422	const char *engine;
423	char fname[PATH_MAX];
424	int numjobs, file_alloced;
425
426	/*
427	 * the def_thread is just for options, it's not a real job
428	 */
429	if (td == &def_thread)
430		return 0;
431
432	/*
433	 * if we are just dumping the output command line, don't add the job
434	 */
435	if (dump_cmdline) {
436		put_job(td);
437		return 0;
438	}
439
440	engine = get_engine_name(td->o.ioengine);
441	td->io_ops = load_ioengine(td, engine);
442	if (!td->io_ops) {
443		log_err("fio: failed to load engine %s\n", engine);
444		goto err;
445	}
446
447	if (td->o.use_thread)
448		nr_thread++;
449	else
450		nr_process++;
451
452	if (td->o.odirect)
453		td->io_ops->flags |= FIO_RAWIO;
454
455	file_alloced = 0;
456	if (!td->o.filename && !td->files_index && !td->o.read_iolog_file) {
457		file_alloced = 1;
458
459		if (td->o.nr_files == 1 && exists_and_not_file(jobname))
460			add_file(td, jobname);
461		else {
462			for (i = 0; i < td->o.nr_files; i++) {
463				sprintf(fname, "%s.%d.%d", jobname,
464							td->thread_number, i);
465				add_file(td, fname);
466			}
467		}
468	}
469
470	if (fixup_options(td))
471		goto err;
472
473	if (td->io_ops->flags & FIO_DISKLESSIO) {
474		struct fio_file *f;
475
476		for_each_file(td, f, i)
477			f->real_file_size = -1ULL;
478	}
479
480	td->mutex = fio_mutex_init(0);
481
482	td->ts.clat_stat[0].min_val = td->ts.clat_stat[1].min_val = ULONG_MAX;
483	td->ts.slat_stat[0].min_val = td->ts.slat_stat[1].min_val = ULONG_MAX;
484	td->ts.bw_stat[0].min_val = td->ts.bw_stat[1].min_val = ULONG_MAX;
485	td->ddir_nr = td->o.ddir_nr;
486
487	if ((td->o.stonewall || td->o.numjobs > 1 || td->o.new_group)
488	     && prev_group_jobs) {
489		prev_group_jobs = 0;
490		groupid++;
491	}
492
493	td->groupid = groupid;
494	prev_group_jobs++;
495
496	if (init_random_state(td))
497		goto err;
498
499	if (setup_rate(td))
500		goto err;
501
502	if (td->o.write_lat_log) {
503		setup_log(&td->ts.slat_log);
504		setup_log(&td->ts.clat_log);
505	}
506	if (td->o.write_bw_log)
507		setup_log(&td->ts.bw_log);
508
509	if (!td->o.name)
510		td->o.name = strdup(jobname);
511
512	if (!terse_output) {
513		if (!job_add_num) {
514			if (!strcmp(td->io_ops->name, "cpuio")) {
515				log_info("%s: ioengine=cpu, cpuload=%u,"
516					 " cpucycle=%u\n", td->o.name,
517							td->o.cpuload,
518							td->o.cpucycle);
519			} else {
520				char *c1, *c2, *c3, *c4;
521
522				c1 = to_kmg(td->o.min_bs[DDIR_READ]);
523				c2 = to_kmg(td->o.max_bs[DDIR_READ]);
524				c3 = to_kmg(td->o.min_bs[DDIR_WRITE]);
525				c4 = to_kmg(td->o.max_bs[DDIR_WRITE]);
526
527				log_info("%s: (g=%d): rw=%s, bs=%s-%s/%s-%s,"
528					 " ioengine=%s, iodepth=%u\n",
529						td->o.name, td->groupid,
530						ddir_str[td->o.td_ddir],
531						c1, c2, c3, c4,
532						td->io_ops->name,
533						td->o.iodepth);
534
535				free(c1);
536				free(c2);
537				free(c3);
538				free(c4);
539			}
540		} else if (job_add_num == 1)
541			log_info("...\n");
542	}
543
544	/*
545	 * recurse add identical jobs, clear numjobs and stonewall options
546	 * as they don't apply to sub-jobs
547	 */
548	numjobs = td->o.numjobs;
549	while (--numjobs) {
550		struct thread_data *td_new = get_new_job(0, td);
551
552		if (!td_new)
553			goto err;
554
555		td_new->o.numjobs = 1;
556		td_new->o.stonewall = 0;
557		td_new->o.new_group = 0;
558
559		if (file_alloced) {
560			td_new->o.filename = NULL;
561			td_new->files_index = 0;
562			td_new->files = NULL;
563		}
564
565		job_add_num = numjobs - 1;
566
567		if (add_job(td_new, jobname, job_add_num))
568			goto err;
569	}
570
571	return 0;
572err:
573	put_job(td);
574	return -1;
575}
576
577static int skip_this_section(const char *name)
578{
579	if (!job_section)
580		return 0;
581	if (!strncmp(name, "global", 6))
582		return 0;
583
584	return strncmp(job_section, name, strlen(job_section));
585}
586
587static int is_empty_or_comment(char *line)
588{
589	unsigned int i;
590
591	for (i = 0; i < strlen(line); i++) {
592		if (line[i] == ';')
593			return 1;
594		if (line[i] == '#')
595			return 1;
596		if (!isspace(line[i]) && !iscntrl(line[i]))
597			return 0;
598	}
599
600	return 1;
601}
602
603/*
604 * This is our [ini] type file parser.
605 */
606static int parse_jobs_ini(char *file, int stonewall_flag)
607{
608	unsigned int global;
609	struct thread_data *td;
610	char *string, *name;
611	FILE *f;
612	char *p;
613	int ret = 0, stonewall;
614	int first_sect = 1;
615	int skip_fgets = 0;
616	int inside_skip = 0;
617
618	if (!strcmp(file, "-"))
619		f = stdin;
620	else
621		f = fopen(file, "r");
622
623	if (!f) {
624		perror("fopen job file");
625		return 1;
626	}
627
628	string = malloc(4096);
629
630	/*
631	 * it's really 256 + small bit, 280 should suffice
632	 */
633	name = malloc(280);
634	memset(name, 0, 280);
635
636	stonewall = stonewall_flag;
637	do {
638		/*
639		 * if skip_fgets is set, we already have loaded a line we
640		 * haven't handled.
641		 */
642		if (!skip_fgets) {
643			p = fgets(string, 4095, f);
644			if (!p)
645				break;
646		}
647
648		skip_fgets = 0;
649		strip_blank_front(&p);
650		strip_blank_end(p);
651
652		if (is_empty_or_comment(p))
653			continue;
654		if (sscanf(p, "[%255s]", name) != 1) {
655			if (inside_skip)
656				continue;
657			log_err("fio: option <%s> outside of [] job section\n",
658									p);
659			break;
660		}
661
662		if (skip_this_section(name)) {
663			inside_skip = 1;
664			continue;
665		} else
666			inside_skip = 0;
667
668		global = !strncmp(name, "global", 6);
669
670		name[strlen(name) - 1] = '\0';
671
672		if (dump_cmdline) {
673			if (first_sect)
674				log_info("fio ");
675			if (!global)
676				log_info("--name=%s ", name);
677			first_sect = 0;
678		}
679
680		td = get_new_job(global, &def_thread);
681		if (!td) {
682			ret = 1;
683			break;
684		}
685
686		/*
687		 * Seperate multiple job files by a stonewall
688		 */
689		if (!global && stonewall) {
690			td->o.stonewall = stonewall;
691			stonewall = 0;
692		}
693
694		while ((p = fgets(string, 4096, f)) != NULL) {
695			if (is_empty_or_comment(p))
696				continue;
697
698			strip_blank_front(&p);
699
700			/*
701			 * new section, break out and make sure we don't
702			 * fgets() a new line at the top.
703			 */
704			if (p[0] == '[') {
705				skip_fgets = 1;
706				break;
707			}
708
709			strip_blank_end(p);
710
711			/*
712			 * Don't break here, continue parsing options so we
713			 * dump all the bad ones. Makes trial/error fixups
714			 * easier on the user.
715			 */
716			ret |= fio_option_parse(td, p);
717			if (!ret && dump_cmdline)
718				log_info("--%s ", p);
719		}
720
721		if (!ret)
722			ret = add_job(td, name, 0);
723		else {
724			log_err("fio: job %s dropped\n", name);
725			put_job(td);
726		}
727	} while (!ret);
728
729	if (dump_cmdline)
730		log_info("\n");
731
732	free(string);
733	free(name);
734	if (f != stdin)
735		fclose(f);
736	return ret;
737}
738
739static int fill_def_thread(void)
740{
741	memset(&def_thread, 0, sizeof(def_thread));
742
743	fio_getaffinity(getpid(), &def_thread.o.cpumask);
744
745	/*
746	 * fill default options
747	 */
748	fio_fill_default_options(&def_thread);
749
750	def_thread.o.timeout = def_timeout;
751	def_thread.o.write_bw_log = write_bw_log;
752	def_thread.o.write_lat_log = write_lat_log;
753
754	return 0;
755}
756
757static void free_shm(void)
758{
759	struct shmid_ds sbuf;
760
761	if (threads) {
762		void *tp = threads;
763
764		threads = NULL;
765		file_hash_exit();
766		fio_debug_jobp = NULL;
767		shmdt(tp);
768		shmctl(shm_id, IPC_RMID, &sbuf);
769	}
770
771	scleanup();
772}
773
774/*
775 * The thread area is shared between the main process and the job
776 * threads/processes. So setup a shared memory segment that will hold
777 * all the job info. We use the end of the region for keeping track of
778 * open files across jobs, for file sharing.
779 */
780static int setup_thread_area(void)
781{
782	void *hash;
783
784	/*
785	 * 1024 is too much on some machines, scale max_jobs if
786	 * we get a failure that looks like too large a shm segment
787	 */
788	do {
789		size_t size = max_jobs * sizeof(struct thread_data);
790
791		size += file_hash_size;
792		size += sizeof(unsigned int);
793
794		shm_id = shmget(0, size, IPC_CREAT | 0600);
795		if (shm_id != -1)
796			break;
797		if (errno != EINVAL) {
798			perror("shmget");
799			break;
800		}
801
802		max_jobs >>= 1;
803	} while (max_jobs);
804
805	if (shm_id == -1)
806		return 1;
807
808	threads = shmat(shm_id, NULL, 0);
809	if (threads == (void *) -1) {
810		perror("shmat");
811		return 1;
812	}
813
814	memset(threads, 0, max_jobs * sizeof(struct thread_data));
815	hash = (void *) threads + max_jobs * sizeof(struct thread_data);
816	fio_debug_jobp = (void *) hash + file_hash_size;
817	*fio_debug_jobp = -1;
818	file_hash_init(hash);
819	atexit(free_shm);
820	return 0;
821}
822
823static void usage(const char *name)
824{
825	printf("%s\n", fio_version_string);
826	printf("%s [options] [job options] <job file(s)>\n", name);
827	printf("\t--debug=options\tEnable debug logging\n");
828	printf("\t--output\tWrite output to file\n");
829	printf("\t--timeout\tRuntime in seconds\n");
830	printf("\t--latency-log\tGenerate per-job latency logs\n");
831	printf("\t--bandwidth-log\tGenerate per-job bandwidth logs\n");
832	printf("\t--minimal\tMinimal (terse) output\n");
833	printf("\t--version\tPrint version info and exit\n");
834	printf("\t--help\t\tPrint this page\n");
835	printf("\t--cmdhelp=cmd\tPrint command help, \"all\" for all of"
836		" them\n");
837	printf("\t--showcmd\tTurn a job file into command line options\n");
838	printf("\t--eta=when\tWhen ETA estimate should be printed\n");
839	printf("\t          \tMay be \"always\", \"never\" or \"auto\"\n");
840	printf("\t--readonly\tTurn on safety read-only checks, preventing"
841		" writes\n");
842	printf("\t--section=name\tOnly run specified section in job file\n");
843	printf("\t--alloc-size=kb\tSet smalloc pool to this size in kb"
844		" (def 1024)\n");
845}
846
847#ifdef FIO_INC_DEBUG
848struct debug_level debug_levels[] = {
849	{ .name = "process",	.shift = FD_PROCESS, },
850	{ .name = "file",	.shift = FD_FILE, },
851	{ .name = "io",		.shift = FD_IO, },
852	{ .name = "mem",	.shift = FD_MEM, },
853	{ .name = "blktrace",	.shift = FD_BLKTRACE },
854	{ .name = "verify",	.shift = FD_VERIFY },
855	{ .name = "random",	.shift = FD_RANDOM },
856	{ .name = "parse",	.shift = FD_PARSE },
857	{ .name = "diskutil",	.shift = FD_DISKUTIL },
858	{ .name = "job",	.shift = FD_JOB },
859	{ },
860};
861
862static int set_debug(const char *string)
863{
864	struct debug_level *dl;
865	char *p = (char *) string;
866	char *opt;
867	int i;
868
869	if (!strcmp(string, "?") || !strcmp(string, "help")) {
870		int i;
871
872		log_info("fio: dumping debug options:");
873		for (i = 0; debug_levels[i].name; i++) {
874			dl = &debug_levels[i];
875			log_info("%s,", dl->name);
876		}
877		log_info("all\n");
878		return 1;
879	}
880
881	while ((opt = strsep(&p, ",")) != NULL) {
882		int found = 0;
883
884		if (!strncmp(opt, "all", 3)) {
885			log_info("fio: set all debug options\n");
886			fio_debug = ~0UL;
887			continue;
888		}
889
890		for (i = 0; debug_levels[i].name; i++) {
891			dl = &debug_levels[i];
892			found = !strncmp(opt, dl->name, strlen(dl->name));
893			if (!found)
894				continue;
895
896			if (dl->shift == FD_JOB) {
897				opt = strchr(opt, ':');
898				if (!opt) {
899					log_err("fio: missing job number\n");
900					break;
901				}
902				opt++;
903				fio_debug_jobno = atoi(opt);
904				log_info("fio: set debug jobno %d\n",
905							fio_debug_jobno);
906			} else {
907				log_info("fio: set debug option %s\n", opt);
908				fio_debug |= (1UL << dl->shift);
909			}
910			break;
911		}
912
913		if (!found)
914			log_err("fio: debug mask %s not found\n", opt);
915	}
916	return 0;
917}
918#else
919static void set_debug(const char *string)
920{
921	log_err("fio: debug tracing not included in build\n");
922	return 1;
923}
924#endif
925
926static int parse_cmd_line(int argc, char *argv[])
927{
928	struct thread_data *td = NULL;
929	int c, ini_idx = 0, lidx, ret = 0, do_exit = 0, exit_val = 0;
930
931	while ((c = getopt_long_only(argc, argv, "", l_opts, &lidx)) != -1) {
932		switch (c) {
933		case 'a':
934			smalloc_pool_size = atoi(optarg);
935			break;
936		case 't':
937			def_timeout = atoi(optarg);
938			break;
939		case 'l':
940			write_lat_log = 1;
941			break;
942		case 'w':
943			write_bw_log = 1;
944			break;
945		case 'o':
946			f_out = fopen(optarg, "w+");
947			if (!f_out) {
948				perror("fopen output");
949				exit(1);
950			}
951			f_err = f_out;
952			break;
953		case 'm':
954			terse_output = 1;
955			break;
956		case 'h':
957			usage(argv[0]);
958			exit(0);
959		case 'c':
960			exit(fio_show_option_help(optarg));
961		case 's':
962			dump_cmdline = 1;
963			break;
964		case 'r':
965			read_only = 1;
966			break;
967		case 'v':
968			printf("%s\n", fio_version_string);
969			exit(0);
970		case 'e':
971			if (!strcmp("always", optarg))
972				eta_print = FIO_ETA_ALWAYS;
973			else if (!strcmp("never", optarg))
974				eta_print = FIO_ETA_NEVER;
975			break;
976		case 'd':
977			if (set_debug(optarg))
978				do_exit++;
979			break;
980		case 'x':
981			if (!strcmp(optarg, "global")) {
982				log_err("fio: can't use global as only "
983					"section\n");
984				do_exit++;
985				exit_val = 1;
986				break;
987			}
988			if (job_section)
989				free(job_section);
990			job_section = strdup(optarg);
991			break;
992		case FIO_GETOPT_JOB: {
993			const char *opt = l_opts[lidx].name;
994			char *val = optarg;
995
996			if (!strncmp(opt, "name", 4) && td) {
997				ret = add_job(td, td->o.name ?: "fio", 0);
998				if (ret) {
999					put_job(td);
1000					return 0;
1001				}
1002				td = NULL;
1003			}
1004			if (!td) {
1005				int is_section = !strncmp(opt, "name", 4);
1006				int global = 0;
1007
1008				if (!is_section || !strncmp(val, "global", 6))
1009					global = 1;
1010
1011				if (is_section && skip_this_section(val))
1012					continue;
1013
1014				td = get_new_job(global, &def_thread);
1015				if (!td)
1016					return 0;
1017			}
1018
1019			ret = fio_cmd_option_parse(td, opt, val);
1020			break;
1021		}
1022		default:
1023			do_exit++;
1024			exit_val = 1;
1025			break;
1026		}
1027	}
1028
1029	if (do_exit)
1030		exit(exit_val);
1031
1032	if (td) {
1033		if (!ret)
1034			ret = add_job(td, td->o.name ?: "fio", 0);
1035		if (ret)
1036			put_job(td);
1037	}
1038
1039	while (optind < argc) {
1040		ini_idx++;
1041		ini_file = realloc(ini_file, ini_idx * sizeof(char *));
1042		ini_file[ini_idx - 1] = strdup(argv[optind]);
1043		optind++;
1044	}
1045
1046	return ini_idx;
1047}
1048
1049int parse_options(int argc, char *argv[])
1050{
1051	int job_files, i;
1052
1053	f_out = stdout;
1054	f_err = stderr;
1055
1056	fio_options_dup_and_init(l_opts);
1057
1058	if (setup_thread_area())
1059		return 1;
1060	if (fill_def_thread())
1061		return 1;
1062
1063	job_files = parse_cmd_line(argc, argv);
1064
1065	for (i = 0; i < job_files; i++) {
1066		if (fill_def_thread())
1067			return 1;
1068		if (parse_jobs_ini(ini_file[i], i))
1069			return 1;
1070		free(ini_file[i]);
1071	}
1072
1073	free(ini_file);
1074	options_mem_free(&def_thread);
1075
1076	if (!thread_number) {
1077		if (dump_cmdline)
1078			return 0;
1079
1080		log_err("No jobs defined(s)\n");
1081		usage(argv[0]);
1082		return 1;
1083	}
1084
1085	return 0;
1086}
1087