[fio.git] / filesetup.c

#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <assert.h>
#include <sys/stat.h>
#include <sys/mman.h>

#include "fio.h"
#include "os.h"

static int create_file(struct thread_data *td, struct fio_file *f)
{
	unsigned long long left;
	unsigned int bs;
	char *b;
	int r;

	f->fd = open(f->file_name, O_WRONLY | O_CREAT | O_TRUNC, 0644);
	if (f->fd < 0) {
		td_verror(td, errno);
		return 1;
	}

	if (ftruncate(f->fd, f->file_size) == -1) {
		td_verror(td, errno);
		goto err;
	}

	b = malloc(td->max_bs);
	memset(b, 0, td->max_bs);

	left = f->file_size;
	while (left && !td->terminate) {
		bs = td->max_bs;
		if (bs > left)
			bs = left;

		r = write(f->fd, b, bs);

		if (r == (int) bs) {
			left -= bs;
			continue;
		} else {
			if (r < 0)
				td_verror(td, errno);
			else
				td_verror(td, EIO);

			break;
		}
	}

	if (td->terminate)
		unlink(f->file_name);
	else if (td->create_fsync)
		fsync(f->fd);

	free(b);
	close(f->fd);
	f->fd = -1;
	return 0;
err:
	close(f->fd);
	f->fd = -1;
	return 1;
}

static int create_files(struct thread_data *td)
{
	struct fio_file *f;
	int i, err;

	/*
	 * unless specifically asked for overwrite, let normal io extend it
	 */
	if (!td->overwrite) {
		td->io_size = td->total_file_size;
		for_each_file(td, f, i)
			f->file_size = td->total_file_size / td->nr_files;

		return 0;
	}

	if (!td->total_file_size) {
		log_err("Need size for create\n");
		td_verror(td, EINVAL);
		return 1;
	}

	temp_stall_ts = 1;
	fprintf(f_out, "%s: Laying out IO file(s) (%LuMiB)\n",
					td->name, td->total_file_size >> 20);

	err = 0;
	for_each_file(td, f, i) {
		f->file_size = td->total_file_size / td->nr_files;
		err = create_file(td, f);
			break;

		td->io_size += f->file_size;
	}

	temp_stall_ts = 0;
	return err;
}

static int file_size(struct thread_data *td, struct fio_file *f)
{
	struct stat st;

	if (td->overwrite) {
		if (fstat(f->fd, &st) == -1) {
			td_verror(td, errno);
			return 1;
		}

		f->real_file_size = st.st_size;

		if (!f->file_size || f->file_size > f->real_file_size)
			f->file_size = f->real_file_size;
	}

	f->file_size -= f->file_offset;
	return 0;
}

static int bdev_size(struct thread_data *td, struct fio_file *f)
{
	unsigned long long bytes;
	int r;

	r = blockdev_size(f->fd, &bytes);
	if (r) {
		td_verror(td, r);
		return 1;
	}

	f->real_file_size = bytes;

	/*
	 * no extend possibilities, so limit size to device size if too large
	 */
	if (!f->file_size || f->file_size > f->real_file_size)
		f->file_size = f->real_file_size;

	f->file_size -= f->file_offset;
	return 0;
}

static int get_file_size(struct thread_data *td, struct fio_file *f)
{
	int ret = 0;

	if (td->filetype == FIO_TYPE_FILE)
		ret = file_size(td, f);
	else if (td->filetype == FIO_TYPE_BD)
		ret = bdev_size(td, f);
	else
		f->real_file_size = -1;

	if (ret)
		return ret;

	if (f->file_offset > f->real_file_size) {
		log_err("%s: offset extends end (%Lu > %Lu)\n", td->name, f->file_offset, f->real_file_size);
		return 1;
	}

	td->io_size += f->file_size;
	return 0;
}

static int __setup_file_mmap(struct thread_data *td, struct fio_file *f)
{
	int flags;

	if (td_rw(td))
		flags = PROT_READ | PROT_WRITE;
	else if (td_write(td)) {
		flags = PROT_WRITE;

		if (td->verify != VERIFY_NONE)
			flags |= PROT_READ;
	} else
		flags = PROT_READ;

	f->mmap = mmap(NULL, f->file_size, flags, MAP_SHARED, f->fd, f->file_offset);
	if (f->mmap == MAP_FAILED) {
		f->mmap = NULL;
		td_verror(td, errno);
		return 1;
	}

	if (td->invalidate_cache) {
		if (madvise(f->mmap, f->file_size, MADV_DONTNEED) < 0) {
			td_verror(td, errno);
			return 1;
		}
	}

	if (td->sequential) {
		if (madvise(f->mmap, f->file_size, MADV_SEQUENTIAL) < 0) {
			td_verror(td, errno);
			return 1;
		}
	} else {
		if (madvise(f->mmap, f->file_size, MADV_RANDOM) < 0) {
			td_verror(td, errno);
			return 1;
		}
	}

	return 0;
}

