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         int 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                 len = prevalist_to_buf(&buffer, pre, prelen, fmt, args);
 112                 len = log_info_buf(buffer, len);
 113                 free(buffer);
 114         }
 115 }
 116
 117 size_t log_info(const char *format, ...)
 118 {
 119         va_list args;
 120         size_t ret;
 121
 122         va_start(args, format);
 123         ret = log_valist(format, args);
 124         va_end(args);
 125
 126         return ret;
 127 }
 128
 129 size_t __log_buf(struct buf_output *buf, const char *format, ...)
 130 {
 131         char *buffer;
 132         va_list args;
 133         size_t len;
 134
 135         va_start(args, format);
 136         len = valist_to_buf(&buffer, format, args);
 137         va_end(args);
 138
 139         len = buf_output_add(buf, buffer, len);
 140         free(buffer);
 141
 142         return len;
 143 }
 144
 145 int log_info_flush(void)
 146 {
 147         if (is_backend || log_syslog)
 148                 return 0;
 149
 150         return fflush(f_out);
 151 }
 152
 153 size_t log_err(const char *format, ...)
 154 {
 155         size_t ret, len;
 156         char *buffer;
 157         va_list args;
 158
 159         va_start(args, format);
 160         len = valist_to_buf(&buffer, format, args);
 161         va_end(args);
 162
 163         if (is_backend) {
 164                 ret = fio_server_text_output(FIO_LOG_ERR, buffer, len);
 165                 if (ret != -1)
 166                         goto done;
 167         }
 168
 169         if (log_syslog) {
 170                 syslog(LOG_INFO, "%s", buffer);
 171                 ret = len;
 172         } else {
 173                 if (f_err != stderr)
 174                         ret = fwrite(buffer, len, 1, stderr);
 175
 176                 ret = fwrite(buffer, len, 1, f_err);
 177         }
 178
 179 done:
 180         free(buffer);
 181         return ret;
 182 }
 183
 184 const char *log_get_level(int level)
 185 {
 186         static const char *levels[] = { "Unknown", "Debug", "Info", "Error",
 187                                                 "Unknown" };
 188
 189         if (level >= FIO_LOG_NR)
 190                 level = FIO_LOG_NR;
 191
 192         return levels[level];
 193 }