log.h (12378B)
1 /* Copyright (c) 2001, Matej Pfajfar. 2 * Copyright (c) 2001-2004, Roger Dingledine. 3 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson. 4 * Copyright (c) 2007-2021, The Tor Project, Inc. */ 5 /* See LICENSE for licensing information */ 6 7 /** 8 * \file log.h 9 * 10 * \brief Headers for log.c 11 **/ 12 13 #ifndef TOR_TORLOG_H 14 #define TOR_TORLOG_H 15 16 #include <stdarg.h> 17 #include "lib/cc/torint.h" 18 #include "lib/cc/compat_compiler.h" 19 #include "lib/defs/logging_types.h" 20 #include "lib/testsupport/testsupport.h" 21 22 #ifdef HAVE_SYSLOG_H 23 #include <syslog.h> 24 #define LOG_WARN LOG_WARNING 25 #if LOG_DEBUG < LOG_ERR 26 #ifndef COCCI 27 #error "Your syslog.h thinks high numbers are more important. " \ 28 "We aren't prepared to deal with that." 29 #endif 30 #endif /* LOG_DEBUG < LOG_ERR */ 31 #else /* !defined(HAVE_SYSLOG_H) */ 32 /* Note: Syslog's logging code refers to priorities, with 0 being the most 33 * important. Thus, all our comparisons needed to be reversed when we added 34 * syslog support. 35 * 36 * The upshot of this is that comments about log levels may be messed up: for 37 * "maximum severity" read "most severe" and "numerically *lowest* severity". 38 */ 39 40 /** Debug-level severity: for hyper-verbose messages of no interest to 41 * anybody but developers. */ 42 #define LOG_DEBUG 7 43 /** Info-level severity: for messages that appear frequently during normal 44 * operation. */ 45 #define LOG_INFO 6 46 /** Notice-level severity: for messages that appear infrequently 47 * during normal operation; that the user will probably care about; 48 * and that are not errors. 49 */ 50 #define LOG_NOTICE 5 51 /** Warn-level severity: for messages that only appear when something has gone 52 * wrong. */ 53 #define LOG_WARN 4 54 /** Error-level severity: for messages that only appear when something has gone 55 * very wrong, and the Tor process can no longer proceed. */ 56 #define LOG_ERR 3 57 #endif /* defined(HAVE_SYSLOG_H) */ 58 59 /* Logging domains */ 60 61 /** Catch-all for miscellaneous events and fatal errors. */ 62 #define LD_GENERAL (UINT64_C(1)<<0) 63 /** The cryptography subsystem. */ 64 #define LD_CRYPTO (UINT64_C(1)<<1) 65 /** Networking. */ 66 #define LD_NET (UINT64_C(1)<<2) 67 /** Parsing and acting on our configuration. */ 68 #define LD_CONFIG (UINT64_C(1)<<3) 69 /** Reading and writing from the filesystem. */ 70 #define LD_FS (UINT64_C(1)<<4) 71 /** Other servers' (non)compliance with the Tor protocol. */ 72 #define LD_PROTOCOL (UINT64_C(1)<<5) 73 /** Memory management. */ 74 #define LD_MM (UINT64_C(1)<<6) 75 /** HTTP implementation. */ 76 #define LD_HTTP (UINT64_C(1)<<7) 77 /** Application (socks) requests. */ 78 #define LD_APP (UINT64_C(1)<<8) 79 /** Communication via the controller protocol. */ 80 #define LD_CONTROL (UINT64_C(1)<<9) 81 /** Building, using, and managing circuits. */ 82 #define LD_CIRC (UINT64_C(1)<<10) 83 /** Hidden services. */ 84 #define LD_REND (UINT64_C(1)<<11) 85 /** Internal errors in this Tor process. */ 86 #define LD_BUG (UINT64_C(1)<<12) 87 /** Learning and using information about Tor servers. */ 88 #define LD_DIR (UINT64_C(1)<<13) 89 /** Learning and using information about Tor servers. */ 90 #define LD_DIRSERV (UINT64_C(1)<<14) 91 /** Onion routing protocol. */ 92 #define LD_OR (UINT64_C(1)<<15) 93 /** Generic edge-connection functionality. */ 94 #define LD_EDGE (UINT64_C(1)<<16) 95 #define LD_EXIT LD_EDGE 96 /** Bandwidth accounting. */ 97 #define LD_ACCT (UINT64_C(1)<<17) 98 /** Router history */ 99 #define LD_HIST (UINT64_C(1)<<18) 100 /** OR handshaking */ 101 #define LD_HANDSHAKE (UINT64_C(1)<<19) 102 /** Heartbeat messages */ 103 #define LD_HEARTBEAT (UINT64_C(1)<<20) 104 /** Abstract channel_t code */ 105 #define LD_CHANNEL (UINT64_C(1)<<21) 106 /** Scheduler */ 107 #define LD_SCHED (UINT64_C(1)<<22) 108 /** Guard nodes */ 109 #define LD_GUARD (UINT64_C(1)<<23) 110 /** Generation and application of consensus diffs. */ 111 #define LD_CONSDIFF (UINT64_C(1)<<24) 112 /** Denial of Service mitigation. */ 113 #define LD_DOS (UINT64_C(1)<<25) 114 /** Processes */ 115 #define LD_PROCESS (UINT64_C(1)<<26) 116 /** Pluggable Transports. */ 117 #define LD_PT (UINT64_C(1)<<27) 118 /** Bootstrap tracker. */ 119 #define LD_BTRACK (UINT64_C(1)<<28) 120 /** Message-passing backend. */ 121 #define LD_MESG (UINT64_C(1)<<29) 122 123 /** The number of log domains. */ 124 #define N_LOGGING_DOMAINS 30 125 /** The highest log domain */ 126 #define HIGHEST_RESERVED_LD_DOMAIN_ (UINT64_C(1)<<(N_LOGGING_DOMAINS - 1)) 127 /** All log domains. */ 128 #define LD_ALL_DOMAINS ((~(UINT64_C(0)))>>(64 - N_LOGGING_DOMAINS)) 129 130 /** The number of log flags. */ 131 #define N_LOGGING_FLAGS 3 132 /** First bit that is reserved in log_domain_mask_t for non-domain flags. */ 133 #define LOWEST_RESERVED_LD_FLAG_ (UINT64_C(1)<<(64 - N_LOGGING_FLAGS)) 134 /** All log flags. */ 135 #define LD_ALL_FLAGS ((~(UINT64_C(0)))<<(64 - N_LOGGING_FLAGS)) 136 137 #ifdef TOR_UNIT_TESTS 138 /** This log message should not be intercepted by mock_saving_logv */ 139 #define LD_NO_MOCK (UINT64_C(1)<<61) 140 #endif 141 142 /** This log message is not safe to send to a callback-based logger 143 * immediately. Used as a flag, not a log domain. */ 144 #define LD_NOCB (UINT64_C(1)<<62) 145 /** This log message should not include a function name, even if it otherwise 146 * would. Used as a flag, not a log domain. */ 147 #define LD_NOFUNCNAME (UINT64_C(1)<<63) 148 149 /** Configures which severities are logged for each logging domain for a given 150 * log target. */ 151 typedef struct log_severity_list_t { 152 /** For each log severity, a bitmask of which domains a given logger is 153 * logging. */ 154 log_domain_mask_t masks[LOG_DEBUG-LOG_ERR+1]; 155 } log_severity_list_t; 156 157 /** Callback type used for add_callback_log. */ 158 typedef void (*log_callback)(int severity, log_domain_mask_t domain, 159 const char *msg); 160 161 void init_logging(int disable_startup_queue); 162 int parse_log_level(const char *level); 163 const char *log_level_to_string(int level); 164 int parse_log_severity_config(const char **cfg, 165 log_severity_list_t *severity_out); 166 void set_log_severity_config(int minSeverity, int maxSeverity, 167 log_severity_list_t *severity_out); 168 void add_stream_log(const log_severity_list_t *severity, 169 const char *name, int fd); 170 MOCK_DECL(int, add_file_log,(const log_severity_list_t *severity, 171 const char *filename, 172 int fd)); 173 174 #ifdef HAVE_SYSLOG_H 175 int add_syslog_log(const log_severity_list_t *severity, 176 const char* syslog_identity_tag); 177 #endif // HAVE_SYSLOG_H. 178 int add_callback_log(const log_severity_list_t *severity, log_callback cb); 179 typedef void (*pending_callback_callback)(void); 180 void logs_set_pending_callback_callback(pending_callback_callback cb); 181 void logs_set_domain_logging(int enabled); 182 int get_min_log_level(void); 183 void switch_logs_debug(void); 184 void logs_free_all(void); 185 void logs_flush_sigsafe(void); 186 void add_default_log(int min_severity); 187 void close_temp_logs(void); 188 void rollback_log_changes(void); 189 void mark_logs_temp(void); 190 void change_callback_log_severity(int loglevelMin, int loglevelMax, 191 log_callback cb); 192 void flush_pending_log_callbacks(void); 193 void flush_log_messages_from_startup(void); 194 void log_set_application_name(const char *name); 195 MOCK_DECL(void, set_log_time_granularity,(int granularity_msec)); 196 void truncate_logs(void); 197 198 void tor_log(int severity, log_domain_mask_t domain, const char *format, ...) 199 CHECK_PRINTF(3,4); 200 201 void tor_log_update_sigsafe_err_fds(void); 202 203 struct smartlist_t; 204 void tor_log_get_logfile_names(struct smartlist_t *out); 205 206 extern int log_global_min_severity_; 207 208 #ifdef TOR_COVERAGE 209 /* For coverage builds, we try to avoid our log_debug optimization, since it 210 * can have weird effects on internal macro coverage. */ 211 #define debug_logging_enabled() (1) 212 #else 213 static inline bool debug_logging_enabled(void); 214 /** 215 * Return true iff debug logging is enabled for at least one domain. 216 */ 217 static inline bool debug_logging_enabled(void) 218 { 219 return PREDICT_UNLIKELY(log_global_min_severity_ == LOG_DEBUG); 220 } 221 #endif /* defined(TOR_COVERAGE) */ 222 223 void log_fn_(int severity, log_domain_mask_t domain, 224 const char *funcname, const char *format, ...) 225 CHECK_PRINTF(4,5); 226 struct ratelim_t; 227 void log_fn_ratelim_(struct ratelim_t *ratelim, int severity, 228 log_domain_mask_t domain, const char *funcname, 229 const char *format, ...) 230 CHECK_PRINTF(5,6); 231 232 int log_message_is_interesting(int severity, log_domain_mask_t domain); 233 void tor_log_string(int severity, log_domain_mask_t domain, 234 const char *function, const char *string); 235 236 #if defined(__GNUC__) && __GNUC__ <= 3 237 238 /* These are the GCC varidaic macros, so that older versions of GCC don't 239 * break. */ 240 241 /** Log a message at level <b>severity</b>, using a pretty-printed version 242 * of the current function name. */ 243 #define log_fn(severity, domain, args...) \ 244 log_fn_(severity, domain, __FUNCTION__, args) 245 /** As log_fn, but use <b>ratelim</b> (an instance of ratelim_t) to control 246 * the frequency at which messages can appear. 247 */ 248 #define log_fn_ratelim(ratelim, severity, domain, args...) \ 249 log_fn_ratelim_(ratelim, severity, domain, __FUNCTION__, args) 250 #define log_debug(domain, args...) \ 251 STMT_BEGIN \ 252 if (debug_logging_enabled()) \ 253 log_fn_(LOG_DEBUG, domain, __FUNCTION__, args); \ 254 STMT_END 255 #define log_info(domain, args...) \ 256 log_fn_(LOG_INFO, domain, __FUNCTION__, args) 257 #define log_notice(domain, args...) \ 258 log_fn_(LOG_NOTICE, domain, __FUNCTION__, args) 259 #define log_warn(domain, args...) \ 260 log_fn_(LOG_WARN, domain, __FUNCTION__, args) 261 #define log_err(domain, args...) \ 262 log_fn_(LOG_ERR, domain, __FUNCTION__, args) 263 264 #else /* !(defined(__GNUC__) && __GNUC__ <= 3) */ 265 266 /* Here are the c99 variadic macros, to work with non-GCC compilers */ 267 268 #define log_debug(domain, args, ...) \ 269 STMT_BEGIN \ 270 if (debug_logging_enabled()) \ 271 log_fn_(LOG_DEBUG, domain, __FUNCTION__, args, ##__VA_ARGS__); \ 272 STMT_END 273 #define log_info(domain, args,...) \ 274 log_fn_(LOG_INFO, domain, __FUNCTION__, args, ##__VA_ARGS__) 275 #define log_notice(domain, args,...) \ 276 log_fn_(LOG_NOTICE, domain, __FUNCTION__, args, ##__VA_ARGS__) 277 #define log_warn(domain, args,...) \ 278 log_fn_(LOG_WARN, domain, __FUNCTION__, args, ##__VA_ARGS__) 279 #define log_err(domain, args,...) \ 280 log_fn_(LOG_ERR, domain, __FUNCTION__, args, ##__VA_ARGS__) 281 /** Log a message at level <b>severity</b>, using a pretty-printed version 282 * of the current function name. */ 283 #define log_fn(severity, domain, args,...) \ 284 log_fn_(severity, domain, __FUNCTION__, args, ##__VA_ARGS__) 285 /** As log_fn, but use <b>ratelim</b> (an instance of ratelim_t) to control 286 * the frequency at which messages can appear. 287 */ 288 #define log_fn_ratelim(ratelim, severity, domain, args,...) \ 289 log_fn_ratelim_(ratelim, severity, domain, __FUNCTION__, \ 290 args, ##__VA_ARGS__) 291 #endif /* defined(__GNUC__) && __GNUC__ <= 3 */ 292 293 /** This defines log levels that are linked in the Rust log module, rather 294 * than re-defining these in both Rust and C. 295 * 296 * C_RUST_COUPLED src/rust/tor_log LogSeverity, LogDomain 297 */ 298 extern const int LOG_WARN_; 299 extern const int LOG_NOTICE_; 300 extern const log_domain_mask_t LD_NET_; 301 extern const log_domain_mask_t LD_GENERAL_; 302 303 #ifdef LOG_PRIVATE 304 MOCK_DECL(STATIC void, logv, (int severity, log_domain_mask_t domain, 305 const char *funcname, const char *suffix, const char *format, 306 va_list ap) CHECK_PRINTF(5,0)); 307 MOCK_DECL(STATIC void, add_stream_log_impl,( 308 const log_severity_list_t *severity, const char *name, int fd)); 309 #endif /* defined(LOG_PRIVATE) */ 310 311 #if defined(LOG_PRIVATE) || defined(TOR_UNIT_TESTS) 312 /** Given a severity, yields an index into log_severity_list_t.masks to use 313 * for that severity. */ 314 #define SEVERITY_MASK_IDX(sev) ((sev) - LOG_ERR) 315 #endif 316 317 #endif /* !defined(TOR_TORLOG_H) */