mono/utils/mono-logger-internals.h

   1 #ifndef __MONO_LOGGER_INTERNAL_H__
   2 #define __MONO_LOGGER_INTERNAL_H__
   3
   4 #include <glib.h>
   5 #include "mono-logger.h"
   6
   7 G_BEGIN_DECLS
   8
   9 typedef enum {
  10         MONO_TRACE_ASSEMBLY             = (1<<0),
  11         MONO_TRACE_TYPE                 = (1<<1),
  12         MONO_TRACE_DLLIMPORT            = (1<<2),
  13         MONO_TRACE_GC                   = (1<<3),
  14         MONO_TRACE_CONFIG               = (1<<4),
  15         MONO_TRACE_AOT                  = (1<<5),
  16         MONO_TRACE_SECURITY             = (1<<6),
  17         MONO_TRACE_THREADPOOL           = (1<<7),
  18         MONO_TRACE_IO_THREADPOOL        = (1<<8),
  19         MONO_TRACE_IO_LAYER             = (1<<9),
  20         MONO_TRACE_W32HANDLE    = (1<<10),
  21         MONO_TRACE_ALL                  = MONO_TRACE_ASSEMBLY |
  22                                           MONO_TRACE_TYPE |
  23                                           MONO_TRACE_DLLIMPORT |
  24                                           MONO_TRACE_GC |
  25                                           MONO_TRACE_CONFIG |
  26                                           MONO_TRACE_AOT |
  27                                           MONO_TRACE_SECURITY |
  28                                           MONO_TRACE_THREADPOOL |
  29                                           MONO_TRACE_IO_THREADPOOL |
  30                                           MONO_TRACE_IO_LAYER |
  31                                           MONO_TRACE_W32HANDLE
  32 } MonoTraceMask;
  33
  34 extern GLogLevelFlags mono_internal_current_level;
  35 extern MonoTraceMask mono_internal_current_mask;
  36
  37 void
  38 mono_trace_init (void);
  39
  40 void
  41 mono_trace_cleanup (void);
  42
  43 void
  44 mono_tracev_inner (GLogLevelFlags level, MonoTraceMask mask, const char *format, va_list args);
  45
  46 void
  47 mono_trace_set_level (GLogLevelFlags level);
  48
  49 void
  50 mono_trace_set_mask (MonoTraceMask mask);
  51
  52 void
  53 mono_trace_push (GLogLevelFlags level, MonoTraceMask mask);
  54
  55 void
  56 mono_trace_pop (void);
  57
  58 gboolean
  59 mono_trace_is_traced (GLogLevelFlags level, MonoTraceMask mask);
  60
  61 G_GNUC_UNUSED static void
  62 mono_tracev (GLogLevelFlags level, MonoTraceMask mask, const char *format, va_list args)
  63 {
  64         if(G_UNLIKELY (level <= mono_internal_current_level && mask & mono_internal_current_mask))
  65                 mono_tracev_inner (level, mask, format, args);
  66 }
  67
  68 /**
  69  * mono_trace:
  70  *
  71  *      @level: Verbose level of the specified message
  72  *      @mask: Type of the specified message
  73  *
  74  * Traces a new message, depending on the current logging level
  75  * and trace mask.
  76  */
  77 G_GNUC_UNUSED static void
  78 mono_trace (GLogLevelFlags level, MonoTraceMask mask, const char *format, ...)
  79 {
  80         if(G_UNLIKELY (level <= mono_internal_current_level && mask & mono_internal_current_mask)) {
  81                 va_list args;
  82                 va_start (args, format);
  83                 mono_tracev_inner (level, mask, format, args);
  84                 va_end (args);
  85         }
  86 }
  87
  88 #ifdef G_HAVE_ISO_VARARGS
  89 #define mono_trace_error(...)   mono_trace(G_LOG_LEVEL_ERROR, \
  90                                                                                         __VA_ARGS__)
  91 #define mono_trace_warning(...) mono_trace(G_LOG_LEVEL_WARNING, \
  92                                                                                         __VA_ARGS__)
  93 #define mono_trace_message(...) mono_trace(G_LOG_LEVEL_MESSAGE, \
  94                                                                                         __VA_ARGS__)
  95 #elif defined(G_HAVE_GNUC_VARARGS)
  96 #define mono_trace_error(format...)     mono_trace(G_LOG_LEVEL_ERROR, \
  97                                                                                         format)
  98 #define mono_trace_warning(format...) mono_trace(G_LOG_LEVEL_WARNING, \
  99                                                                                         format)
 100 #define mono_trace_message(format...) mono_trace(G_LOG_LEVEL_MESSAGE, \
 101                                                                                         format)
 102 #else /* no varargs macros */
 103 G_GNUC_UNUSED static void
 104 mono_trace_error(MonoTraceMask mask, const char *format, ...)
 105 {
 106         va_list args;
 107         va_start (args, format);
 108         mono_tracev(G_LOG_LEVEL_ERROR, mask, format, args);
 109         va_end (args);
 110 }
 111
 112 G_GNUC_UNUSED static void
 113 mono_trace_warning(MonoTraceMask mask, const char *format, ...)
 114 {
 115         va_list args;
 116         va_start (args, format);
 117         mono_tracev(G_LOG_LEVEL_WARNING, mask, format, args);
 118         va_end (args);
 119 }
 120
 121 G_GNUC_UNUSED static void
 122 mono_trace_message(MonoTraceMask mask, const char *format, ...)
 123 {
 124         va_list args;
 125         va_start (args, format);
 126         mono_tracev(G_LOG_LEVEL_MESSAGE, mask, format, args);
 127         va_end (args);
 128 }
 129
 130 #endif /* !__GNUC__ */
 131
 132 #if defined (PLATFORM_ANDROID) || (defined (TARGET_IOS) && defined (TARGET_IOS))
 133
 134 #define mono_gc_printf(gc_log_file, format, ...) g_log ("mono-gc", G_LOG_LEVEL_MESSAGE, format, ##__VA_ARGS__)
 135 #define mono_runtime_printf(format, ...) g_log ("mono-rt", G_LOG_LEVEL_MESSAGE, format "\n", ##__VA_ARGS__)
 136 #define mono_runtime_printf_err(format, ...) g_log ("mono-rt", G_LOG_LEVEL_CRITICAL, format "\n", ##__VA_ARGS__)
 137 #define mono_runtime_stdout_fflush() do { } while (0)
 138
 139 #else
 140
 141 #define mono_gc_printf(gc_log_file, format, ...) do {   \
 142         fprintf (gc_log_file, format, ##__VA_ARGS__);   \
 143         fflush (gc_log_file);   \
 144 } while (0)
 145
 146 #define mono_runtime_printf(format, ...) fprintf (stdout, format "\n", ##__VA_ARGS__)
 147 #define mono_runtime_printf_err(format, ...) fprintf (stderr, format "\n", ##__VA_ARGS__)
 148 #define mono_runtime_stdout_fflush() do { fflush (stdout); } while (0)
 149
 150 #endif
 151
 152 /* Internal logging API */
 153 typedef void (*MonoLoggerOpen) (const char *, void *);
 154 typedef void (*MonoLoggerWrite) (const char *, GLogLevelFlags, mono_bool, const char *);
 155 typedef void (*MonoLoggerClose) (void);
 156
 157 typedef struct _MonoLogCallParm_ {
 158         MonoLoggerOpen  opener;         /* Routine to open logging */
 159         MonoLoggerWrite writer;         /* Routine to write log data */
 160         MonoLoggerClose closer;         /* Routine to close logging */
 161         char            *dest;          /* Log destination */
 162         void            *user_data;     /* User data from legacy handler */
 163         mono_bool       header;         /* Whether we want pid/time/date in log message */
 164 } MonoLogCallParm;
 165
 166 void mono_trace_set_log_handler_internal (MonoLogCallParm *callback, void *user_data);
 167 void mono_trace_set_logdest_string (const char *value);
 168 void mono_trace_set_logheader_string (const char *value);
 169
 170 void mono_log_open_syslog (const char *, void *);
 171 void mono_log_write_syslog (const char *, GLogLevelFlags, mono_bool, const char *);
 172 void mono_log_close_syslog (void);
 173
 174 void mono_log_open_logfile (const char *, void *);
 175 void mono_log_write_logfile (const char *, GLogLevelFlags, mono_bool, const char *);
 176 void mono_log_close_logfile (void);
 177
 178 G_END_DECLS
 179
 180 #endif /* __MONO_LOGGER_INTERNAL_H__ */