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