#include "verify.h"
#include "trim.h"
#include "filelock.h"
-#include "lib/tp.h"
static const char iolog_ver2[] = "fio version 2 iolog";
td->total_io_size += ipo->len;
}
-void log_io_u(struct thread_data *td, struct io_u *io_u)
+void log_io_u(const struct thread_data *td, const struct io_u *io_u)
{
if (!td->o.write_iolog_file)
return;
static void iolog_delay(struct thread_data *td, unsigned long delay)
{
- unsigned long usec = utime_since_now(&td->last_issue);
- unsigned long this_delay;
+ uint64_t usec = utime_since_now(&td->last_issue);
+ uint64_t this_delay;
+ struct timeval tv;
+ if (delay < td->time_offset) {
+ td->time_offset = 0;
+ return;
+ }
+
+ delay -= td->time_offset;
if (delay < usec)
return;
delay -= usec;
+ fio_gettime(&tv, NULL);
while (delay && !td->terminate) {
this_delay = delay;
if (this_delay > 500000)
usec_sleep(td, this_delay);
delay -= this_delay;
}
+
+ usec = utime_since_now(&tv);
+ if (usec > delay)
+ td->time_offset = usec - delay;
+ else
+ td->time_offset = 0;
}
static int ipo_special(struct thread_data *td, struct io_piece *ipo)
}
while (!flist_empty(&td->io_hist_list)) {
- ipo = flist_entry(&td->io_hist_list, struct io_piece, list);
+ ipo = flist_first_entry(&td->io_hist_list, struct io_piece, list);
flist_del(&ipo->list);
remove_trim_entry(td, ipo);
td->io_hist_len--;
p = &td->io_hist_tree.rb_node;
parent = NULL;
while (*p) {
+ int overlap = 0;
parent = *p;
__ipo = rb_entry(parent, struct io_piece, rb_node);
p = &(*p)->rb_left;
else if (ipo->file > __ipo->file)
p = &(*p)->rb_right;
- else if (ipo->offset < __ipo->offset)
+ else if (ipo->offset < __ipo->offset) {
p = &(*p)->rb_left;
- else if (ipo->offset > __ipo->offset)
+ overlap = ipo->offset + ipo->len > __ipo->offset;
+ }
+ else if (ipo->offset > __ipo->offset) {
p = &(*p)->rb_right;
- else {
+ overlap = __ipo->offset + __ipo->len > ipo->offset;
+ }
+ else
+ overlap = 1;
+
+ if (overlap) {
dprint(FD_IO, "iolog: overlap %llu/%lu, %llu/%lu",
__ipo->offset, __ipo->len,
ipo->offset, ipo->len);
{
struct io_piece *ipo = io_u->ipo;
+ if (td->ts.nr_block_infos) {
+ uint32_t *info = io_u_block_info(td, io_u);
+ if (BLOCK_INFO_STATE(*info) < BLOCK_STATE_TRIM_FAILURE) {
+ if (io_u->ddir == DDIR_TRIM)
+ *info = BLOCK_INFO_SET_STATE(*info,
+ BLOCK_STATE_TRIM_FAILURE);
+ else if (io_u->ddir == DDIR_WRITE)
+ *info = BLOCK_INFO_SET_STATE(*info,
+ BLOCK_STATE_WRITE_FAILURE);
+ }
+ }
+
if (!ipo)
return;
td->io_hist_len--;
}
-void trim_io_piece(struct thread_data *td, struct io_u *io_u)
+void trim_io_piece(struct thread_data *td, const struct io_u *io_u)
{
struct io_piece *ipo = io_u->ipo;
void setup_log(struct io_log **log, struct log_params *p,
const char *filename)
{
- struct io_log *l = malloc(sizeof(*l));
+ struct io_log *l;
- memset(l, 0, sizeof(*l));
+ l = calloc(1, sizeof(*l));
l->nr_samples = 0;
l->max_samples = 1024;
l->log_type = p->log_type;
if (l->log_gz && !p->td)
l->log_gz = 0;
- else if (l->log_gz) {
+ else if (l->log_gz || l->log_gz_store) {
pthread_mutex_init(&l->chunk_lock, NULL);
p->td->flags |= TD_F_COMPRESS_LOG;
}
free(log);
}
-static void flush_samples(FILE *f, void *samples, uint64_t sample_size)
+void flush_samples(FILE *f, void *samples, uint64_t sample_size)
{
struct io_sample *s;
int log_offset;
#ifdef CONFIG_ZLIB
struct iolog_flush_data {
- struct tp_work work;
+ struct workqueue_work work;
+ pthread_mutex_t lock;
+ pthread_cond_t cv;
+ int wait;
+ volatile int done;
+ volatile int refs;
struct io_log *log;
void *samples;
uint64_t nr_samples;
};
-struct iolog_compress {
- struct flist_head list;
- void *buf;
- size_t len;
- unsigned int seq;
-};
-
#define GZ_CHUNK 131072
static struct iolog_compress *get_new_chunk(unsigned int seq)
if (ret < 0) {
perror("fread");
fclose(f);
+ free(buf);
return 1;
} else if (ret != 1) {
log_err("fio: short read on reading log\n");
fclose(f);
+ free(buf);
return 1;
}
*/
total = ic.len;
do {
- size_t ret;
+ size_t iret;
- ret = inflate_chunk(&ic, 1, stdout, &stream, &iter);
- total -= ret;
+ iret = inflate_chunk(&ic, 1, stdout, &stream, &iter);
+ total -= iret;
if (!total)
break;
if (iter.err)
break;
ic.seq++;
- ic.len -= ret;
- ic.buf += ret;
+ ic.len -= iret;
+ ic.buf += iret;
} while (1);
if (iter.seq) {
#endif
-void flush_log(struct io_log *log)
+void flush_log(struct io_log *log, int do_append)
{
void *buf;
FILE *f;
- f = fopen(log->filename, "w");
+ if (!do_append)
+ f = fopen(log->filename, "w");
+ else
+ f = fopen(log->filename, "a");
if (!f) {
perror("fopen log");
return;
static int finish_log(struct thread_data *td, struct io_log *log, int trylock)
{
- if (td->tp_data)
+ if (td->flags & TD_F_COMPRESS_LOG)
iolog_flush(log, 1);
if (trylock) {
} else
fio_lock_file(log->filename);
- if (td->client_type == FIO_CLIENT_TYPE_GUI)
+ if (td->client_type == FIO_CLIENT_TYPE_GUI || is_backend)
fio_send_iolog(td, log, log->filename);
else
- flush_log(log);
+ flush_log(log, !td->o.per_job_logs);
fio_unlock_file(log->filename);
free_log(log);
return 0;
}
+size_t log_chunk_sizes(struct io_log *log)
+{
+ struct flist_head *entry;
+ size_t ret;
+
+ if (flist_empty(&log->chunk_list))
+ return 0;
+
+ ret = 0;
+ pthread_mutex_lock(&log->chunk_lock);
+ flist_for_each(entry, &log->chunk_list) {
+ struct iolog_compress *c;
+
+ c = flist_entry(entry, struct iolog_compress, list);
+ ret += c->len;
+ }
+ pthread_mutex_unlock(&log->chunk_lock);
+ return ret;
+}
+
#ifdef CONFIG_ZLIB
+static void drop_data_unlock(struct iolog_flush_data *data)
+{
+ int refs;
+
+ refs = --data->refs;
+ pthread_mutex_unlock(&data->lock);
+
+ if (!refs) {
+ free(data);
+ pthread_mutex_destroy(&data->lock);
+ pthread_cond_destroy(&data->cv);
+ }
+}
+
/*
* Invoked from our compress helper thread, when logging would have exceeded
* the specified memory limitation. Compresses the previously stored
* entries.
*/
-static int gz_work(struct tp_work *work)
+static int gz_work(struct submit_worker *sw, struct workqueue_work *work)
{
struct iolog_flush_data *data;
struct iolog_compress *c;
ret = 0;
done:
- if (work->wait) {
- work->done = 1;
- pthread_cond_signal(&work->cv);
+ if (data->wait) {
+ pthread_mutex_lock(&data->lock);
+ data->done = 1;
+ pthread_cond_signal(&data->cv);
+
+ drop_data_unlock(data);
} else
free(data);
-
return ret;
err:
while (!flist_empty(&list)) {
goto done;
}
+static int gz_init_worker(struct submit_worker *sw)
+{
+ struct thread_data *td = sw->wq->td;
+
+ if (!fio_option_is_set(&td->o, log_gz_cpumask))
+ return 0;
+
+ if (fio_setaffinity(gettid(), td->o.log_gz_cpumask) == -1) {
+ log_err("gz: failed to set CPU affinity\n");
+ return 1;
+ }
+
+ return 0;
+}
+
+static struct workqueue_ops log_compress_wq_ops = {
+ .fn = gz_work,
+ .init_worker_fn = gz_init_worker,
+ .nice = 1,
+};
+
+int iolog_compress_init(struct thread_data *td, struct sk_out *sk_out)
+{
+ if (!(td->flags & TD_F_COMPRESS_LOG))
+ return 0;
+
+ workqueue_init(td, &td->log_compress_wq, &log_compress_wq_ops, 1, sk_out);
+ return 0;
+}
+
+void iolog_compress_exit(struct thread_data *td)
+{
+ if (!(td->flags & TD_F_COMPRESS_LOG))
+ return;
+
+ workqueue_exit(&td->log_compress_wq);
+}
+
/*
- * Queue work item to compress the existing log entries. We copy the
- * samples, and reset the log sample count to 0 (so the logging will
- * continue to use the memory associated with the log). If called with
- * wait == 1, will not return until the log compression has completed.
+ * Queue work item to compress the existing log entries. We reset the
+ * current log to a small size, and reference the existing log in the
+ * data that we queue for compression. Once compression has been done,
+ * this old log is freed. If called with wait == 1, will not return until
+ * the log compression has completed.
*/
int iolog_flush(struct io_log *log, int wait)
{
- struct tp_data *tdat = log->td->tp_data;
struct iolog_flush_data *data;
- size_t sample_size;
+
+ io_u_quiesce(log->td);
data = malloc(sizeof(*data));
if (!data)
data->log = log;
- sample_size = log->nr_samples * log_entry_sz(log);
- data->samples = malloc(sample_size);
- if (!data->samples) {
- free(data);
- return 1;
- }
-
- memcpy(data->samples, log->log, sample_size);
+ data->samples = log->log;
data->nr_samples = log->nr_samples;
- data->work.fn = gz_work;
- log->nr_samples = 0;
- if (wait) {
- pthread_mutex_init(&data->work.lock, NULL);
- pthread_cond_init(&data->work.cv, NULL);
- data->work.wait = 1;
- } else
- data->work.wait = 0;
+ log->nr_samples = 0;
+ log->max_samples = 128;
+ log->log = malloc(log->max_samples * log_entry_sz(log));
+
+ data->wait = wait;
+ if (data->wait) {
+ pthread_mutex_init(&data->lock, NULL);
+ pthread_cond_init(&data->cv, NULL);
+ data->done = 0;
+ data->refs = 2;
+ }
- data->work.prio = 1;
- tp_queue_work(tdat, &data->work);
+ workqueue_enqueue(&log->td->log_compress_wq, &data->work);
if (wait) {
- pthread_mutex_lock(&data->work.lock);
- while (!data->work.done)
- pthread_cond_wait(&data->work.cv, &data->work.lock);
- pthread_mutex_unlock(&data->work.lock);
- free(data);
+ pthread_mutex_lock(&data->lock);
+ while (!data->done)
+ pthread_cond_wait(&data->cv, &data->lock);
+
+ drop_data_unlock(data);
}
return 0;
return 1;
}
+int iolog_compress_init(struct thread_data *td, struct sk_out *sk_out)
+{
+ return 0;
+}
+
+void iolog_compress_exit(struct thread_data *td)
+{
+}
+
#endif
-static int write_iops_log(struct thread_data *td, int try)
+static int __write_log(struct thread_data *td, struct io_log *log, int try)
{
- struct io_log *log = td->iops_log;
+ if (log)
+ return finish_log(td, log, try);
- if (!log)
- return 0;
+ return 0;
+}
- return finish_log(td, log, try);
+static int write_iops_log(struct thread_data *td, int try)
+{
+ return __write_log(td, td->iops_log, try);
}
static int write_slat_log(struct thread_data *td, int try)
{
- struct io_log *log = td->slat_log;
-
- if (!log)
- return 0;
-
- return finish_log(td, log, try);
+ return __write_log(td, td->slat_log, try);
}
static int write_clat_log(struct thread_data *td, int try)
{
- struct io_log *log = td->clat_log;
-
- if (!log)
- return 0;
-
- return finish_log(td, log, try);
+ return __write_log(td, td->clat_log, try);
}
static int write_lat_log(struct thread_data *td, int try)
{
- struct io_log *log = td->lat_log;
-
- if (!log)
- return 0;
-
- return finish_log(td, log, try);
+ return __write_log(td, td->lat_log, try);
}
static int write_bandw_log(struct thread_data *td, int try)
{
- struct io_log *log = td->bw_log;
-
- if (!log)
- return 0;
-
- return finish_log(td, log, try);
+ return __write_log(td, td->bw_log, try);
}
enum {