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