static int setup_files_mmap(struct thread_data *td)
{
	struct fio_file *f;
	int i, err = 0;

	for_each_file(td, f, i) {
		err = __setup_file_mmap(td, f);
		if (err)
			break;
	}

	return err;
}

static int __setup_file_plain(struct thread_data *td, struct fio_file *f)
{
	if (td->invalidate_cache) {
		if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_DONTNEED) < 0) {
			td_verror(td, errno);
			return 1;
		}
	}

	if (td->sequential) {
		if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_SEQUENTIAL) < 0) {
			td_verror(td, errno);
			return 1;
		}
	} else {
		if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_RANDOM) < 0) {
			td_verror(td, errno);
			return 1;
		}
	}

	return 0;
}

static int setup_files_plain(struct thread_data *td)
{
	struct fio_file *f;
	int i, err = 0;

	for_each_file(td, f, i) {
		err = __setup_file_plain(td, f);
		if (err)
			break;
	}

	return err;
}

static int setup_file(struct thread_data *td, struct fio_file *f)
{
	struct stat st;
	int flags = 0;

	if (stat(f->file_name, &st) == -1) {
		if (errno != ENOENT) {
			td_verror(td, errno);
			return 1;
		}
		if (!td->create_file) {
			td_verror(td, ENOENT);
			return 1;
		}
		if (create_file(td, f))
			return 1;
	} else if (td->filetype == FIO_TYPE_FILE &&
		   st.st_size < (off_t) f->file_size) {
		if (create_file(td, f))
			return 1;
	}

	if (td->odirect)
		flags |= OS_O_DIRECT;

	if (td_write(td) || td_rw(td)) {
		if (td->filetype == FIO_TYPE_FILE) {
			if (!td->overwrite)
				flags |= O_TRUNC;

			flags |= O_CREAT;
		}
		if (td->sync_io)
			flags |= O_SYNC;

		flags |= O_RDWR;

		f->fd = open(f->file_name, flags, 0600);
	} else {
		if (td->filetype == FIO_TYPE_CHAR)
			flags |= O_RDWR;
		else
			flags |= O_RDONLY;

		f->fd = open(f->file_name, flags);
	}

	if (f->fd == -1) {
		td_verror(td, errno);
		return 1;
	}

	if (get_file_size(td, f))
		return 1;

	return 0;
}

int setup_files(struct thread_data *td)
{
	struct fio_file *f;
	int i, err;

	/*
	 * if ioengine defines a setup() method, it's responsible for
	 * setting up everything in the td->files[] area.
	 */
	if (td->io_ops->setup)
		return td->io_ops->setup(td);

	if (create_files(td))
		return 1;

	for_each_file(td, f, i) {
		err = setup_file(td, f);
		if (err)
			break;
	}

	if (td->io_size == 0) {
		log_err("%s: no io blocks\n", td->name);
		td_verror(td, EINVAL);
		return 1;
	}

	if (!td->zone_size)
		td->zone_size = td->io_size;

	td->total_io_size = td->io_size * td->loops;

	if (td->io_ops->flags & FIO_MMAPIO)
		return setup_files_mmap(td);
	else
		return setup_files_plain(td);
}

