X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=log.c;h=6c36813d4a9912b5e8742d2da55304f56b00f941;hp=df2edc6bb5a75ef603a923d3a6665798a97a4e2c;hb=84abeef7d9f2f5cded36dcfc127b3f33db89ea57;hpb=4e991c23d2d06484f581eb5e2105bc102cb35941 diff --git a/log.c b/log.c index df2edc6b..6c36813d 100644 --- a/log.c +++ b/log.c @@ -1,253 +1,148 @@ -#include -#include -#include "list.h" -#include "fio.h" - -void write_iolog_put(struct thread_data *td, struct io_u *io_u) -{ - fprintf(td->iolog_f, "%u,%llu,%lu\n", io_u->ddir, io_u->offset, io_u->buflen); -} - -int read_iolog_get(struct thread_data *td, struct io_u *io_u) -{ - struct io_piece *ipo; - - if (!list_empty(&td->io_log_list)) { - ipo = list_entry(td->io_log_list.next, struct io_piece, list); - list_del(&ipo->list); - io_u->offset = ipo->offset; - io_u->buflen = ipo->len; - io_u->ddir = ipo->ddir; - io_u->file = ipo->file; - free(ipo); - return 0; - } - - return 1; -} +#include +#include +#include +#include -void prune_io_piece_log(struct thread_data *td) -{ - struct io_piece *ipo; - - while (!list_empty(&td->io_hist_list)) { - ipo = list_entry(td->io_hist_list.next, struct io_piece, list); - - list_del(&ipo->list); - free(ipo); - } -} +#include "fio.h" +#include "oslib/asprintf.h" -/* - * log a successful write, so we can unwind the log for verify - */ -void log_io_piece(struct thread_data *td, struct io_u *io_u) +size_t log_info_buf(const char *buf, size_t len) { - struct io_piece *ipo = malloc(sizeof(struct io_piece)); - struct list_head *entry; - - INIT_LIST_HEAD(&ipo->list); - ipo->file = io_u->file; - ipo->offset = io_u->offset; - ipo->len = io_u->buflen; - - /* - * for random io where the writes extend the file, it will typically - * be laid out with the block scattered as written. it's faster to - * read them in in that order again, so don't sort - */ - if (!td_random(td) || !td->overwrite) { - list_add_tail(&ipo->list, &td->io_hist_list); - return; - } - /* - * for random io, sort the list so verify will run faster + * buf could be NULL (not just ""). */ - entry = &td->io_hist_list; - while ((entry = entry->prev) != &td->io_hist_list) { - struct io_piece *__ipo = list_entry(entry, struct io_piece, list); + if (!buf) + return 0; - if (__ipo->offset < ipo->offset) - break; + if (is_backend) { + ssize_t ret = fio_server_text_output(FIO_LOG_INFO, buf, len); + if (ret != -1) + return ret; } - list_add(&ipo->list, entry); + if (log_syslog) { + syslog(LOG_INFO, "%s", buf); + return len; + } else + return fwrite(buf, len, 1, f_out); } -void write_iolog_close(struct thread_data *td) +size_t log_valist(const char *fmt, va_list args) { - fflush(td->iolog_f); - fclose(td->iolog_f); - free(td->iolog_buf); -} + char *buffer; + int len; -/* - * Open a stored log and read in the entries. - */ -static int init_iolog_read(struct thread_data *td) -{ - unsigned long long offset; - unsigned int bytes; - char *str, *p; - FILE *f; - int rw, reads, writes; - - f = fopen(td->read_iolog_file, "r"); - if (!f) { - perror("fopen read iolog"); - return 1; - } - - /* - * Read in the read iolog and store it, reuse the infrastructure - * for doing verifications. - */ - str = malloc(4096); - reads = writes = 0; - while ((p = fgets(str, 4096, f)) != NULL) { - struct io_piece *ipo; - - if (sscanf(p, "%d,%llu,%u", &rw, &offset, &bytes) != 3) { - log_err("bad iolog: %s\n", p); - continue; - } - if (rw == DDIR_READ) - reads++; - else if (rw == DDIR_WRITE) - writes++; - else { - log_err("bad ddir: %d\n", rw); - continue; - } - - ipo = malloc(sizeof(*ipo)); - INIT_LIST_HEAD(&ipo->list); - ipo->offset = offset; - ipo->len = bytes; - ipo->ddir = (enum fio_ddir) rw; - if (bytes > td->max_bs[rw]) - td->max_bs[rw] = bytes; - list_add_tail(&ipo->list, &td->io_log_list); - } - - free(str); - fclose(f); - - if (!reads && !writes) - return 1; - else if (reads && !writes) - td->td_ddir = TD_DDIR_READ; - else if (!reads && writes) - td->td_ddir = TD_DDIR_READ; - else - td->td_ddir = TD_DDIR_RW; + len = vasprintf(&buffer, fmt, args); + if (len < 0) + return 0; + len = log_info_buf(buffer, len); + free(buffer); - return 0; + return len; } -/* - * Setup a log for storing io patterns. - */ -static int init_iolog_write(struct thread_data *td) +/* add prefix for the specified type in front of the valist */ +void log_prevalist(int type, const char *fmt, va_list args) { - FILE *f; + char *buf1, *buf2; + int len; + pid_t pid; - f = fopen(td->write_iolog_file, "w+"); - if (!f) { - perror("fopen write iolog"); - return 1; - } + pid = gettid(); + if (fio_debug_jobp && *fio_debug_jobp != -1U + && pid != *fio_debug_jobp) + return; - /* - * That's it for writing, setup a log buffer and we're done. - */ - td->iolog_f = f; - td->iolog_buf = malloc(8192); - setvbuf(f, td->iolog_buf, _IOFBF, 8192); - return 0; + len = vasprintf(&buf1, fmt, args); + if (len < 0) + return; + len = asprintf(&buf2, "%-8s %-5u %s", debug_levels[type].name, + (int) pid, buf1); + free(buf1); + if (len < 0) + return; + len = log_info_buf(buf2, len); + free(buf2); } -int init_iolog(struct thread_data *td) +ssize_t log_info(const char *format, ...) { - int ret = 0; - - if (td->io_ops->flags & FIO_DISKLESSIO) - return 0; + va_list args; + ssize_t ret; - if (td->read_iolog_file) - ret = init_iolog_read(td); - else if (td->write_iolog_file) - ret = init_iolog_write(td); + va_start(args, format); + ret = log_valist(format, args); + va_end(args); return ret; } -int setup_rate(struct thread_data *td) +size_t __log_buf(struct buf_output *buf, const char *format, ...) { - unsigned long long rate; - int nr_reads_per_msec; - unsigned int bs; - - if (!td->rate && !td->rate_iops) + char *buffer; + va_list args; + int len; + + va_start(args, format); + len = vasprintf(&buffer, format, args); + va_end(args); + if (len < 0) return 0; + len = buf_output_add(buf, buffer, len); + free(buffer); - if (td_rw(td)) - bs = td->rw_min_bs; - else if (td_read(td)) - bs = td->min_bs[DDIR_READ]; - else - bs = td->min_bs[DDIR_WRITE]; - - if (td->rate) { - rate = td->rate; - nr_reads_per_msec = (rate * 1024 * 1000) / bs; - } else - nr_reads_per_msec = td->rate_iops * 1000; - - if (!nr_reads_per_msec) { - log_err("rate lower than supported\n"); - return -1; - } - - td->rate_usec_cycle = 1000000000ULL / nr_reads_per_msec; - td->rate_pending_usleep = 0; - return 0; + return len; } -void setup_log(struct io_log **log) +int log_info_flush(void) { - struct io_log *l = malloc(sizeof(*l)); + if (is_backend || log_syslog) + return 0; - l->nr_samples = 0; - l->max_samples = 1024; - l->log = malloc(l->max_samples * sizeof(struct io_sample)); - *log = l; + return fflush(f_out); } -void __finish_log(struct io_log *log, const char *name) +ssize_t log_err(const char *format, ...) { - unsigned int i; - FILE *f; - - f = fopen(name, "w"); - if (!f) { - perror("fopen log"); - return; + ssize_t ret; + int len; + char *buffer; + va_list args; + + va_start(args, format); + len = vasprintf(&buffer, format, args); + va_end(args); + if (len < 0) + return len; + + if (is_backend) { + ret = fio_server_text_output(FIO_LOG_ERR, buffer, len); + if (ret != -1) + goto done; } - for (i = 0; i < log->nr_samples; i++) - fprintf(f, "%lu, %lu, %u\n", log->log[i].time, log->log[i].val, log->log[i].ddir); + if (log_syslog) { + syslog(LOG_INFO, "%s", buffer); + ret = len; + } else { + if (f_err != stderr) + ret = fwrite(buffer, len, 1, stderr); + + ret = fwrite(buffer, len, 1, f_err); + } - fclose(f); - free(log->log); - free(log); +done: + free(buffer); + return ret; } -void finish_log(struct thread_data *td, struct io_log *log, const char *name) +const char *log_get_level(int level) { - char file_name[256]; + static const char *levels[] = { "Unknown", "Debug", "Info", "Error", + "Unknown" }; + + if (level >= FIO_LOG_NR) + level = FIO_LOG_NR; - snprintf(file_name, 200, "client%d_%s.log", td->thread_number, name); - __finish_log(log, file_name); + return levels[level]; }