[fio.git] / blktrace.c

/*
 * blktrace support code for fio
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "flist.h"
#include "fio.h"
#include "blktrace.h"
#include "blktrace_api.h"
#include "oslib/linux-dev-lookup.h"

#define TRACE_FIFO_SIZE	8192

/*
 * fifo refill frontend, to avoid reading data in trace sized bites
 */
static int refill_fifo(struct thread_data *td, struct fifo *fifo, int fd)
{
	char buf[TRACE_FIFO_SIZE];
	unsigned int total;
	int ret;

	total = sizeof(buf);
	if (total > fifo_room(fifo))
		total = fifo_room(fifo);

	ret = read(fd, buf, total);
	if (ret < 0) {
		int read_err = errno;

		assert(read_err > 0);
		td_verror(td, read_err, "read blktrace file");
		return -read_err;
	}

	if (ret > 0)
		ret = fifo_put(fifo, buf, ret);

	dprint(FD_BLKTRACE, "refill: filled %d bytes\n", ret);
	return ret;
}

/*
 * Retrieve 'len' bytes from the fifo, refilling if necessary.
 */
static int trace_fifo_get(struct thread_data *td, struct fifo *fifo, int fd,
			  void *buf, unsigned int len)
{
	if (fifo_len(fifo) < len) {
		int ret = refill_fifo(td, fifo, fd);

		if (ret < 0)
			return ret;
	}

	return fifo_get(fifo, buf, len);
}

/*
 * Just discard the pdu by seeking past it.
 */
static int discard_pdu(struct thread_data *td, struct fifo *fifo, int fd,
		       struct blk_io_trace *t)
{
	if (t->pdu_len == 0)
		return 0;

	dprint(FD_BLKTRACE, "discard pdu len %u\n", t->pdu_len);
	return trace_fifo_get(td, fifo, fd, NULL, t->pdu_len);
}

/*
 * Check if this is a blktrace binary data file. We read a single trace
 * into memory and check for the magic signature.
 */
bool is_blktrace(const char *filename, int *need_swap)
{
	struct blk_io_trace t;
	int fd, ret;

	fd = open(filename, O_RDONLY);
	if (fd < 0)
		return false;

	ret = read(fd, &t, sizeof(t));
	close(fd);

	if (ret < 0) {
		perror("read blktrace");
		return false;
	} else if (ret != sizeof(t)) {
		log_err("fio: short read on blktrace file\n");
		return false;
	}

	if ((t.magic & 0xffffff00) == BLK_IO_TRACE_MAGIC) {
		*need_swap = 0;
		return true;
	}

	/*
	 * Maybe it needs to be endian swapped...
	 */
	t.magic = fio_swap32(t.magic);
	if ((t.magic & 0xffffff00) == BLK_IO_TRACE_MAGIC) {
		*need_swap = 1;
		return true;
	}

	return false;
}

#define FMINORBITS	20
#define FMINORMASK	((1U << FMINORBITS) - 1)
#define FMAJOR(dev)	((unsigned int) ((dev) >> FMINORBITS))
#define FMINOR(dev)	((unsigned int) ((dev) & FMINORMASK))

static void trace_add_open_close_event(struct thread_data *td, int fileno, enum file_log_act action)
{
	struct io_piece *ipo;

	ipo = calloc(1, sizeof(*ipo));
	init_ipo(ipo);

	ipo->ddir = DDIR_INVAL;
	ipo->fileno = fileno;
	ipo->file_action = action;
	flist_add_tail(&ipo->list, &td->io_log_list);
}

static int trace_add_file(struct thread_data *td, __u32 device)
{
	static unsigned int last_maj, last_min, last_fileno;
	unsigned int maj = FMAJOR(device);
	unsigned int min = FMINOR(device);
	struct fio_file *f;
	char dev[256];
	unsigned int i;

	if (last_maj == maj && last_min == min)
		return last_fileno;

	last_maj = maj;
	last_min = min;

	/*
	 * check for this file in our list
	 */
	for_each_file(td, f, i)
		if (f->major == maj && f->minor == min) {
			last_fileno = f->fileno;
			return last_fileno;
		}

	strcpy(dev, "/dev");
	if (blktrace_lookup_device(td->o.replay_redirect, dev, maj, min)) {
		int fileno;

		if (td->o.replay_redirect)
			dprint(FD_BLKTRACE, "device lookup: %d/%d\n overridden"
					" with: %s\n", maj, min,
					td->o.replay_redirect);
		else
			dprint(FD_BLKTRACE, "device lookup: %d/%d\n", maj, min);

		dprint(FD_BLKTRACE, "add devices %s\n", dev);
		fileno = add_file_exclusive(td, dev);
		td->o.open_files++;
		td->files[fileno]->major = maj;
		td->files[fileno]->minor = min;
		trace_add_open_close_event(td, fileno, FIO_LOG_OPEN_FILE);
		last_fileno = fileno;
	}

	return last_fileno;
}

static void t_bytes_align(struct thread_options *o, struct blk_io_trace *t)
{
	if (!o->replay_align)
		return;

	t->bytes = (t->bytes + o->replay_align - 1) & ~(o->replay_align - 1);
}

/*
 * Store blk_io_trace data in an ipo for later retrieval.
 */
static void store_ipo(struct thread_data *td, unsigned long long offset,
		      unsigned int bytes, int rw, unsigned long long ttime,
		      int fileno)
{
	struct io_piece *ipo;

	ipo = calloc(1, sizeof(*ipo));
	init_ipo(ipo);

	ipo->offset = offset * 512;
	if (td->o.replay_scale)
		ipo->offset = ipo->offset / td->o.replay_scale;
	ipo_bytes_align(td->o.replay_align, ipo);
	ipo->len = bytes;
	ipo->delay = ttime / 1000;
	if (rw)
		ipo->ddir = DDIR_WRITE;
	else
		ipo->ddir = DDIR_READ;
	ipo->fileno = fileno;

	dprint(FD_BLKTRACE, "store ddir=%d, off=%llu, len=%lu, delay=%lu\n",
							ipo->ddir, ipo->offset,
							ipo->len, ipo->delay);
	queue_io_piece(td, ipo);
}

static void handle_trace_notify(struct blk_io_trace *t)
{
	switch (t->action) {
	case BLK_TN_PROCESS:
		dprint(FD_BLKTRACE, "got process notify: %x, %d\n",
				t->action, t->pid);
		break;
	case BLK_TN_TIMESTAMP:
		dprint(FD_BLKTRACE, "got timestamp notify: %x, %d\n",
				t->action, t->pid);
		break;
	case BLK_TN_MESSAGE:
		break;
	default:
		dprint(FD_BLKTRACE, "unknown trace act %x\n", t->action);
		break;
	}
}

