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