LXR qemu/include/qemu/log.h

   1#ifndef QEMU_LOG_H
   2#define QEMU_LOG_H
   3
   4/* A small part of this API is split into its own header */
   5#include "qemu/log-for-trace.h"
   6#include "qemu/rcu.h"
   7
   8typedef struct QemuLogFile {
   9    struct rcu_head rcu;
  10    FILE *fd;
  11} QemuLogFile;
  12
  13/* Private global variable, don't use */
  14extern QemuLogFile *qemu_logfile;
  15
  16
  17/* 
  18 * The new API:
  19 *
  20 */
  21
  22/* Log settings checking macros: */
  23
  24/* Returns true if qemu_log() will really write somewhere
  25 */
  26static inline bool qemu_log_enabled(void)
  27{
  28    return qemu_logfile != NULL;
  29}
  30
  31/* Returns true if qemu_log() will write somewhere else than stderr
  32 */
  33static inline bool qemu_log_separate(void)
  34{
  35    QemuLogFile *logfile;
  36    bool res = false;
  37
  38    rcu_read_lock();
  39    logfile = qatomic_rcu_read(&qemu_logfile);
  40    if (logfile && logfile->fd != stderr) {
  41        res = true;
  42    }
  43    rcu_read_unlock();
  44    return res;
  45}
  46
  47#define CPU_LOG_TB_OUT_ASM (1 << 0)
  48#define CPU_LOG_TB_IN_ASM  (1 << 1)
  49#define CPU_LOG_TB_OP      (1 << 2)
  50#define CPU_LOG_TB_OP_OPT  (1 << 3)
  51#define CPU_LOG_INT        (1 << 4)
  52#define CPU_LOG_EXEC       (1 << 5)
  53#define CPU_LOG_PCALL      (1 << 6)
  54#define CPU_LOG_TB_CPU     (1 << 8)
  55#define CPU_LOG_RESET      (1 << 9)
  56#define LOG_UNIMP          (1 << 10)
  57#define LOG_GUEST_ERROR    (1 << 11)
  58#define CPU_LOG_MMU        (1 << 12)
  59#define CPU_LOG_TB_NOCHAIN (1 << 13)
  60#define CPU_LOG_PAGE       (1 << 14)
  61/* LOG_TRACE (1 << 15) is defined in log-for-trace.h */
  62#define CPU_LOG_TB_OP_IND  (1 << 16)
  63#define CPU_LOG_TB_FPU     (1 << 17)
  64#define CPU_LOG_PLUGIN     (1 << 18)
  65/* LOG_STRACE is used for user-mode strace logging. */
  66#define LOG_STRACE         (1 << 19)
  67
  68/* Lock output for a series of related logs.  Since this is not needed
  69 * for a single qemu_log / qemu_log_mask / qemu_log_mask_and_addr, we
  70 * assume that qemu_loglevel_mask has already been tested, and that
  71 * qemu_loglevel is never set when qemu_logfile is unset.
  72 */
  73
  74static inline FILE *qemu_log_lock(void)
  75{
  76    QemuLogFile *logfile;
  77    rcu_read_lock();
  78    logfile = qatomic_rcu_read(&qemu_logfile);
  79    if (logfile) {
  80        qemu_flockfile(logfile->fd);
  81        return logfile->fd;
  82    } else {
  83        return NULL;
  84    }
  85}
  86
  87static inline void qemu_log_unlock(FILE *fd)
  88{
  89    if (fd) {
  90        qemu_funlockfile(fd);
  91    }
  92    rcu_read_unlock();
  93}
  94
  95/* Logging functions: */
  96
  97/* vfprintf-like logging function
  98 */
  99static inline void G_GNUC_PRINTF(1, 0)
 100qemu_log_vprintf(const char *fmt, va_list va)
 101{
 102    QemuLogFile *logfile;
 103
 104    rcu_read_lock();
 105    logfile = qatomic_rcu_read(&qemu_logfile);
 106    if (logfile) {
 107        vfprintf(logfile->fd, fmt, va);
 108    }
 109    rcu_read_unlock();
 110}
 111
 112/* log only if a bit is set on the current loglevel mask:
 113 * @mask: bit to check in the mask
 114 * @fmt: printf-style format string
 115 * @args: optional arguments for format string
 116 */
 117#define qemu_log_mask(MASK, FMT, ...)                   \
 118    do {                                                \
 119        if (unlikely(qemu_loglevel_mask(MASK))) {       \
 120            qemu_log(FMT, ## __VA_ARGS__);              \
 121        }                                               \
 122    } while (0)
 123
 124/* log only if a bit is set on the current loglevel mask
 125 * and we are in the address range we care about:
 126 * @mask: bit to check in the mask
 127 * @addr: address to check in dfilter
 128 * @fmt: printf-style format string
 129 * @args: optional arguments for format string
 130 */
 131#define qemu_log_mask_and_addr(MASK, ADDR, FMT, ...)    \
 132    do {                                                \
 133        if (unlikely(qemu_loglevel_mask(MASK)) &&       \
 134                     qemu_log_in_addr_range(ADDR)) {    \
 135            qemu_log(FMT, ## __VA_ARGS__);              \
 136        }                                               \
 137    } while (0)
 138
 139/* Maintenance: */
 140
 141/* define log items */
 142typedef struct QEMULogItem {
 143    int mask;
 144    const char *name;
 145    const char *help;
 146} QEMULogItem;
 147
 148extern const QEMULogItem qemu_log_items[];
 149
 150void qemu_set_log(int log_flags);
 151void qemu_log_needs_buffers(void);
 152void qemu_set_log_filename(const char *filename, Error **errp);
 153void qemu_set_dfilter_ranges(const char *ranges, Error **errp);
 154bool qemu_log_in_addr_range(uint64_t addr);
 155int qemu_str_to_log_mask(const char *str);
 156
 157/* Print a usage message listing all the valid logging categories
 158 * to the specified FILE*.
 159 */
 160void qemu_print_log_usage(FILE *f);
 161
 162/* fflush() the log file */
 163void qemu_log_flush(void);
 164/* Close the log file */
 165void qemu_log_close(void);
 166
 167#endif
 168