static void handle_trace_discard(struct thread_data *td,
				 struct blk_io_trace *t,
				 unsigned long long ttime,
				 unsigned long *ios, unsigned int *bs)
{
	struct io_piece *ipo;
	int fileno;

	if (td->o.replay_skip & (1u << DDIR_TRIM))
		return;

	ipo = calloc(1, sizeof(*ipo));
	init_ipo(ipo);
	fileno = trace_add_file(td, t->device);

	ios[DDIR_TRIM]++;
	if (t->bytes > bs[DDIR_TRIM])
		bs[DDIR_TRIM] = t->bytes;

	td->o.size += t->bytes;

	INIT_FLIST_HEAD(&ipo->list);

	ipo->offset = t->sector * 512;
	if (td->o.replay_scale)
		ipo->offset = ipo->offset / td->o.replay_scale;
	ipo_bytes_align(td->o.replay_align, ipo);
	ipo->len = t->bytes;
	ipo->delay = ttime / 1000;
	ipo->ddir = DDIR_TRIM;
	ipo->fileno = fileno;

	dprint(FD_BLKTRACE, "store discard, off=%llu, len=%lu, delay=%lu\n",
							ipo->offset, ipo->len,
							ipo->delay);
	queue_io_piece(td, ipo);
}

static void dump_trace(struct blk_io_trace *t)
{
	log_err("blktrace: ignoring zero byte trace: action=%x\n", t->action);
}

static void handle_trace_fs(struct thread_data *td, struct blk_io_trace *t,
			    unsigned long long ttime, unsigned long *ios,
			    unsigned int *bs)
{
	int rw;
	int fileno;

	fileno = trace_add_file(td, t->device);

	rw = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;

	if (rw) {
		if (td->o.replay_skip & (1u << DDIR_WRITE))
			return;
	} else {
		if (td->o.replay_skip & (1u << DDIR_READ))
			return;
	}

	if (!t->bytes) {
		if (!fio_did_warn(FIO_WARN_BTRACE_ZERO))
			dump_trace(t);
		return;
	}

	if (t->bytes > bs[rw])
		bs[rw] = t->bytes;

	ios[rw]++;
	td->o.size += t->bytes;
	store_ipo(td, t->sector, t->bytes, rw, ttime, fileno);
}

static void handle_trace_flush(struct thread_data *td, struct blk_io_trace *t,
			       unsigned long long ttime, unsigned long *ios)
{
	struct io_piece *ipo;
	int fileno;

	if (td->o.replay_skip & (1u << DDIR_SYNC))
		return;

	ipo = calloc(1, sizeof(*ipo));
	init_ipo(ipo);
	fileno = trace_add_file(td, t->device);

	ipo->delay = ttime / 1000;
	ipo->ddir = DDIR_SYNC;
	ipo->fileno = fileno;

	ios[DDIR_SYNC]++;
	dprint(FD_BLKTRACE, "store flush delay=%lu\n", ipo->delay);
	queue_io_piece(td, ipo);
}

/*
 * We only care for queue traces, most of the others are side effects
 * due to internal workings of the block layer.
 */
static void handle_trace(struct thread_data *td, struct blk_io_trace *t,
			 unsigned long *ios, unsigned int *bs)
{
	static unsigned long long last_ttime;
	unsigned long long delay = 0;

	if ((t->action & 0xffff) != __BLK_TA_QUEUE)
		return;

	if (!(t->action & BLK_TC_ACT(BLK_TC_NOTIFY))) {
		if (!last_ttime || td->o.no_stall)
			delay = 0;
		else if (td->o.replay_time_scale == 100)
			delay = t->time - last_ttime;
		else {
			double tmp = t->time - last_ttime;
			double scale;

			scale = (double) 100.0 / (double) td->o.replay_time_scale;
			tmp *= scale;
			delay = tmp;
		}
		last_ttime = t->time;
	}

	t_bytes_align(&td->o, t);

	if (t->action & BLK_TC_ACT(BLK_TC_NOTIFY))
		handle_trace_notify(t);
	else if (t->action & BLK_TC_ACT(BLK_TC_DISCARD))
		handle_trace_discard(td, t, delay, ios, bs);
	else if (t->action & BLK_TC_ACT(BLK_TC_FLUSH))
		handle_trace_flush(td, t, delay, ios);
	else
		handle_trace_fs(td, t, delay, ios, bs);
}

static void byteswap_trace(struct blk_io_trace *t)
{
	t->magic = fio_swap32(t->magic);
	t->sequence = fio_swap32(t->sequence);
	t->time = fio_swap64(t->time);
	t->sector = fio_swap64(t->sector);
	t->bytes = fio_swap32(t->bytes);
	t->action = fio_swap32(t->action);
	t->pid = fio_swap32(t->pid);
	t->device = fio_swap32(t->device);
	t->cpu = fio_swap32(t->cpu);
	t->error = fio_swap16(t->error);
	t->pdu_len = fio_swap16(t->pdu_len);
}

static bool t_is_write(struct blk_io_trace *t)
{
	return (t->action & BLK_TC_ACT(BLK_TC_WRITE | BLK_TC_DISCARD)) != 0;
}

static enum fio_ddir t_get_ddir(struct blk_io_trace *t)
{
	if (t->action & BLK_TC_ACT(BLK_TC_READ))
		return DDIR_READ;
	else if (t->action & BLK_TC_ACT(BLK_TC_WRITE))
		return DDIR_WRITE;
	else if (t->action & BLK_TC_ACT(BLK_TC_DISCARD))
		return DDIR_TRIM;

	return DDIR_INVAL;
}

static void depth_inc(struct blk_io_trace *t, int *depth)
{
	enum fio_ddir ddir;

	ddir = t_get_ddir(t);
	if (ddir != DDIR_INVAL)
		depth[ddir]++;
}

static void depth_dec(struct blk_io_trace *t, int *depth)
{
	enum fio_ddir ddir;

	ddir = t_get_ddir(t);
	if (ddir != DDIR_INVAL)
		depth[ddir]--;
}

static void depth_end(struct blk_io_trace *t, int *this_depth, int *depth)
{
	enum fio_ddir ddir = DDIR_INVAL;

	ddir = t_get_ddir(t);
	if (ddir != DDIR_INVAL) {
		depth[ddir] = max(depth[ddir], this_depth[ddir]);
		this_depth[ddir] = 0;
	}
}

/*
 * Load a blktrace file by reading all the blk_io_trace entries, and storing
 * them as io_pieces like the fio text version would do.
 */
