log.c

   1 #include <unistd.h>
   2 #include <fcntl.h>
   3 #include <string.h>
   4 #include <stdarg.h>
   5 #include <syslog.h>
   6
   7 #include "fio.h"
   8
   9 #define LOG_START_SZ            512
  10
  11 size_t log_info_buf(const char *buf, size_t len)
  12 {
  13         /*
  14          * buf could be NULL (not just "").
  15          */
  16         if (!buf)
  17                 return 0;
  18
  19         if (is_backend) {
  20                 size_t ret = fio_server_text_output(FIO_LOG_INFO, buf, len);
  21                 if (ret != -1)
  22                         return ret;
  23         }
  24
  25         if (log_syslog) {
  26                 syslog(LOG_INFO, "%s", buf);
  27                 return len;
  28         } else
  29                 return fwrite(buf, len, 1, f_out);
  30 }
  31
  32 static size_t valist_to_buf(char **buffer, const char *fmt, va_list src_args)
  33 {
  34         size_t len, cur = LOG_START_SZ;
  35         va_list args;
  36
  37         do {
  38                 *buffer = calloc(1, cur);
  39                 if (!*buffer)
  40                         return 0;
  41
  42                 va_copy(args, src_args);
  43                 len = vsnprintf(*buffer, cur, fmt, args);
  44                 va_end(args);
  45
  46                 if (len < cur)
  47                         break;
  48
  49                 cur = len + 1;
  50                 free(*buffer);
  51         } while (1);
  52
  53         return len;
  54 }
  55
  56 /* allocate buffer, fill with prefix string followed by vararg string */
  57 static size_t prevalist_to_buf(char **buffer, const char *pre, int prelen,
  58                 const char *fmt, va_list src_args)
  59 {
  60         size_t len, cur = LOG_START_SZ;
  61         va_list args;
  62
  63         do {
  64                 *buffer = calloc(1, cur);
  65                 if (!*buffer)
  66                         return 0;
  67
  68                 va_copy(args, src_args);
  69                 memcpy(*buffer, pre, prelen);
  70                 len = prelen + vsnprintf(*buffer + prelen, cur - prelen, fmt, args);
  71                 va_end(args);
  72
  73                 if (len < cur)
  74                         break;
  75
  76                 cur = len + 1;
  77                 free(*buffer);
  78         } while (1);
  79
  80         return len;
  81 }
  82
  83 size_t log_valist(const char *fmt, va_list args)
  84 {
  85         char *buffer;
  86         size_t len;
  87
  88         len = valist_to_buf(&buffer, fmt, args);
  89         len = log_info_buf(buffer, len);
  90         free(buffer);
  91
  92         return len;
  93 }
  94
  95 /* add prefix for the specified type in front of the valist */
  96 void log_prevalist(int type, const char *fmt, va_list args)
  97 {
  98         char pre[32];
  99         char *buffer;
 100         size_t len;
 101         size_t prelen;
 102         pid_t pid;
 103
 104         pid = gettid();
 105         if (fio_debug_jobp && *fio_debug_jobp != -1U
 106             && pid != *fio_debug_jobp)
 107                 return;
 108
 109         prelen = snprintf(pre, sizeof pre, "%-8s %-5u ", debug_levels[type].name, (int) pid);
 110         if (prelen < 0)
 111                 return;
 112
 113         len = prevalist_to_buf(&buffer, pre, prelen, fmt, args);
 114         len = log_info_buf(buffer, len);
 115         free(buffer);
 116
 117         return;
 118 }
 119
 120 size_t log_info(const char *format, ...)
 121 {
 122         va_list args;
 123         size_t ret;
 124
 125         va_start(args, format);
 126         ret = log_valist(format, args);
 127         va_end(args);
 128
 129         return ret;
 130 }
 131
 132 size_t __log_buf(struct buf_output *buf, const char *format, ...)
 133 {
 134         char *buffer;
 135         va_list args;
 136         size_t len;
 137
 138         va_start(args, format);
 139         len = valist_to_buf(&buffer, format, args);
 140         va_end(args);
 141
 142         len = buf_output_add(buf, buffer, len);
 143         free(buffer);
 144
 145         return len;
 146 }
 147
 148 int log_info_flush(void)
 149 {
 150         if (is_backend || log_syslog)
 151                 return 0;
 152
 153         return fflush(f_out);
 154 }
 155
 156 size_t log_err(const char *format, ...)
 157 {
 158         size_t ret, len;
 159         char *buffer;
 160         va_list args;
 161
 162         va_start(args, format);
 163         len = valist_to_buf(&buffer, format, args);
 164         va_end(args);
 165
 166         if (is_backend) {
 167                 ret = fio_server_text_output(FIO_LOG_ERR, buffer, len);
 168                 if (ret != -1)
 169                         goto done;
 170         }
 171
 172         if (log_syslog) {
 173                 syslog(LOG_INFO, "%s", buffer);
 174                 ret = len;
 175         } else {
 176                 if (f_err != stderr)
 177                         ret = fwrite(buffer, len, 1, stderr);
 178
 179                 ret = fwrite(buffer, len, 1, f_err);
 180         }
 181
 182 done:
 183         free(buffer);
 184         return ret;
 185 }
 186
 187 const char *log_get_level(int level)
 188 {
 189         static const char *levels[] = { "Unknown", "Debug", "Info", "Error",
 190                                                 "Unknown" };
 191
 192         if (level >= FIO_LOG_NR)
 193                 level = FIO_LOG_NR;
 194
 195         return levels[level];
 196 }