#include "verify.h"
#include "trim.h"
#include "filelock.h"
+#include "smalloc.h"
static const char iolog_ver2[] = "fio version 2 iolog";
{
struct io_log *l;
- l = calloc(1, sizeof(*l));
+ l = smalloc(sizeof(*l));
l->nr_samples = 0;
- l->max_samples = 1024;
l->log_type = p->log_type;
l->log_offset = p->log_offset;
l->log_gz = p->log_gz;
l->log_gz_store = p->log_gz_store;
- l->log = malloc(l->max_samples * log_entry_sz(l));
l->avg_msec = p->avg_msec;
l->filename = strdup(filename);
l->td = p->td;
{
free(log->log);
free(log->filename);
- free(log);
+ sfree(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;
struct iolog_flush_data {
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)
} 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, !td->o.per_job_logs);
return 0;
}
-#ifdef CONFIG_ZLIB
-
-static void drop_data_unlock(struct iolog_flush_data *data)
+size_t log_chunk_sizes(struct io_log *log)
{
- int refs;
+ struct flist_head *entry;
+ size_t ret;
+
+ if (flist_empty(&log->chunk_list))
+ return 0;
- refs = --data->refs;
- pthread_mutex_unlock(&data->lock);
+ ret = 0;
+ pthread_mutex_lock(&log->chunk_lock);
+ flist_for_each(entry, &log->chunk_list) {
+ struct iolog_compress *c;
- if (!refs) {
- free(data);
- pthread_mutex_destroy(&data->lock);
- pthread_cond_destroy(&data->cv);
+ c = flist_entry(entry, struct iolog_compress, list);
+ ret += c->len;
}
+ pthread_mutex_unlock(&log->chunk_lock);
+ return ret;
}
-/*
- * 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 submit_worker *sw, struct workqueue_work *work)
+#ifdef CONFIG_ZLIB
+
+static int gz_work(struct iolog_flush_data *data)
{
- struct iolog_flush_data *data;
struct iolog_compress *c;
struct flist_head list;
unsigned int seq;
INIT_FLIST_HEAD(&list);
- data = container_of(work, struct iolog_flush_data, work);
-
stream.zalloc = Z_NULL;
stream.zfree = Z_NULL;
stream.opaque = Z_NULL;
ret = deflateInit(&stream, Z_DEFAULT_COMPRESSION);
if (ret != Z_OK) {
log_err("fio: failed to init gz stream\n");
- return 0;
+ goto err;
}
seq = ++data->log->chunk_seq;
ret = 0;
done:
- if (data->wait) {
- pthread_mutex_lock(&data->lock);
- data->done = 1;
- pthread_cond_signal(&data->cv);
-
- drop_data_unlock(data);
- } else
- free(data);
+ free(data);
return ret;
err:
while (!flist_empty(&list)) {
goto done;
}
+/*
+ * Invoked from our compress helper thread, when logging would have exceeded
+ * the specified memory limitation. Compresses the previously stored
+ * entries.
+ */
+static int gz_work_async(struct submit_worker *sw, struct workqueue_work *work)
+{
+ return gz_work(container_of(work, struct iolog_flush_data, work));
+}
+
static int gz_init_worker(struct submit_worker *sw)
{
struct thread_data *td = sw->wq->td;
}
static struct workqueue_ops log_compress_wq_ops = {
- .fn = gz_work,
+ .fn = gz_work_async,
.init_worker_fn = gz_init_worker,
.nice = 1,
};
data->nr_samples = log->nr_samples;
log->nr_samples = 0;
- log->max_samples = 128;
+ log->max_samples = DEF_LOG_ENTRIES;
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;
- }
-
- workqueue_enqueue(&log->td->log_compress_wq, &data->work);
-
- if (wait) {
- pthread_mutex_lock(&data->lock);
- while (!data->done)
- pthread_cond_wait(&data->cv, &data->lock);
-
- drop_data_unlock(data);
- }
+ if (!wait)
+ workqueue_enqueue(&log->td->log_compress_wq, &data->work);
+ else
+ gz_work(data);
return 0;
}
return 0;
}
-static int write_iops_log(struct thread_data *td, int try)
+static int write_iops_log(struct thread_data *td, int try, bool unit_log)
{
- return __write_log(td, td->iops_log, try);
+ int ret;
+
+ if (per_unit_log(td->iops_log) != unit_log)
+ return 0;
+
+ ret = __write_log(td, td->iops_log, try);
+ if (!ret)
+ td->iops_log = NULL;
+
+ return ret;
}
-static int write_slat_log(struct thread_data *td, int try)
+static int write_slat_log(struct thread_data *td, int try, bool unit_log)
{
- return __write_log(td, td->slat_log, try);
+ int ret;
+
+ if (!unit_log)
+ return 0;
+
+ ret = __write_log(td, td->slat_log, try);
+ if (!ret)
+ td->slat_log = NULL;
+
+ return ret;
}
-static int write_clat_log(struct thread_data *td, int try)
+static int write_clat_log(struct thread_data *td, int try, bool unit_log)
{
- return __write_log(td, td->clat_log, try);
+ int ret;
+
+ if (!unit_log)
+ return 0;
+
+ ret = __write_log(td, td->clat_log, try);
+ if (!ret)
+ td->clat_log = NULL;
+
+ return ret;
}
-static int write_lat_log(struct thread_data *td, int try)
+static int write_lat_log(struct thread_data *td, int try, bool unit_log)
{
- return __write_log(td, td->lat_log, try);
+ int ret;
+
+ if (!unit_log)
+ return 0;
+
+ ret = __write_log(td, td->lat_log, try);
+ if (!ret)
+ td->lat_log = NULL;
+
+ return ret;
}
-static int write_bandw_log(struct thread_data *td, int try)
+static int write_bandw_log(struct thread_data *td, int try, bool unit_log)
{
- return __write_log(td, td->bw_log, try);
+ int ret;
+
+ if (per_unit_log(td->bw_log) != unit_log)
+ return 0;
+
+ ret = __write_log(td, td->bw_log, try);
+ if (!ret)
+ td->bw_log = NULL;
+
+ return ret;
}
enum {
struct log_type {
unsigned int mask;
- int (*fn)(struct thread_data *, int);
+ int (*fn)(struct thread_data *, int, bool);
};
static struct log_type log_types[] = {
},
};
-void fio_writeout_logs(struct thread_data *td)
+void td_writeout_logs(struct thread_data *td, bool unit_logs)
{
unsigned int log_mask = 0;
unsigned int log_left = ALL_LOG_NR;
old_state = td_bump_runstate(td, TD_FINISHING);
- finalize_logs(td);
+ finalize_logs(td, unit_logs);
while (log_left) {
int prev_log_left = log_left;
int ret;
if (!(log_mask & lt->mask)) {
- ret = lt->fn(td, log_left != 1);
+ ret = lt->fn(td, log_left != 1, unit_logs);
if (!ret) {
log_left--;
log_mask |= lt->mask;
td_restore_runstate(td, old_state);
}
+
+void fio_writeout_logs(bool unit_logs)
+{
+ struct thread_data *td;
+ int i;
+
+ for_each_td(td, i)
+ td_writeout_logs(td, unit_logs);
+}