bool load_blktrace(struct thread_data *td, const char *filename, int need_swap)
{
	struct blk_io_trace t;
	unsigned long ios[DDIR_RWDIR_SYNC_CNT] = { };
	unsigned int rw_bs[DDIR_RWDIR_CNT] = { };
	unsigned long skipped_writes;
	struct fifo *fifo;
	int fd, i, old_state, max_depth;
	struct fio_file *f;
	int this_depth[DDIR_RWDIR_CNT] = { };
	int depth[DDIR_RWDIR_CNT] = { };

	fd = open(filename, O_RDONLY);
	if (fd < 0) {
		td_verror(td, errno, "open blktrace file");
		return false;
	}

	fifo = fifo_alloc(TRACE_FIFO_SIZE);

	old_state = td_bump_runstate(td, TD_SETTING_UP);

	td->o.size = 0;
	skipped_writes = 0;
	do {
		int ret = trace_fifo_get(td, fifo, fd, &t, sizeof(t));

		if (ret < 0)
			goto err;
		else if (!ret)
			break;
		else if (ret < (int) sizeof(t)) {
			log_err("fio: short fifo get\n");
			break;
		}

		if (need_swap)
			byteswap_trace(&t);

		if ((t.magic & 0xffffff00) != BLK_IO_TRACE_MAGIC) {
			log_err("fio: bad magic in blktrace data: %x\n",
								t.magic);
			goto err;
		}
		if ((t.magic & 0xff) != BLK_IO_TRACE_VERSION) {
			log_err("fio: bad blktrace version %d\n",
								t.magic & 0xff);
			goto err;
		}
		ret = discard_pdu(td, fifo, fd, &t);
		if (ret < 0) {
			td_verror(td, -ret, "blktrace lseek");
			goto err;
		} else if (t.pdu_len != ret) {
			log_err("fio: discarded %d of %d\n", ret, t.pdu_len);
			goto err;
		}
		if ((t.action & BLK_TC_ACT(BLK_TC_NOTIFY)) == 0) {
			if ((t.action & 0xffff) == __BLK_TA_QUEUE)
				depth_inc(&t, this_depth);
			else if (((t.action & 0xffff) == __BLK_TA_BACKMERGE) ||
				((t.action & 0xffff) == __BLK_TA_FRONTMERGE))
				depth_dec(&t, this_depth);
			else if ((t.action & 0xffff) == __BLK_TA_COMPLETE)
				depth_end(&t, this_depth, depth);

			if (t_is_write(&t) && read_only) {
				skipped_writes++;
				continue;
			}
		}

		handle_trace(td, &t, ios, rw_bs);
	} while (1);

	for_each_file(td, f, i)
		trace_add_open_close_event(td, f->fileno, FIO_LOG_CLOSE_FILE);

	fifo_free(fifo);
	close(fd);

	td_restore_runstate(td, old_state);

	if (!td->files_index) {
		log_err("fio: did not find replay device(s)\n");
		return false;
	}

	/*
	 * For stacked devices, we don't always get a COMPLETE event so
	 * the depth grows to insane values. Limit it to something sane(r).
	 */
	max_depth = 0;
	for (i = 0; i < DDIR_RWDIR_CNT; i++) {
		if (depth[i] > 1024)
			depth[i] = 1024;
		else if (!depth[i] && ios[i])
			depth[i] = 1;
		max_depth = max(depth[i], max_depth);
	}

	if (skipped_writes)
		log_err("fio: %s skips replay of %lu writes due to read-only\n",
						td->o.name, skipped_writes);

	if (!ios[DDIR_READ] && !ios[DDIR_WRITE] && !ios[DDIR_TRIM] &&
	    !ios[DDIR_SYNC]) {
		log_err("fio: found no ios in blktrace data\n");
		return false;
	}

	td->o.td_ddir = 0;
	if (ios[DDIR_READ]) {
		td->o.td_ddir |= TD_DDIR_READ;
		td->o.max_bs[DDIR_READ] = rw_bs[DDIR_READ];
	}
	if (ios[DDIR_WRITE]) {
		td->o.td_ddir |= TD_DDIR_WRITE;
		td->o.max_bs[DDIR_WRITE] = rw_bs[DDIR_WRITE];
	}
	if (ios[DDIR_TRIM]) {
		td->o.td_ddir |= TD_DDIR_TRIM;
		td->o.max_bs[DDIR_TRIM] = rw_bs[DDIR_TRIM];
	}

	/*
	 * We need to do direct/raw ios to the device, to avoid getting
	 * read-ahead in our way. But only do so if the minimum block size
	 * is a multiple of 4k, otherwise we don't know if it's safe to do so.
	 */
	if (!fio_option_is_set(&td->o, odirect) && !(td_min_bs(td) & 4095))
		td->o.odirect = 1;

	/*
	 * If depth wasn't manually set, use probed depth
	 */
	if (!fio_option_is_set(&td->o, iodepth))
		td->o.iodepth = td->o.iodepth_low = max_depth;

	return true;
err:
	close(fd);
	fifo_free(fifo);
	return false;
}

static int init_merge_param_list(fio_fp64_t *vals, struct blktrace_cursor *bcs,
				 int nr_logs, int def, size_t off)
{
	int i = 0, len = 0;

	while (len < FIO_IO_U_LIST_MAX_LEN && vals[len].u.f != 0.0)
		len++;

	if (len && len != nr_logs)
		return len;

	for (i = 0; i < nr_logs; i++) {
		int *val = (int *)((char *)&bcs[i] + off);
		*val = def;
		if (len)
			*val = (int)vals[i].u.f;
	}

	return 0;

}

static int find_earliest_io(struct blktrace_cursor *bcs, int nr_logs)
{
	__u64 time = ~(__u64)0;
	int idx = 0, i;

	for (i = 0; i < nr_logs; i++) {
		if (bcs[i].t.time < time) {
			time = bcs[i].t.time;
			idx = i;
		}
	}

	return idx;
}

static void merge_finish_file(struct blktrace_cursor *bcs, int i, int *nr_logs)
{
	bcs[i].iter++;
	if (bcs[i].iter < bcs[i].nr_iter) {
		lseek(bcs[i].fd, 0, SEEK_SET);
		return;
	}

	*nr_logs -= 1;

	/* close file */
	fifo_free(bcs[i].fifo);
	close(bcs[i].fd);

	/* keep active files contiguous */
	memmove(&bcs[i], &bcs[*nr_logs], sizeof(bcs[i]));
}

