X-Git-Url: https://git.kernel.dk/?a=blobdiff_plain;f=log.c;h=6c36813d4a9912b5e8742d2da55304f56b00f941;hb=5d665e96ca02da02210606c3eed0489f78f06310;hp=42aedf270ff0882c56de0f13b78614f1c88bfff6;hpb=6796209a7e3d39522b0f5599aba277809786335e;p=fio.git diff --git a/log.c b/log.c index 42aedf27..6c36813d 100644 --- a/log.c +++ b/log.c @@ -1,162 +1,148 @@ -#include -#include -#include "list.h" -#include "fio.h" +#include +#include +#include +#include -void write_iolog_put(struct thread_data *td, struct io_u *io_u) -{ - fprintf(td->iolog_f, "%d,%llu,%u\n", io_u->ddir, io_u->offset, io_u->buflen); -} +#include "fio.h" +#include "oslib/asprintf.h" -int read_iolog_get(struct thread_data *td, struct io_u *io_u) +size_t log_info_buf(const char *buf, size_t len) { - 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; - free(ipo); + /* + * buf could be NULL (not just ""). + */ + if (!buf) return 0; + + if (is_backend) { + ssize_t ret = fio_server_text_output(FIO_LOG_INFO, buf, len); + if (ret != -1) + return ret; } - return 1; + if (log_syslog) { + syslog(LOG_INFO, "%s", buf); + return len; + } else + return fwrite(buf, len, 1, f_out); } -void prune_io_piece_log(struct thread_data *td) +size_t log_valist(const char *fmt, va_list args) { - struct io_piece *ipo; + char *buffer; + int len; - while (!list_empty(&td->io_hist_list)) { - ipo = list_entry(td->io_hist_list.next, struct io_piece, list); + len = vasprintf(&buffer, fmt, args); + if (len < 0) + return 0; + len = log_info_buf(buffer, len); + free(buffer); - list_del(&ipo->list); - free(ipo); - } + return len; } -/* - * log a succesful write, so we can unwind the log for verify - */ -void log_io_piece(struct thread_data *td, struct io_u *io_u) +/* add prefix for the specified type in front of the valist */ +void log_prevalist(int type, const char *fmt, va_list args) { - struct io_piece *ipo = malloc(sizeof(struct io_piece)); - struct list_head *entry; + char *buf1, *buf2; + int len; + pid_t pid; - INIT_LIST_HEAD(&ipo->list); - ipo->offset = io_u->offset; - ipo->len = io_u->buflen; + pid = gettid(); + if (fio_debug_jobp && *fio_debug_jobp != -1U + && pid != *fio_debug_jobp) + return; - /* - * 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->sequential || !td->overwrite) { - list_add_tail(&ipo->list, &td->io_hist_list); + 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); +} - /* - * for random io, sort the list so verify will run faster - */ - entry = &td->io_hist_list; - while ((entry = entry->prev) != &td->io_hist_list) { - struct io_piece *__ipo = list_entry(entry, struct io_piece, list); +ssize_t log_info(const char *format, ...) +{ + va_list args; + ssize_t ret; - if (__ipo->offset < ipo->offset) - break; - } + va_start(args, format); + ret = log_valist(format, args); + va_end(args); - list_add(&ipo->list, entry); + return ret; } -void write_iolog_close(struct thread_data *td) +size_t __log_buf(struct buf_output *buf, const char *format, ...) { - fflush(td->iolog_f); - fclose(td->iolog_f); - free(td->iolog_buf); + 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); + + return len; } -int init_iolog(struct thread_data *td) +int log_info_flush(void) { - unsigned long long offset; - unsigned int bytes; - char *str, *p; - FILE *f; - int rw, i, reads, writes; - - if (!td->read_iolog && !td->write_iolog) + if (is_backend || log_syslog) return 0; - if (td->read_iolog) - f = fopen(td->iolog_file, "r"); - else - f = fopen(td->iolog_file, "w"); + return fflush(f_out); +} - if (!f) { - perror("fopen iolog"); - printf("file %s, %d/%d\n", td->iolog_file, td->read_iolog, td->write_iolog); - return 1; +ssize_t log_err(const char *format, ...) +{ + 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; } - /* - * That's it for writing, setup a log buffer and we're done. - */ - if (td->write_iolog) { - td->iolog_f = f; - td->iolog_buf = malloc(8192); - setvbuf(f, td->iolog_buf, _IOFBF, 8192); - return 0; - } + if (log_syslog) { + syslog(LOG_INFO, "%s", buffer); + ret = len; + } else { + if (f_err != stderr) + ret = fwrite(buffer, len, 1, stderr); - /* - * Read in the read iolog and store it, reuse the infrastructure - * for doing verifications. - */ - str = malloc(4096); - reads = writes = i = 0; - while ((p = fgets(str, 4096, f)) != NULL) { - struct io_piece *ipo; - - if (sscanf(p, "%d,%llu,%u", &rw, &offset, &bytes) != 3) { - fprintf(stderr, "bad iolog: %s\n", p); - continue; - } - if (rw == DDIR_READ) - reads++; - else if (rw == DDIR_WRITE) - writes++; - else { - fprintf(stderr, "bad ddir: %d\n", rw); - continue; - } - - ipo = malloc(sizeof(*ipo)); - INIT_LIST_HEAD(&ipo->list); - ipo->offset = offset; - ipo->len = bytes; - if (bytes > td->max_bs) - td->max_bs = bytes; - ipo->ddir = rw; - list_add_tail(&ipo->list, &td->io_log_list); - i++; + ret = fwrite(buffer, len, 1, f_err); } - free(str); - fclose(f); +done: + free(buffer); + return ret; +} - if (!i) - return 1; +const char *log_get_level(int level) +{ + static const char *levels[] = { "Unknown", "Debug", "Info", "Error", + "Unknown" }; - if (reads && !writes) - td->ddir = DDIR_READ; - else if (!reads && writes) - td->ddir = DDIR_READ; - else - td->iomix = 1; + if (level >= FIO_LOG_NR) + level = FIO_LOG_NR; - return 0; + return levels[level]; }