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
  40                 va_copy(args, src_args);
  41                 len = vsnprintf(*buffer, cur, fmt, args);
  42                 va_end(args);
  43
  44                 if (len < cur)
  45                         break;
  46
  47                 cur = len + 1;
  48                 free(*buffer);
  49         } while (1);
  50
  51         return len;
  52 }
  53
  54 size_t log_valist(const char *fmt, va_list args)
  55 {
  56         char *buffer;
  57         size_t len;
  58
  59         len = valist_to_buf(&buffer, fmt, args);
  60         len = log_info_buf(buffer, len);
  61         free(buffer);
  62
  63         return len;
  64 }
  65
  66 size_t log_info(const char *format, ...)
  67 {
  68         va_list args;
  69         size_t ret;
  70
  71         va_start(args, format);
  72         ret = log_valist(format, args);
  73         va_end(args);
  74
  75         return ret;
  76 }
  77
  78 size_t __log_buf(struct buf_output *buf, const char *format, ...)
  79 {
  80         char *buffer;
  81         va_list args;
  82         size_t len;
  83
  84         va_start(args, format);
  85         len = valist_to_buf(&buffer, format, args);
  86         va_end(args);
  87
  88         len = buf_output_add(buf, buffer, len);
  89         free(buffer);
  90
  91         return len;
  92 }
  93
  94 int log_info_flush(void)
  95 {
  96         if (is_backend || log_syslog)
  97                 return 0;
  98
  99         return fflush(f_out);
 100 }
 101
 102 size_t log_err(const char *format, ...)
 103 {
 104         size_t ret, len;
 105         char *buffer;
 106         va_list args;
 107
 108         va_start(args, format);
 109         len = valist_to_buf(&buffer, format, args);
 110         va_end(args);
 111
 112         if (is_backend) {
 113                 ret = fio_server_text_output(FIO_LOG_ERR, buffer, len);
 114                 if (ret != -1)
 115                         goto done;
 116         }
 117
 118         if (log_syslog) {
 119                 syslog(LOG_INFO, "%s", buffer);
 120                 ret = len;
 121         } else {
 122                 if (f_err != stderr)
 123                         ret = fwrite(buffer, len, 1, stderr);
 124
 125                 ret = fwrite(buffer, len, 1, f_err);
 126         }
 127
 128 done:
 129         free(buffer);
 130         return ret;
 131 }
 132
 133 const char *log_get_level(int level)
 134 {
 135         static const char *levels[] = { "Unknown", "Debug", "Info", "Error",
 136                                                 "Unknown" };
 137
 138         if (level >= FIO_LOG_NR)
 139                 level = FIO_LOG_NR;
 140
 141         return levels[level];
 142 }