static int read_trace(struct thread_data *td, struct blktrace_cursor *bc)
{
	int ret = 0;
	struct blk_io_trace *t = &bc->t;

read_skip:
	/* read an io trace */
	ret = trace_fifo_get(td, bc->fifo, bc->fd, t, sizeof(*t));
	if (ret < 0) {
		return ret;
	} else if (!ret) {
		if (!bc->length)
			bc->length = bc->t.time;
		return ret;
	} else if (ret < (int) sizeof(*t)) {
		log_err("fio: short fifo get\n");
		return -1;
	}

	if (bc->swap)
		byteswap_trace(t);

	/* skip over actions that fio does not care about */
	if ((t->action & 0xffff) != __BLK_TA_QUEUE ||
	    t_get_ddir(t) == DDIR_INVAL) {
		ret = discard_pdu(td, bc->fifo, bc->fd, t);
		if (ret < 0) {
			td_verror(td, -ret, "blktrace lseek");
			return ret;
		} else if (t->pdu_len != ret) {
			log_err("fio: discarded %d of %d\n", ret,
				t->pdu_len);
			return -1;
		}
		goto read_skip;
	}

	t->time = (t->time + bc->iter * bc->length) * bc->scalar / 100;

	return ret;
}

static int write_trace(FILE *fp, struct blk_io_trace *t)
{
	/* pdu is not used so just write out only the io trace */
	t->pdu_len = 0;
	return fwrite((void *)t, sizeof(*t), 1, fp);
}

