log.c

   1 #include <unistd.h>
   2 #include <string.h>
   3 #include <stdarg.h>
   4 #include <syslog.h>
   5
   6 #include "fio.h"
   7 #include "oslib/asprintf.h"
   8
   9 size_t log_info_buf(const char *buf, size_t len)
  10 {
  11         /*
  12          * buf could be NULL (not just "").
  13          */
  14         if (!buf)
  15                 return 0;
  16
  17         if (is_backend) {
  18                 ssize_t ret = fio_server_text_output(FIO_LOG_INFO, buf, len);
  19                 if (ret != -1)
  20                         return ret;
  21         }
  22
  23         if (log_syslog) {
  24                 syslog(LOG_INFO, "%s", buf);
  25                 return len;
  26         } else
  27                 return fwrite(buf, len, 1, f_out);
  28 }
  29
  30 size_t log_valist(const char *fmt, va_list args)
  31 {
  32         char *buffer;
  33         int len;
  34
  35         len = vasprintf(&buffer, fmt, args);
  36         if (len < 0)
  37                 return 0;
  38         len = log_info_buf(buffer, len);
  39         free(buffer);
  40
  41         return len;
  42 }
  43
  44 /* add prefix for the specified type in front of the valist */
  45 void log_prevalist(int type, const char *fmt, va_list args)
  46 {
  47         char *buf1, *buf2;
  48         int len;
  49         pid_t pid;
  50
  51         pid = gettid();
  52         if (fio_debug_jobp && *fio_debug_jobp != -1U
  53             && pid != *fio_debug_jobp)
  54                 return;
  55
  56         len = vasprintf(&buf1, fmt, args);
  57         if (len < 0)
  58                 return;
  59         len = asprintf(&buf2, "%-8s %-5u %s", debug_levels[type].name,
  60                        (int) pid, buf1);
  61         free(buf1);
  62         if (len < 0)
  63                 return;
  64         len = log_info_buf(buf2, len);
  65         free(buf2);
  66 }
  67
  68 ssize_t log_info(const char *format, ...)
  69 {
  70         va_list args;
  71         ssize_t ret;
  72
  73         va_start(args, format);
  74         ret = log_valist(format, args);
  75         va_end(args);
  76
  77         return ret;
  78 }
  79
  80 size_t __log_buf(struct buf_output *buf, const char *format, ...)
  81 {
  82         char *buffer;
  83         va_list args;
  84         int len;
  85
  86         va_start(args, format);
  87         len = vasprintf(&buffer, format, args);
  88         va_end(args);
  89         if (len < 0)
  90                 return 0;
  91         len = buf_output_add(buf, buffer, len);
  92         free(buffer);
  93
  94         return len;
  95 }
  96
  97 int log_info_flush(void)
  98 {
  99         if (is_backend || log_syslog)
 100                 return 0;
 101
 102         return fflush(f_out);
 103 }
 104
 105 ssize_t log_err(const char *format, ...)
 106 {
 107         ssize_t ret;
 108         int len;
 109         char *buffer;
 110         va_list args;
 111
 112         va_start(args, format);
 113         len = vasprintf(&buffer, format, args);
 114         va_end(args);
 115         if (len < 0)
 116                 return len;
 117
 118         if (is_backend) {
 119                 ret = fio_server_text_output(FIO_LOG_ERR, buffer, len);
 120                 if (ret != -1)
 121                         goto done;
 122         }
 123
 124         if (log_syslog) {
 125                 syslog(LOG_INFO, "%s", buffer);
 126                 ret = len;
 127         } else {
 128                 if (f_err != stderr)
 129                         ret = fwrite(buffer, len, 1, stderr);
 130
 131                 ret = fwrite(buffer, len, 1, f_err);
 132         }
 133
 134 done:
 135         free(buffer);
 136         return ret;
 137 }
 138
 139 const char *log_get_level(int level)
 140 {
 141         static const char *levels[] = { "Unknown", "Debug", "Info", "Error",
 142                                                 "Unknown" };
 143
 144         if (level >= FIO_LOG_NR)
 145                 level = FIO_LOG_NR;
 146
 147         return levels[level];
 148 }