void close_files(struct thread_data *td)
{
	int i;

	for (i = 0; i < td->nr_files; i++) {
		struct fio_file *f = &td->files[i];

		if (f->fd != -1) {
			close(f->fd);
			f->fd = -1;
		}
		if (f->mmap) {
			munmap(f->mmap, f->file_size);
			f->mmap = NULL;
		}
	}
}
Commit	Line	Data
	1	#include <unistd.h>
	2	#include <fcntl.h>
	3	#include <string.h>
	4	#include <assert.h>
	5	#include <sys/stat.h>
	6	#include <sys/mman.h>
	7
	8	#include "fio.h"
	9	#include "os.h"
	10
	11	static int create_file(struct thread_data td, struct fio_file f)
	12	{
	13	unsigned long long left;
	14	unsigned int bs;
	15	char *b;
	16	int r;
	17
	18	f->fd = open(f->file_name, O_WRONLY \| O_CREAT \| O_TRUNC, 0644);
	19	if (f->fd < 0) {
	20	td_verror(td, errno);
	21	return 1;
	22	}
	23
	24	if (ftruncate(f->fd, f->file_size) == -1) {
	25	td_verror(td, errno);
	26	goto err;
	27	}
	28
	29	b = malloc(td->max_bs);
	30	memset(b, 0, td->max_bs);
	31
	32	left = f->file_size;
	33	while (left && !td->terminate) {
	34	bs = td->max_bs;
	35	if (bs > left)
	36	bs = left;
	37
	38	r = write(f->fd, b, bs);
	39
	40	if (r == (int) bs) {
	41	left -= bs;
	42	continue;
	43	} else {
	44	if (r < 0)
	45	td_verror(td, errno);
	46	else
	47	td_verror(td, EIO);
	48
	49	break;
	50	}
	51	}
	52
	53	if (td->terminate)
	54	unlink(f->file_name);
	55	else if (td->create_fsync)
	56	fsync(f->fd);
	57
	58	free(b);
	59	close(f->fd);
	60	f->fd = -1;
	61	return 0;
	62	err:
	63	close(f->fd);
	64	f->fd = -1;
	65	return 1;
	66	}
	67
	68	static int create_files(struct thread_data *td)
	69	{
	70	struct fio_file *f;
	71	int i, err;
	72
	73	/*
	74	* unless specifically asked for overwrite, let normal io extend it
	75	*/
	76	if (!td->overwrite) {
	77	td->io_size = td->total_file_size;
	78	for_each_file(td, f, i)
	79	f->file_size = td->total_file_size / td->nr_files;
	80
	81	return 0;
	82	}
	83
	84	if (!td->total_file_size) {
	85	log_err("Need size for create\n");
	86	td_verror(td, EINVAL);
	87	return 1;
	88	}
	89
	90	temp_stall_ts = 1;
	91	fprintf(f_out, "%s: Laying out IO file(s) (%LuMiB)\n",
	92	td->name, td->total_file_size >> 20);
	93
	94	err = 0;
	95	for_each_file(td, f, i) {
	96	f->file_size = td->total_file_size / td->nr_files;
	97	err = create_file(td, f);
	98	break;
	99
	100	td->io_size += f->file_size;
	101	}
	102
	103	temp_stall_ts = 0;
	104	return err;
	105	}
	106
	107	static int file_size(struct thread_data td, struct fio_file f)
	108	{
	109	struct stat st;
	110
	111	if (td->overwrite) {
	112	if (fstat(f->fd, &st) == -1) {
	113	td_verror(td, errno);
	114	return 1;
	115	}
	116
	117	f->real_file_size = st.st_size;
	118
	119	if (!f->file_size \|\| f->file_size > f->real_file_size)
	120	f->file_size = f->real_file_size;
	121	}
	122
	123	f->file_size -= f->file_offset;
	124	return 0;
	125	}
	126
	127	static int bdev_size(struct thread_data td, struct fio_file f)
	128	{
	129	unsigned long long bytes;
	130	int r;
	131
	132	r = blockdev_size(f->fd, &bytes);
	133	if (r) {
	134	td_verror(td, r);
	135	return 1;
	136	}
	137
	138	f->real_file_size = bytes;
	139
	140	/*
	141	* no extend possibilities, so limit size to device size if too large
	142	*/
	143	if (!f->file_size \|\| f->file_size > f->real_file_size)
	144	f->file_size = f->real_file_size;
	145
	146	f->file_size -= f->file_offset;
	147	return 0;
	148	}
	149
	150	static int get_file_size(struct thread_data td, struct fio_file f)
	151	{
	152	int ret = 0;
	153
	154	if (td->filetype == FIO_TYPE_FILE)
	155	ret = file_size(td, f);
	156	else if (td->filetype == FIO_TYPE_BD)
	157	ret = bdev_size(td, f);
	158	else
	159	f->real_file_size = -1;
	160
	161	if (ret)
	162	return ret;
	163
	164	if (f->file_offset > f->real_file_size) {
	165	log_err("%s: offset extends end (%Lu > %Lu)\n", td->name, f->file_offset, f->real_file_size);
	166	return 1;
	167	}
	168
	169	td->io_size += f->file_size;
	170	return 0;
	171	}
	172
	173	static int __setup_file_mmap(struct thread_data td, struct fio_file f)
	174	{
	175	int flags;
	176
	177	if (td_rw(td))
	178	flags = PROT_READ \| PROT_WRITE;
	179	else if (td_write(td)) {
	180	flags = PROT_WRITE;
	181
	182	if (td->verify != VERIFY_NONE)
	183	flags \|= PROT_READ;
	184	} else
	185	flags = PROT_READ;
	186
	187	f->mmap = mmap(NULL, f->file_size, flags, MAP_SHARED, f->fd, f->file_offset);
	188	if (f->mmap == MAP_FAILED) {
	189	f->mmap = NULL;
	190	td_verror(td, errno);
	191	return 1;
	192	}
	193
	194	if (td->invalidate_cache) {
	195	if (madvise(f->mmap, f->file_size, MADV_DONTNEED) < 0) {
	196	td_verror(td, errno);
	197	return 1;
	198	}
	199	}
	200
	201	if (td->sequential) {
	202	if (madvise(f->mmap, f->file_size, MADV_SEQUENTIAL) < 0) {
	203	td_verror(td, errno);
	204	return 1;
	205	}
	206	} else {
	207	if (madvise(f->mmap, f->file_size, MADV_RANDOM) < 0) {
	208	td_verror(td, errno);
	209	return 1;
	210	}
	211	}
	212
	213	return 0;
	214	}
	215
	216	static int setup_files_mmap(struct thread_data *td)
	217	{
	218	struct fio_file *f;
	219	int i, err = 0;
	220
	221	for_each_file(td, f, i) {
	222	err = __setup_file_mmap(td, f);
	223	if (err)
	224	break;
	225	}
	226
	227	return err;
	228	}
	229
	230	static int __setup_file_plain(struct thread_data td, struct fio_file f)
	231	{
	232	if (td->invalidate_cache) {
	233	if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_DONTNEED) < 0) {
	234	td_verror(td, errno);
	235	return 1;
	236	}
	237	}
	238
	239	if (td->sequential) {
	240	if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_SEQUENTIAL) < 0) {
	241	td_verror(td, errno);
	242	return 1;
	243	}
	244	} else {
	245	if (fadvise(f->fd, f->file_offset, f->file_size, POSIX_FADV_RANDOM) < 0) {
	246	td_verror(td, errno);
	247	return 1;
	248	}
	249	}
	250
	251	return 0;
	252	}
	253
	254	static int setup_files_plain(struct thread_data *td)
	255	{
	256	struct fio_file *f;
	257	int i, err = 0;
	258
	259	for_each_file(td, f, i) {
	260	err = __setup_file_plain(td, f);
	261	if (err)
	262	break;
	263	}
	264
	265	return err;
	266	}
	267
	268	static int setup_file(struct thread_data td, struct fio_file f)
	269	{
	270	struct stat st;
	271	int flags = 0;
	272
	273	if (stat(f->file_name, &st) == -1) {
	274	if (errno != ENOENT) {
	275	td_verror(td, errno);
	276	return 1;
	277	}
	278	if (!td->create_file) {
	279	td_verror(td, ENOENT);
	280	return 1;
	281	}
	282	if (create_file(td, f))
	283	return 1;
	284	} else if (td->filetype == FIO_TYPE_FILE &&
	285	st.st_size < (off_t) f->file_size) {
	286	if (create_file(td, f))
	287	return 1;
	288	}
	289
	290	if (td->odirect)
	291	flags \|= OS_O_DIRECT;
	292
	293	if (td_write(td) \|\| td_rw(td)) {
	294	if (td->filetype == FIO_TYPE_FILE) {
	295	if (!td->overwrite)
	296	flags \|= O_TRUNC;
	297
	298	flags \|= O_CREAT;
	299	}
	300	if (td->sync_io)
	301	flags \|= O_SYNC;
	302
	303	flags \|= O_RDWR;
	304
	305	f->fd = open(f->file_name, flags, 0600);
	306	} else {
	307	if (td->filetype == FIO_TYPE_CHAR)
	308	flags \|= O_RDWR;
	309	else
	310	flags \|= O_RDONLY;
	311
	312	f->fd = open(f->file_name, flags);
	313	}
	314
	315	if (f->fd == -1) {
	316	td_verror(td, errno);
	317	return 1;
	318	}
	319
	320	if (get_file_size(td, f))
	321	return 1;
	322
	323	return 0;
	324	}
	325
	326	int setup_files(struct thread_data *td)
	327	{
	328	struct fio_file *f;
	329	int i, err;
	330
	331	/*
	332	* if ioengine defines a setup() method, it's responsible for
	333	* setting up everything in the td->files[] area.
	334	*/
	335	if (td->io_ops->setup)
	336	return td->io_ops->setup(td);
	337
	338	if (create_files(td))
	339	return 1;
	340
	341	for_each_file(td, f, i) {
	342	err = setup_file(td, f);
	343	if (err)
	344	break;
	345	}
	346
	347	if (td->io_size == 0) {
	348	log_err("%s: no io blocks\n", td->name);
	349	td_verror(td, EINVAL);
	350	return 1;
	351	}
	352
	353	if (!td->zone_size)
	354	td->zone_size = td->io_size;
	355
	356	td->total_io_size = td->io_size * td->loops;
	357
	358	if (td->io_ops->flags & FIO_MMAPIO)
	359	return setup_files_mmap(td);
	360	else
	361	return setup_files_plain(td);
	362	}
	363
	364	void close_files(struct thread_data *td)
	365	{
	366	int i;
	367
	368	for (i = 0; i < td->nr_files; i++) {
	369	struct fio_file *f = &td->files[i];
	370
	371	if (f->fd != -1) {
	372	close(f->fd);
	373	f->fd = -1;
	374	}
	375	if (f->mmap) {
	376	munmap(f->mmap, f->file_size);
	377	f->mmap = NULL;
	378	}
	379	}
	380	}