int merge_blktrace_iologs(struct thread_data *td)
{
	int nr_logs = get_max_str_idx(td->o.read_iolog_file);
	struct blktrace_cursor *bcs = malloc(sizeof(struct blktrace_cursor) *
					     nr_logs);
	struct blktrace_cursor *bc;
	FILE *merge_fp;
	char *str, *ptr, *name, *merge_buf;
	int i, ret;

	ret = init_merge_param_list(td->o.merge_blktrace_scalars, bcs, nr_logs,
				    100, offsetof(struct blktrace_cursor,
						  scalar));
	if (ret) {
		log_err("fio: merge_blktrace_scalars(%d) != nr_logs(%d)\n",
			ret, nr_logs);
		goto err_param;
	}

	ret = init_merge_param_list(td->o.merge_blktrace_iters, bcs, nr_logs,
				    1, offsetof(struct blktrace_cursor,
						nr_iter));
	if (ret) {
		log_err("fio: merge_blktrace_iters(%d) != nr_logs(%d)\n",
			ret, nr_logs);
		goto err_param;
	}

	/* setup output file */
	merge_fp = fopen(td->o.merge_blktrace_file, "w");
	merge_buf = malloc(128 * 1024);
	if (!merge_buf)
		goto err_out_file;
	ret = setvbuf(merge_fp, merge_buf, _IOFBF, 128 * 1024);
	if (ret)
		goto err_merge_buf;

	/* setup input files */
	str = ptr = strdup(td->o.read_iolog_file);
	nr_logs = 0;
	for (i = 0; (name = get_next_str(&ptr)) != NULL; i++) {
		bcs[i].fd = open(name, O_RDONLY);
		if (bcs[i].fd < 0) {
			log_err("fio: could not open file: %s\n", name);
			ret = bcs[i].fd;
			free(str);
			goto err_file;
		}
		bcs[i].fifo = fifo_alloc(TRACE_FIFO_SIZE);
		nr_logs++;

		if (!is_blktrace(name, &bcs[i].swap)) {
			log_err("fio: file is not a blktrace: %s\n", name);
			free(str);
			goto err_file;
		}

		ret = read_trace(td, &bcs[i]);
		if (ret < 0) {
			free(str);
			goto err_file;
		} else if (!ret) {
			merge_finish_file(bcs, i, &nr_logs);
			i--;
		}
	}
	free(str);

	/* merge files */
	while (nr_logs) {
		i = find_earliest_io(bcs, nr_logs);
		bc = &bcs[i];
		/* skip over the pdu */
		ret = discard_pdu(td, bc->fifo, bc->fd, &bc->t);
		if (ret < 0) {
			td_verror(td, -ret, "blktrace lseek");
			goto err_file;
		} else if (bc->t.pdu_len != ret) {
			log_err("fio: discarded %d of %d\n", ret,
				bc->t.pdu_len);
			goto err_file;
		}

		ret = write_trace(merge_fp, &bc->t);
		ret = read_trace(td, bc);
		if (ret < 0)
			goto err_file;
		else if (!ret)
			merge_finish_file(bcs, i, &nr_logs);
	}

	/* set iolog file to read from the newly merged file */
	td->o.read_iolog_file = td->o.merge_blktrace_file;
	ret = 0;

err_file:
	/* cleanup */
	for (i = 0; i < nr_logs; i++) {
		fifo_free(bcs[i].fifo);
		close(bcs[i].fd);
	}
err_merge_buf:
	free(merge_buf);
err_out_file:
	fflush(merge_fp);
	fclose(merge_fp);
err_param:
	free(bcs);

	return ret;
}
Commit	Line	Data
	1	/*
	2	* blktrace support code for fio
	3	*/
	4	#include <stdio.h>
	5	#include <stdlib.h>
	6	#include <unistd.h>
	7
	8	#include "flist.h"
	9	#include "fio.h"
	10	#include "blktrace.h"
	11	#include "blktrace_api.h"
	12	#include "oslib/linux-dev-lookup.h"
	13
	14	#define TRACE_FIFO_SIZE 8192
	15
	16	/*
	17	* fifo refill frontend, to avoid reading data in trace sized bites
	18	*/
	19	static int refill_fifo(struct thread_data td, struct fifo fifo, int fd)
	20	{
	21	char buf[TRACE_FIFO_SIZE];
	22	unsigned int total;
	23	int ret;
	24
	25	total = sizeof(buf);
	26	if (total > fifo_room(fifo))
	27	total = fifo_room(fifo);
	28
	29	ret = read(fd, buf, total);
	30	if (ret < 0) {
	31	int read_err = errno;
	32
	33	assert(read_err > 0);
	34	td_verror(td, read_err, "read blktrace file");
	35	return -read_err;
	36	}
	37
	38	if (ret > 0)
	39	ret = fifo_put(fifo, buf, ret);
	40
	41	dprint(FD_BLKTRACE, "refill: filled %d bytes\n", ret);
	42	return ret;
	43	}
	44
	45	/*
	46	* Retrieve 'len' bytes from the fifo, refilling if necessary.
	47	*/
	48	static int trace_fifo_get(struct thread_data td, struct fifo fifo, int fd,
	49	void *buf, unsigned int len)
	50	{
	51	if (fifo_len(fifo) < len) {
	52	int ret = refill_fifo(td, fifo, fd);
	53
	54	if (ret < 0)
	55	return ret;
	56	}
	57
	58	return fifo_get(fifo, buf, len);
	59	}
	60
	61	/*
	62	* Just discard the pdu by seeking past it.
	63	*/
	64	static int discard_pdu(struct thread_data td, struct fifo fifo, int fd,
	65	struct blk_io_trace *t)
	66	{
	67	if (t->pdu_len == 0)
	68	return 0;
	69
	70	dprint(FD_BLKTRACE, "discard pdu len %u\n", t->pdu_len);
	71	return trace_fifo_get(td, fifo, fd, NULL, t->pdu_len);
	72	}
	73
	74	/*
	75	* Check if this is a blktrace binary data file. We read a single trace
	76	* into memory and check for the magic signature.
	77	*/
	78	bool is_blktrace(const char filename, int need_swap)
	79	{
	80	struct blk_io_trace t;
	81	int fd, ret;
	82
	83	fd = open(filename, O_RDONLY);
	84	if (fd < 0)
	85	return false;
	86
	87	ret = read(fd, &t, sizeof(t));
	88	close(fd);
	89
	90	if (ret < 0) {
	91	perror("read blktrace");
	92	return false;
	93	} else if (ret != sizeof(t)) {
	94	log_err("fio: short read on blktrace file\n");
	95	return false;
	96	}
	97
	98	if ((t.magic & 0xffffff00) == BLK_IO_TRACE_MAGIC) {
	99	*need_swap = 0;
	100	return true;
	101	}
	102
	103	/*
	104	* Maybe it needs to be endian swapped...
	105	*/
	106	t.magic = fio_swap32(t.magic);
	107	if ((t.magic & 0xffffff00) == BLK_IO_TRACE_MAGIC) {
	108	*need_swap = 1;
	109	return true;
	110	}
	111
	112	return false;
	113	}
	114
	115	#define FMINORBITS 20
	116	#define FMINORMASK ((1U << FMINORBITS) - 1)
	117	#define FMAJOR(dev) ((unsigned int) ((dev) >> FMINORBITS))
	118	#define FMINOR(dev) ((unsigned int) ((dev) & FMINORMASK))
	119
	120	static void trace_add_open_close_event(struct thread_data *td, int fileno, enum file_log_act action)
	121	{
	122	struct io_piece *ipo;
	123
	124	ipo = calloc(1, sizeof(*ipo));
	125	init_ipo(ipo);
	126
	127	ipo->ddir = DDIR_INVAL;
	128	ipo->fileno = fileno;
	129	ipo->file_action = action;
	130	flist_add_tail(&ipo->list, &td->io_log_list);
	131	}
	132
	133	static int trace_add_file(struct thread_data *td, __u32 device)
	134	{
	135	static unsigned int last_maj, last_min, last_fileno;
	136	unsigned int maj = FMAJOR(device);
	137	unsigned int min = FMINOR(device);
	138	struct fio_file *f;
	139	char dev[256];
	140	unsigned int i;
	141
	142	if (last_maj == maj && last_min == min)
	143	return last_fileno;
	144
	145	last_maj = maj;
	146	last_min = min;
	147
	148	/*
	149	* check for this file in our list
	150	*/
	151	for_each_file(td, f, i)
	152	if (f->major == maj && f->minor == min) {
	153	last_fileno = f->fileno;
	154	return last_fileno;
	155	}
	156
	157	strcpy(dev, "/dev");
	158	if (blktrace_lookup_device(td->o.replay_redirect, dev, maj, min)) {
	159	int fileno;
	160
	161	if (td->o.replay_redirect)
	162	dprint(FD_BLKTRACE, "device lookup: %d/%d\n overridden"
	163	" with: %s\n", maj, min,
	164	td->o.replay_redirect);
	165	else
	166	dprint(FD_BLKTRACE, "device lookup: %d/%d\n", maj, min);
	167
	168	dprint(FD_BLKTRACE, "add devices %s\n", dev);
	169	fileno = add_file_exclusive(td, dev);
	170	td->o.open_files++;
	171	td->files[fileno]->major = maj;
	172	td->files[fileno]->minor = min;
	173	trace_add_open_close_event(td, fileno, FIO_LOG_OPEN_FILE);
	174	last_fileno = fileno;
	175	}
	176
	177	return last_fileno;
	178	}
	179
	180	static void t_bytes_align(struct thread_options o, struct blk_io_trace t)
	181	{
	182	if (!o->replay_align)
	183	return;
	184
	185	t->bytes = (t->bytes + o->replay_align - 1) & ~(o->replay_align - 1);
	186	}
	187
	188	/*
	189	* Store blk_io_trace data in an ipo for later retrieval.
	190	*/
	191	static void store_ipo(struct thread_data *td, unsigned long long offset,
	192	unsigned int bytes, int rw, unsigned long long ttime,
	193	int fileno)
	194	{
	195	struct io_piece *ipo;
	196
	197	ipo = calloc(1, sizeof(*ipo));
	198	init_ipo(ipo);
	199
	200	ipo->offset = offset * 512;
	201	if (td->o.replay_scale)
	202	ipo->offset = ipo->offset / td->o.replay_scale;
	203	ipo_bytes_align(td->o.replay_align, ipo);
	204	ipo->len = bytes;
	205	ipo->delay = ttime / 1000;
	206	if (rw)
	207	ipo->ddir = DDIR_WRITE;
	208	else
	209	ipo->ddir = DDIR_READ;
	210	ipo->fileno = fileno;
	211
	212	dprint(FD_BLKTRACE, "store ddir=%d, off=%llu, len=%lu, delay=%lu\n",
	213	ipo->ddir, ipo->offset,
	214	ipo->len, ipo->delay);
	215	queue_io_piece(td, ipo);
	216	}
	217
	218	static void handle_trace_notify(struct blk_io_trace *t)
	219	{
	220	switch (t->action) {
	221	case BLK_TN_PROCESS:
	222	dprint(FD_BLKTRACE, "got process notify: %x, %d\n",
	223	t->action, t->pid);
	224	break;
	225	case BLK_TN_TIMESTAMP:
	226	dprint(FD_BLKTRACE, "got timestamp notify: %x, %d\n",
	227	t->action, t->pid);
	228	break;
	229	case BLK_TN_MESSAGE:
	230	break;
	231	default:
	232	dprint(FD_BLKTRACE, "unknown trace act %x\n", t->action);
	233	break;
	234	}
	235	}
	236
	237	static void handle_trace_discard(struct thread_data *td,
	238	struct blk_io_trace *t,
	239	unsigned long long ttime,
	240	unsigned long ios, unsigned int bs)
	241	{
	242	struct io_piece *ipo;
	243	int fileno;
	244
	245	if (td->o.replay_skip & (1u << DDIR_TRIM))
	246	return;
	247
	248	ipo = calloc(1, sizeof(*ipo));
	249	init_ipo(ipo);
	250	fileno = trace_add_file(td, t->device);
	251
	252	ios[DDIR_TRIM]++;
	253	if (t->bytes > bs[DDIR_TRIM])
	254	bs[DDIR_TRIM] = t->bytes;
	255
	256	td->o.size += t->bytes;
	257
	258	INIT_FLIST_HEAD(&ipo->list);
	259
	260	ipo->offset = t->sector * 512;
	261	if (td->o.replay_scale)
	262	ipo->offset = ipo->offset / td->o.replay_scale;
	263	ipo_bytes_align(td->o.replay_align, ipo);
	264	ipo->len = t->bytes;
	265	ipo->delay = ttime / 1000;
	266	ipo->ddir = DDIR_TRIM;
	267	ipo->fileno = fileno;
	268
	269	dprint(FD_BLKTRACE, "store discard, off=%llu, len=%lu, delay=%lu\n",
	270	ipo->offset, ipo->len,
	271	ipo->delay);
	272	queue_io_piece(td, ipo);
	273	}
	274
	275	static void dump_trace(struct blk_io_trace *t)
	276	{
	277	log_err("blktrace: ignoring zero byte trace: action=%x\n", t->action);
	278	}
	279
	280	static void handle_trace_fs(struct thread_data td, struct blk_io_trace t,
	281	unsigned long long ttime, unsigned long *ios,
	282	unsigned int *bs)
	283	{
	284	int rw;
	285	int fileno;
	286
	287	fileno = trace_add_file(td, t->device);
	288
	289	rw = (t->action & BLK_TC_ACT(BLK_TC_WRITE)) != 0;
	290
	291	if (rw) {
	292	if (td->o.replay_skip & (1u << DDIR_WRITE))
	293	return;
	294	} else {
	295	if (td->o.replay_skip & (1u << DDIR_READ))
	296	return;
	297	}
	298
	299	if (!t->bytes) {
	300	if (!fio_did_warn(FIO_WARN_BTRACE_ZERO))
	301	dump_trace(t);
	302	return;
	303	}
	304
	305	if (t->bytes > bs[rw])
	306	bs[rw] = t->bytes;
	307
	308	ios[rw]++;
	309	td->o.size += t->bytes;
	310	store_ipo(td, t->sector, t->bytes, rw, ttime, fileno);
	311	}
	312
	313	static void handle_trace_flush(struct thread_data td, struct blk_io_trace t,
	314	unsigned long long ttime, unsigned long *ios)
	315	{
	316	struct io_piece *ipo;
	317	int fileno;
	318
	319	if (td->o.replay_skip & (1u << DDIR_SYNC))
	320	return;
	321
	322	ipo = calloc(1, sizeof(*ipo));
	323	init_ipo(ipo);
	324	fileno = trace_add_file(td, t->device);
	325
	326	ipo->delay = ttime / 1000;
	327	ipo->ddir = DDIR_SYNC;
	328	ipo->fileno = fileno;
	329
	330	ios[DDIR_SYNC]++;
	331	dprint(FD_BLKTRACE, "store flush delay=%lu\n", ipo->delay);
	332	queue_io_piece(td, ipo);
	333	}
	334
	335	/*
	336	* We only care for queue traces, most of the others are side effects
	337	* due to internal workings of the block layer.
	338	*/
	339	static void handle_trace(struct thread_data td, struct blk_io_trace t,
	340	unsigned long ios, unsigned int bs)
	341	{
	342	static unsigned long long last_ttime;
	343	unsigned long long delay = 0;
	344
	345	if ((t->action & 0xffff) != __BLK_TA_QUEUE)
	346	return;
	347
	348	if (!(t->action & BLK_TC_ACT(BLK_TC_NOTIFY))) {
	349	if (!last_ttime \|\| td->o.no_stall)
	350	delay = 0;
	351	else if (td->o.replay_time_scale == 100)
	352	delay = t->time - last_ttime;
	353	else {
	354	double tmp = t->time - last_ttime;
	355	double scale;
	356
	357	scale = (double) 100.0 / (double) td->o.replay_time_scale;
	358	tmp *= scale;
	359	delay = tmp;
	360	}
	361	last_ttime = t->time;
	362	}
	363
	364	t_bytes_align(&td->o, t);
	365
	366	if (t->action & BLK_TC_ACT(BLK_TC_NOTIFY))
	367	handle_trace_notify(t);
	368	else if (t->action & BLK_TC_ACT(BLK_TC_DISCARD))
	369	handle_trace_discard(td, t, delay, ios, bs);
	370	else if (t->action & BLK_TC_ACT(BLK_TC_FLUSH))
	371	handle_trace_flush(td, t, delay, ios);
	372	else
	373	handle_trace_fs(td, t, delay, ios, bs);
	374	}
	375
	376	static void byteswap_trace(struct blk_io_trace *t)
	377	{
	378	t->magic = fio_swap32(t->magic);
	379	t->sequence = fio_swap32(t->sequence);
	380	t->time = fio_swap64(t->time);
	381	t->sector = fio_swap64(t->sector);
	382	t->bytes = fio_swap32(t->bytes);
	383	t->action = fio_swap32(t->action);
	384	t->pid = fio_swap32(t->pid);
	385	t->device = fio_swap32(t->device);
	386	t->cpu = fio_swap32(t->cpu);
	387	t->error = fio_swap16(t->error);
	388	t->pdu_len = fio_swap16(t->pdu_len);
	389	}
	390
	391	static bool t_is_write(struct blk_io_trace *t)
	392	{
	393	return (t->action & BLK_TC_ACT(BLK_TC_WRITE \| BLK_TC_DISCARD)) != 0;
	394	}
	395
	396	static enum fio_ddir t_get_ddir(struct blk_io_trace *t)
	397	{
	398	if (t->action & BLK_TC_ACT(BLK_TC_READ))
	399	return DDIR_READ;
	400	else if (t->action & BLK_TC_ACT(BLK_TC_WRITE))
	401	return DDIR_WRITE;
	402	else if (t->action & BLK_TC_ACT(BLK_TC_DISCARD))
	403	return DDIR_TRIM;
	404
	405	return DDIR_INVAL;
	406	}
	407
	408	static void depth_inc(struct blk_io_trace t, int depth)
	409	{
	410	enum fio_ddir ddir;
	411
	412	ddir = t_get_ddir(t);
	413	if (ddir != DDIR_INVAL)
	414	depth[ddir]++;
	415	}
	416
	417	static void depth_dec(struct blk_io_trace t, int depth)
	418	{
	419	enum fio_ddir ddir;
	420
	421	ddir = t_get_ddir(t);
	422	if (ddir != DDIR_INVAL)
	423	depth[ddir]--;
	424	}
	425
	426	static void depth_end(struct blk_io_trace t, int this_depth, int *depth)
	427	{
	428	enum fio_ddir ddir = DDIR_INVAL;
	429
	430	ddir = t_get_ddir(t);
	431	if (ddir != DDIR_INVAL) {
	432	depth[ddir] = max(depth[ddir], this_depth[ddir]);
	433	this_depth[ddir] = 0;
	434	}
	435	}
	436
	437	/*
	438	* Load a blktrace file by reading all the blk_io_trace entries, and storing
	439	* them as io_pieces like the fio text version would do.
	440	*/
	441	bool load_blktrace(struct thread_data td, const char filename, int need_swap)
	442	{
	443	struct blk_io_trace t;
	444	unsigned long ios[DDIR_RWDIR_SYNC_CNT] = { };
	445	unsigned int rw_bs[DDIR_RWDIR_CNT] = { };
	446	unsigned long skipped_writes;
	447	struct fifo *fifo;
	448	int fd, i, old_state, max_depth;
	449	struct fio_file *f;
	450	int this_depth[DDIR_RWDIR_CNT] = { };
	451	int depth[DDIR_RWDIR_CNT] = { };
	452
	453	fd = open(filename, O_RDONLY);
	454	if (fd < 0) {
	455	td_verror(td, errno, "open blktrace file");
	456	return false;
	457	}
	458
	459	fifo = fifo_alloc(TRACE_FIFO_SIZE);
	460
	461	old_state = td_bump_runstate(td, TD_SETTING_UP);
	462
	463	td->o.size = 0;
	464	skipped_writes = 0;
	465	do {
	466	int ret = trace_fifo_get(td, fifo, fd, &t, sizeof(t));
	467
	468	if (ret < 0)
	469	goto err;
	470	else if (!ret)
	471	break;
	472	else if (ret < (int) sizeof(t)) {
	473	log_err("fio: short fifo get\n");
	474	break;
	475	}
	476
	477	if (need_swap)
	478	byteswap_trace(&t);
	479
	480	if ((t.magic & 0xffffff00) != BLK_IO_TRACE_MAGIC) {
	481	log_err("fio: bad magic in blktrace data: %x\n",
	482	t.magic);
	483	goto err;
	484	}
	485	if ((t.magic & 0xff) != BLK_IO_TRACE_VERSION) {
	486	log_err("fio: bad blktrace version %d\n",
	487	t.magic & 0xff);
	488	goto err;
	489	}
	490	ret = discard_pdu(td, fifo, fd, &t);
	491	if (ret < 0) {
	492	td_verror(td, -ret, "blktrace lseek");
	493	goto err;
	494	} else if (t.pdu_len != ret) {
	495	log_err("fio: discarded %d of %d\n", ret, t.pdu_len);
	496	goto err;
	497	}
	498	if ((t.action & BLK_TC_ACT(BLK_TC_NOTIFY)) == 0) {
	499	if ((t.action & 0xffff) == __BLK_TA_QUEUE)
	500	depth_inc(&t, this_depth);
	501	else if (((t.action & 0xffff) == __BLK_TA_BACKMERGE) \|\|
	502	((t.action & 0xffff) == __BLK_TA_FRONTMERGE))
	503	depth_dec(&t, this_depth);
	504	else if ((t.action & 0xffff) == __BLK_TA_COMPLETE)
	505	depth_end(&t, this_depth, depth);
	506
	507	if (t_is_write(&t) && read_only) {
	508	skipped_writes++;
	509	continue;
	510	}
	511	}
	512
	513	handle_trace(td, &t, ios, rw_bs);
	514	} while (1);
	515
	516	for_each_file(td, f, i)
	517	trace_add_open_close_event(td, f->fileno, FIO_LOG_CLOSE_FILE);
	518
	519	fifo_free(fifo);
	520	close(fd);
	521
	522	td_restore_runstate(td, old_state);
	523
	524	if (!td->files_index) {
	525	log_err("fio: did not find replay device(s)\n");
	526	return false;
	527	}
	528
	529	/*
	530	* For stacked devices, we don't always get a COMPLETE event so
	531	* the depth grows to insane values. Limit it to something sane(r).
	532	*/
	533	max_depth = 0;
	534	for (i = 0; i < DDIR_RWDIR_CNT; i++) {
	535	if (depth[i] > 1024)
	536	depth[i] = 1024;
	537	else if (!depth[i] && ios[i])
	538	depth[i] = 1;
	539	max_depth = max(depth[i], max_depth);
	540	}
	541
	542	if (skipped_writes)
	543	log_err("fio: %s skips replay of %lu writes due to read-only\n",
	544	td->o.name, skipped_writes);
	545
	546	if (!ios[DDIR_READ] && !ios[DDIR_WRITE] && !ios[DDIR_TRIM] &&
	547	!ios[DDIR_SYNC]) {
	548	log_err("fio: found no ios in blktrace data\n");
	549	return false;
	550	}
	551
	552	td->o.td_ddir = 0;
	553	if (ios[DDIR_READ]) {
	554	td->o.td_ddir \|= TD_DDIR_READ;
	555	td->o.max_bs[DDIR_READ] = rw_bs[DDIR_READ];
	556	}
	557	if (ios[DDIR_WRITE]) {
	558	td->o.td_ddir \|= TD_DDIR_WRITE;
	559	td->o.max_bs[DDIR_WRITE] = rw_bs[DDIR_WRITE];
	560	}
	561	if (ios[DDIR_TRIM]) {
	562	td->o.td_ddir \|= TD_DDIR_TRIM;
	563	td->o.max_bs[DDIR_TRIM] = rw_bs[DDIR_TRIM];
	564	}
	565
	566	/*
	567	* We need to do direct/raw ios to the device, to avoid getting
	568	* read-ahead in our way. But only do so if the minimum block size
	569	* is a multiple of 4k, otherwise we don't know if it's safe to do so.
	570	*/
	571	if (!fio_option_is_set(&td->o, odirect) && !(td_min_bs(td) & 4095))
	572	td->o.odirect = 1;
	573
	574	/*
	575	* If depth wasn't manually set, use probed depth
	576	*/
	577	if (!fio_option_is_set(&td->o, iodepth))
	578	td->o.iodepth = td->o.iodepth_low = max_depth;
	579
	580	return true;
	581	err:
	582	close(fd);
	583	fifo_free(fifo);
	584	return false;
	585	}
	586
	587	static int init_merge_param_list(fio_fp64_t vals, struct blktrace_cursor bcs,
	588	int nr_logs, int def, size_t off)
	589	{
	590	int i = 0, len = 0;
	591
	592	while (len < FIO_IO_U_LIST_MAX_LEN && vals[len].u.f != 0.0)
	593	len++;
	594
	595	if (len && len != nr_logs)
	596	return len;
	597
	598	for (i = 0; i < nr_logs; i++) {
	599	int val = (int )((char *)&bcs[i] + off);
	600	*val = def;
	601	if (len)
	602	*val = (int)vals[i].u.f;
	603	}
	604
	605	return 0;
	606
	607	}
	608
	609	static int find_earliest_io(struct blktrace_cursor *bcs, int nr_logs)
	610	{
	611	__u64 time = ~(__u64)0;
	612	int idx = 0, i;
	613
	614	for (i = 0; i < nr_logs; i++) {
	615	if (bcs[i].t.time < time) {
	616	time = bcs[i].t.time;
	617	idx = i;
	618	}
	619	}
	620
	621	return idx;
	622	}
	623
	624	static void merge_finish_file(struct blktrace_cursor bcs, int i, int nr_logs)
	625	{
	626	bcs[i].iter++;
	627	if (bcs[i].iter < bcs[i].nr_iter) {
	628	lseek(bcs[i].fd, 0, SEEK_SET);
	629	return;
	630	}
	631
	632	*nr_logs -= 1;
	633
	634	/* close file */
	635	fifo_free(bcs[i].fifo);
	636	close(bcs[i].fd);
	637
	638	/* keep active files contiguous */
	639	memmove(&bcs[i], &bcs[*nr_logs], sizeof(bcs[i]));
	640	}
	641
	642	static int read_trace(struct thread_data td, struct blktrace_cursor bc)
	643	{
	644	int ret = 0;
	645	struct blk_io_trace *t = &bc->t;
	646
	647	read_skip:
	648	/* read an io trace */
	649	ret = trace_fifo_get(td, bc->fifo, bc->fd, t, sizeof(*t));
	650	if (ret < 0) {
	651	return ret;
	652	} else if (!ret) {
	653	if (!bc->length)
	654	bc->length = bc->t.time;
	655	return ret;
	656	} else if (ret < (int) sizeof(*t)) {
	657	log_err("fio: short fifo get\n");
	658	return -1;
	659	}
	660
	661	if (bc->swap)
	662	byteswap_trace(t);
	663
	664	/* skip over actions that fio does not care about */
	665	if ((t->action & 0xffff) != __BLK_TA_QUEUE \|\|
	666	t_get_ddir(t) == DDIR_INVAL) {
	667	ret = discard_pdu(td, bc->fifo, bc->fd, t);
	668	if (ret < 0) {
	669	td_verror(td, -ret, "blktrace lseek");
	670	return ret;
	671	} else if (t->pdu_len != ret) {
	672	log_err("fio: discarded %d of %d\n", ret,
	673	t->pdu_len);
	674	return -1;
	675	}
	676	goto read_skip;
	677	}
	678
	679	t->time = (t->time + bc->iter * bc->length) * bc->scalar / 100;
	680
	681	return ret;
	682	}
	683
	684	static int write_trace(FILE fp, struct blk_io_trace t)
	685	{
	686	/* pdu is not used so just write out only the io trace */
	687	t->pdu_len = 0;
	688	return fwrite((void )t, sizeof(t), 1, fp);
	689	}
	690
	691	int merge_blktrace_iologs(struct thread_data *td)
	692	{
	693	int nr_logs = get_max_str_idx(td->o.read_iolog_file);
	694	struct blktrace_cursor bcs = malloc(sizeof(struct blktrace_cursor)
	695	nr_logs);
	696	struct blktrace_cursor *bc;
	697	FILE *merge_fp;
	698	char str, ptr, name, merge_buf;
	699	int i, ret;
	700
	701	ret = init_merge_param_list(td->o.merge_blktrace_scalars, bcs, nr_logs,
	702	100, offsetof(struct blktrace_cursor,
	703	scalar));
	704	if (ret) {
	705	log_err("fio: merge_blktrace_scalars(%d) != nr_logs(%d)\n",
	706	ret, nr_logs);
	707	goto err_param;
	708	}
	709
	710	ret = init_merge_param_list(td->o.merge_blktrace_iters, bcs, nr_logs,
	711	1, offsetof(struct blktrace_cursor,
	712	nr_iter));
	713	if (ret) {
	714	log_err("fio: merge_blktrace_iters(%d) != nr_logs(%d)\n",
	715	ret, nr_logs);
	716	goto err_param;
	717	}
	718
	719	/* setup output file */
	720	merge_fp = fopen(td->o.merge_blktrace_file, "w");
	721	merge_buf = malloc(128 * 1024);
	722	if (!merge_buf)
	723	goto err_out_file;
	724	ret = setvbuf(merge_fp, merge_buf, _IOFBF, 128 * 1024);
	725	if (ret)
	726	goto err_merge_buf;
	727
	728	/* setup input files */
	729	str = ptr = strdup(td->o.read_iolog_file);
	730	nr_logs = 0;
	731	for (i = 0; (name = get_next_str(&ptr)) != NULL; i++) {
	732	bcs[i].fd = open(name, O_RDONLY);
	733	if (bcs[i].fd < 0) {
	734	log_err("fio: could not open file: %s\n", name);
	735	ret = bcs[i].fd;
	736	free(str);
	737	goto err_file;
	738	}
	739	bcs[i].fifo = fifo_alloc(TRACE_FIFO_SIZE);
	740	nr_logs++;
	741
	742	if (!is_blktrace(name, &bcs[i].swap)) {
	743	log_err("fio: file is not a blktrace: %s\n", name);
	744	free(str);
	745	goto err_file;
	746	}
	747
	748	ret = read_trace(td, &bcs[i]);
	749	if (ret < 0) {
	750	free(str);
	751	goto err_file;
	752	} else if (!ret) {
	753	merge_finish_file(bcs, i, &nr_logs);
	754	i--;
	755	}
	756	}
	757	free(str);
	758
	759	/* merge files */
	760	while (nr_logs) {
	761	i = find_earliest_io(bcs, nr_logs);
	762	bc = &bcs[i];
	763	/* skip over the pdu */
	764	ret = discard_pdu(td, bc->fifo, bc->fd, &bc->t);
	765	if (ret < 0) {
	766	td_verror(td, -ret, "blktrace lseek");
	767	goto err_file;
	768	} else if (bc->t.pdu_len != ret) {
	769	log_err("fio: discarded %d of %d\n", ret,
	770	bc->t.pdu_len);
	771	goto err_file;
	772	}
	773
	774	ret = write_trace(merge_fp, &bc->t);
	775	ret = read_trace(td, bc);
	776	if (ret < 0)
	777	goto err_file;
	778	else if (!ret)
	779	merge_finish_file(bcs, i, &nr_logs);
	780	}
	781
	782	/* set iolog file to read from the newly merged file */
	783	td->o.read_iolog_file = td->o.merge_blktrace_file;
	784	ret = 0;
	785
	786	err_file:
	787	/* cleanup */
	788	for (i = 0; i < nr_logs; i++) {
	789	fifo_free(bcs[i].fifo);
	790	close(bcs[i].fd);
	791	}
	792	err_merge_buf:
	793	free(merge_buf);
	794	err_out_file:
	795	fflush(merge_fp);
	796	fclose(merge_fp);
	797	err_param:
	798	free(bcs);
	799
	800	return ret;
	801	}