/* This file is autogenerated by tracetool, do not edit. */

#ifndef TRACE_ACCEL_KVM_GENERATED_TRACERS_H
#define TRACE_ACCEL_KVM_GENERATED_TRACERS_H

#include "trace/control.h"

extern TraceEvent _TRACE_KVM_IOCTL_EVENT;
extern TraceEvent _TRACE_KVM_VM_IOCTL_EVENT;
extern TraceEvent _TRACE_KVM_VCPU_IOCTL_EVENT;
extern TraceEvent _TRACE_KVM_RUN_EXIT_EVENT;
extern TraceEvent _TRACE_KVM_DEVICE_IOCTL_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_REG_GET_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_REG_SET_EVENT;
extern TraceEvent _TRACE_KVM_INIT_VCPU_EVENT;
extern TraceEvent _TRACE_KVM_CREATE_VCPU_EVENT;
extern TraceEvent _TRACE_KVM_DESTROY_VCPU_EVENT;
extern TraceEvent _TRACE_KVM_PARK_VCPU_EVENT;
extern TraceEvent _TRACE_KVM_UNPARK_VCPU_EVENT;
extern TraceEvent _TRACE_KVM_IRQCHIP_COMMIT_ROUTES_EVENT;
extern TraceEvent _TRACE_KVM_IRQCHIP_ADD_MSI_ROUTE_EVENT;
extern TraceEvent _TRACE_KVM_IRQCHIP_UPDATE_MSI_ROUTE_EVENT;
extern TraceEvent _TRACE_KVM_IRQCHIP_RELEASE_VIRQ_EVENT;
extern TraceEvent _TRACE_KVM_SET_IOEVENTFD_MMIO_EVENT;
extern TraceEvent _TRACE_KVM_SET_IOEVENTFD_PIO_EVENT;
extern TraceEvent _TRACE_KVM_SET_USER_MEMORY_EVENT;
extern TraceEvent _TRACE_KVM_CLEAR_DIRTY_LOG_EVENT;
extern TraceEvent _TRACE_KVM_RESAMPLE_FD_NOTIFY_EVENT;
extern TraceEvent _TRACE_KVM_DIRTY_RING_FULL_EVENT;
extern TraceEvent _TRACE_KVM_DIRTY_RING_REAP_VCPU_EVENT;
extern TraceEvent _TRACE_KVM_DIRTY_RING_PAGE_EVENT;
extern TraceEvent _TRACE_KVM_DIRTY_RING_REAPER_EVENT;
extern TraceEvent _TRACE_KVM_DIRTY_RING_REAP_EVENT;
extern TraceEvent _TRACE_KVM_DIRTY_RING_REAPER_KICK_EVENT;
extern TraceEvent _TRACE_KVM_DIRTY_RING_FLUSH_EVENT;
extern TraceEvent _TRACE_KVM_FAILED_GET_VCPU_MMAP_SIZE_EVENT;
extern TraceEvent _TRACE_KVM_CPU_EXEC_EVENT;
extern TraceEvent _TRACE_KVM_INTERRUPT_EXIT_REQUEST_EVENT;
extern TraceEvent _TRACE_KVM_IO_WINDOW_EXIT_EVENT;
extern TraceEvent _TRACE_KVM_RUN_EXIT_SYSTEM_EVENT_EVENT;
extern TraceEvent _TRACE_KVM_CONVERT_MEMORY_EVENT;
extern TraceEvent _TRACE_KVM_MEMORY_FAULT_EVENT;
extern TraceEvent _TRACE_KVM_SLOTS_GROW_EVENT;
extern uint16_t _TRACE_KVM_IOCTL_DSTATE;
extern uint16_t _TRACE_KVM_VM_IOCTL_DSTATE;
extern uint16_t _TRACE_KVM_VCPU_IOCTL_DSTATE;
extern uint16_t _TRACE_KVM_RUN_EXIT_DSTATE;
extern uint16_t _TRACE_KVM_DEVICE_IOCTL_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_REG_GET_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_REG_SET_DSTATE;
extern uint16_t _TRACE_KVM_INIT_VCPU_DSTATE;
extern uint16_t _TRACE_KVM_CREATE_VCPU_DSTATE;
extern uint16_t _TRACE_KVM_DESTROY_VCPU_DSTATE;
extern uint16_t _TRACE_KVM_PARK_VCPU_DSTATE;
extern uint16_t _TRACE_KVM_UNPARK_VCPU_DSTATE;
extern uint16_t _TRACE_KVM_IRQCHIP_COMMIT_ROUTES_DSTATE;
extern uint16_t _TRACE_KVM_IRQCHIP_ADD_MSI_ROUTE_DSTATE;
extern uint16_t _TRACE_KVM_IRQCHIP_UPDATE_MSI_ROUTE_DSTATE;
extern uint16_t _TRACE_KVM_IRQCHIP_RELEASE_VIRQ_DSTATE;
extern uint16_t _TRACE_KVM_SET_IOEVENTFD_MMIO_DSTATE;
extern uint16_t _TRACE_KVM_SET_IOEVENTFD_PIO_DSTATE;
extern uint16_t _TRACE_KVM_SET_USER_MEMORY_DSTATE;
extern uint16_t _TRACE_KVM_CLEAR_DIRTY_LOG_DSTATE;
extern uint16_t _TRACE_KVM_RESAMPLE_FD_NOTIFY_DSTATE;
extern uint16_t _TRACE_KVM_DIRTY_RING_FULL_DSTATE;
extern uint16_t _TRACE_KVM_DIRTY_RING_REAP_VCPU_DSTATE;
extern uint16_t _TRACE_KVM_DIRTY_RING_PAGE_DSTATE;
extern uint16_t _TRACE_KVM_DIRTY_RING_REAPER_DSTATE;
extern uint16_t _TRACE_KVM_DIRTY_RING_REAP_DSTATE;
extern uint16_t _TRACE_KVM_DIRTY_RING_REAPER_KICK_DSTATE;
extern uint16_t _TRACE_KVM_DIRTY_RING_FLUSH_DSTATE;
extern uint16_t _TRACE_KVM_FAILED_GET_VCPU_MMAP_SIZE_DSTATE;
extern uint16_t _TRACE_KVM_CPU_EXEC_DSTATE;
extern uint16_t _TRACE_KVM_INTERRUPT_EXIT_REQUEST_DSTATE;
extern uint16_t _TRACE_KVM_IO_WINDOW_EXIT_DSTATE;
extern uint16_t _TRACE_KVM_RUN_EXIT_SYSTEM_EVENT_DSTATE;
extern uint16_t _TRACE_KVM_CONVERT_MEMORY_DSTATE;
extern uint16_t _TRACE_KVM_MEMORY_FAULT_DSTATE;
extern uint16_t _TRACE_KVM_SLOTS_GROW_DSTATE;
#define TRACE_KVM_IOCTL_ENABLED 1
#define TRACE_KVM_VM_IOCTL_ENABLED 1
#define TRACE_KVM_VCPU_IOCTL_ENABLED 1
#define TRACE_KVM_RUN_EXIT_ENABLED 1
#define TRACE_KVM_DEVICE_IOCTL_ENABLED 1
#define TRACE_KVM_FAILED_REG_GET_ENABLED 1
#define TRACE_KVM_FAILED_REG_SET_ENABLED 1
#define TRACE_KVM_INIT_VCPU_ENABLED 1
#define TRACE_KVM_CREATE_VCPU_ENABLED 1
#define TRACE_KVM_DESTROY_VCPU_ENABLED 1
#define TRACE_KVM_PARK_VCPU_ENABLED 1
#define TRACE_KVM_UNPARK_VCPU_ENABLED 1
#define TRACE_KVM_IRQCHIP_COMMIT_ROUTES_ENABLED 1
#define TRACE_KVM_IRQCHIP_ADD_MSI_ROUTE_ENABLED 1
#define TRACE_KVM_IRQCHIP_UPDATE_MSI_ROUTE_ENABLED 1
#define TRACE_KVM_IRQCHIP_RELEASE_VIRQ_ENABLED 1
#define TRACE_KVM_SET_IOEVENTFD_MMIO_ENABLED 1
#define TRACE_KVM_SET_IOEVENTFD_PIO_ENABLED 1
#define TRACE_KVM_SET_USER_MEMORY_ENABLED 1
#define TRACE_KVM_CLEAR_DIRTY_LOG_ENABLED 1
#define TRACE_KVM_RESAMPLE_FD_NOTIFY_ENABLED 1
#define TRACE_KVM_DIRTY_RING_FULL_ENABLED 1
#define TRACE_KVM_DIRTY_RING_REAP_VCPU_ENABLED 1
#define TRACE_KVM_DIRTY_RING_PAGE_ENABLED 1
#define TRACE_KVM_DIRTY_RING_REAPER_ENABLED 1
#define TRACE_KVM_DIRTY_RING_REAP_ENABLED 1
#define TRACE_KVM_DIRTY_RING_REAPER_KICK_ENABLED 1
#define TRACE_KVM_DIRTY_RING_FLUSH_ENABLED 1
#define TRACE_KVM_FAILED_GET_VCPU_MMAP_SIZE_ENABLED 1
#define TRACE_KVM_CPU_EXEC_ENABLED 1
#define TRACE_KVM_INTERRUPT_EXIT_REQUEST_ENABLED 1
#define TRACE_KVM_IO_WINDOW_EXIT_ENABLED 1
#define TRACE_KVM_RUN_EXIT_SYSTEM_EVENT_ENABLED 1
#define TRACE_KVM_CONVERT_MEMORY_ENABLED 1
#define TRACE_KVM_MEMORY_FAULT_ENABLED 1
#define TRACE_KVM_SLOTS_GROW_ENABLED 1
#include "qemu/log-for-trace.h"
#include "qemu/error-report.h"


#define TRACE_KVM_IOCTL_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_IOCTL) || \
    false)

static inline void _nocheck__trace_kvm_ioctl(unsigned long type, void * arg)
{
    if (trace_event_get_state(TRACE_KVM_IOCTL) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 4 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_ioctl " "type 0x%lx, arg %p" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , type, arg);
#line 136 "trace/trace-accel_kvm.h"
        } else {
#line 4 "../accel/kvm/trace-events"
            qemu_log("kvm_ioctl " "type 0x%lx, arg %p" "\n", type, arg);
#line 140 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_ioctl(unsigned long type, void * arg)
{
    if (true) {
        _nocheck__trace_kvm_ioctl(type, arg);
    }
}

#define TRACE_KVM_VM_IOCTL_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_VM_IOCTL) || \
    false)

static inline void _nocheck__trace_kvm_vm_ioctl(unsigned long type, void * arg)
{
    if (trace_event_get_state(TRACE_KVM_VM_IOCTL) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 5 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_vm_ioctl " "type 0x%lx, arg %p" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , type, arg);
#line 167 "trace/trace-accel_kvm.h"
        } else {
#line 5 "../accel/kvm/trace-events"
            qemu_log("kvm_vm_ioctl " "type 0x%lx, arg %p" "\n", type, arg);
#line 171 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_vm_ioctl(unsigned long type, void * arg)
{
    if (true) {
        _nocheck__trace_kvm_vm_ioctl(type, arg);
    }
}

#define TRACE_KVM_VCPU_IOCTL_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_VCPU_IOCTL) || \
    false)

static inline void _nocheck__trace_kvm_vcpu_ioctl(int cpu_index, unsigned long type, void * arg)
{
    if (trace_event_get_state(TRACE_KVM_VCPU_IOCTL) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 6 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_vcpu_ioctl " "cpu_index %d, type 0x%lx, arg %p" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cpu_index, type, arg);
#line 198 "trace/trace-accel_kvm.h"
        } else {
#line 6 "../accel/kvm/trace-events"
            qemu_log("kvm_vcpu_ioctl " "cpu_index %d, type 0x%lx, arg %p" "\n", cpu_index, type, arg);
#line 202 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_vcpu_ioctl(int cpu_index, unsigned long type, void * arg)
{
    if (true) {
        _nocheck__trace_kvm_vcpu_ioctl(cpu_index, type, arg);
    }
}

#define TRACE_KVM_RUN_EXIT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_RUN_EXIT) || \
    false)

static inline void _nocheck__trace_kvm_run_exit(int cpu_index, uint32_t reason)
{
    if (trace_event_get_state(TRACE_KVM_RUN_EXIT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 7 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_run_exit " "cpu_index %d, reason %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cpu_index, reason);
#line 229 "trace/trace-accel_kvm.h"
        } else {
#line 7 "../accel/kvm/trace-events"
            qemu_log("kvm_run_exit " "cpu_index %d, reason %d" "\n", cpu_index, reason);
#line 233 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_run_exit(int cpu_index, uint32_t reason)
{
    if (true) {
        _nocheck__trace_kvm_run_exit(cpu_index, reason);
    }
}

#define TRACE_KVM_DEVICE_IOCTL_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_DEVICE_IOCTL) || \
    false)

static inline void _nocheck__trace_kvm_device_ioctl(int fd, unsigned long type, void * arg)
{
    if (trace_event_get_state(TRACE_KVM_DEVICE_IOCTL) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 8 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_device_ioctl " "dev fd %d, type 0x%lx, arg %p" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , fd, type, arg);
#line 260 "trace/trace-accel_kvm.h"
        } else {
#line 8 "../accel/kvm/trace-events"
            qemu_log("kvm_device_ioctl " "dev fd %d, type 0x%lx, arg %p" "\n", fd, type, arg);
#line 264 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_device_ioctl(int fd, unsigned long type, void * arg)
{
    if (true) {
        _nocheck__trace_kvm_device_ioctl(fd, type, arg);
    }
}

#define TRACE_KVM_FAILED_REG_GET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_REG_GET) || \
    false)

static inline void _nocheck__trace_kvm_failed_reg_get(uint64_t id, const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_REG_GET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 9 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_reg_get " "Warning: Unable to retrieve ONEREG %" PRIu64 " from KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , id, msg);
#line 291 "trace/trace-accel_kvm.h"
        } else {
#line 9 "../accel/kvm/trace-events"
            qemu_log("kvm_failed_reg_get " "Warning: Unable to retrieve ONEREG %" PRIu64 " from KVM: %s" "\n", id, msg);
#line 295 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_failed_reg_get(uint64_t id, const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_reg_get(id, msg);
    }
}

#define TRACE_KVM_FAILED_REG_SET_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_REG_SET) || \
    false)

static inline void _nocheck__trace_kvm_failed_reg_set(uint64_t id, const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_REG_SET) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 10 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_reg_set " "Warning: Unable to set ONEREG %" PRIu64 " to KVM: %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , id, msg);
#line 322 "trace/trace-accel_kvm.h"
        } else {
#line 10 "../accel/kvm/trace-events"
            qemu_log("kvm_failed_reg_set " "Warning: Unable to set ONEREG %" PRIu64 " to KVM: %s" "\n", id, msg);
#line 326 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_failed_reg_set(uint64_t id, const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_failed_reg_set(id, msg);
    }
}

#define TRACE_KVM_INIT_VCPU_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_INIT_VCPU) || \
    false)

static inline void _nocheck__trace_kvm_init_vcpu(int cpu_index, unsigned long arch_cpu_id)
{
    if (trace_event_get_state(TRACE_KVM_INIT_VCPU) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 11 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_init_vcpu " "index: %d id: %lu" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cpu_index, arch_cpu_id);
#line 353 "trace/trace-accel_kvm.h"
        } else {
#line 11 "../accel/kvm/trace-events"
            qemu_log("kvm_init_vcpu " "index: %d id: %lu" "\n", cpu_index, arch_cpu_id);
#line 357 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_init_vcpu(int cpu_index, unsigned long arch_cpu_id)
{
    if (true) {
        _nocheck__trace_kvm_init_vcpu(cpu_index, arch_cpu_id);
    }
}

#define TRACE_KVM_CREATE_VCPU_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_CREATE_VCPU) || \
    false)

static inline void _nocheck__trace_kvm_create_vcpu(int cpu_index, unsigned long arch_cpu_id, int kvm_fd)
{
    if (trace_event_get_state(TRACE_KVM_CREATE_VCPU) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 12 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_create_vcpu " "index: %d, id: %lu, kvm fd: %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cpu_index, arch_cpu_id, kvm_fd);
#line 384 "trace/trace-accel_kvm.h"
        } else {
#line 12 "../accel/kvm/trace-events"
            qemu_log("kvm_create_vcpu " "index: %d, id: %lu, kvm fd: %d" "\n", cpu_index, arch_cpu_id, kvm_fd);
#line 388 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_create_vcpu(int cpu_index, unsigned long arch_cpu_id, int kvm_fd)
{
    if (true) {
        _nocheck__trace_kvm_create_vcpu(cpu_index, arch_cpu_id, kvm_fd);
    }
}

#define TRACE_KVM_DESTROY_VCPU_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_DESTROY_VCPU) || \
    false)

static inline void _nocheck__trace_kvm_destroy_vcpu(int cpu_index, unsigned long arch_cpu_id)
{
    if (trace_event_get_state(TRACE_KVM_DESTROY_VCPU) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 13 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_destroy_vcpu " "index: %d id: %lu" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cpu_index, arch_cpu_id);
#line 415 "trace/trace-accel_kvm.h"
        } else {
#line 13 "../accel/kvm/trace-events"
            qemu_log("kvm_destroy_vcpu " "index: %d id: %lu" "\n", cpu_index, arch_cpu_id);
#line 419 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_destroy_vcpu(int cpu_index, unsigned long arch_cpu_id)
{
    if (true) {
        _nocheck__trace_kvm_destroy_vcpu(cpu_index, arch_cpu_id);
    }
}

#define TRACE_KVM_PARK_VCPU_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_PARK_VCPU) || \
    false)

static inline void _nocheck__trace_kvm_park_vcpu(int cpu_index, unsigned long arch_cpu_id)
{
    if (trace_event_get_state(TRACE_KVM_PARK_VCPU) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 14 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_park_vcpu " "index: %d id: %lu" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cpu_index, arch_cpu_id);
#line 446 "trace/trace-accel_kvm.h"
        } else {
#line 14 "../accel/kvm/trace-events"
            qemu_log("kvm_park_vcpu " "index: %d id: %lu" "\n", cpu_index, arch_cpu_id);
#line 450 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_park_vcpu(int cpu_index, unsigned long arch_cpu_id)
{
    if (true) {
        _nocheck__trace_kvm_park_vcpu(cpu_index, arch_cpu_id);
    }
}

#define TRACE_KVM_UNPARK_VCPU_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_UNPARK_VCPU) || \
    false)

static inline void _nocheck__trace_kvm_unpark_vcpu(unsigned long arch_cpu_id, const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_UNPARK_VCPU) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 15 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_unpark_vcpu " "id: %lu %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , arch_cpu_id, msg);
#line 477 "trace/trace-accel_kvm.h"
        } else {
#line 15 "../accel/kvm/trace-events"
            qemu_log("kvm_unpark_vcpu " "id: %lu %s" "\n", arch_cpu_id, msg);
#line 481 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_unpark_vcpu(unsigned long arch_cpu_id, const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_unpark_vcpu(arch_cpu_id, msg);
    }
}

#define TRACE_KVM_IRQCHIP_COMMIT_ROUTES_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_IRQCHIP_COMMIT_ROUTES) || \
    false)

static inline void _nocheck__trace_kvm_irqchip_commit_routes(void)
{
    if (trace_event_get_state(TRACE_KVM_IRQCHIP_COMMIT_ROUTES) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 16 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_irqchip_commit_routes " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 508 "trace/trace-accel_kvm.h"
        } else {
#line 16 "../accel/kvm/trace-events"
            qemu_log("kvm_irqchip_commit_routes " "" "\n");
#line 512 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_irqchip_commit_routes(void)
{
    if (true) {
        _nocheck__trace_kvm_irqchip_commit_routes();
    }
}

#define TRACE_KVM_IRQCHIP_ADD_MSI_ROUTE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_IRQCHIP_ADD_MSI_ROUTE) || \
    false)

static inline void _nocheck__trace_kvm_irqchip_add_msi_route(char * name, int vector, int virq)
{
    if (trace_event_get_state(TRACE_KVM_IRQCHIP_ADD_MSI_ROUTE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 17 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_irqchip_add_msi_route " "dev %s vector %d virq %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , name, vector, virq);
#line 539 "trace/trace-accel_kvm.h"
        } else {
#line 17 "../accel/kvm/trace-events"
            qemu_log("kvm_irqchip_add_msi_route " "dev %s vector %d virq %d" "\n", name, vector, virq);
#line 543 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_irqchip_add_msi_route(char * name, int vector, int virq)
{
    if (true) {
        _nocheck__trace_kvm_irqchip_add_msi_route(name, vector, virq);
    }
}

#define TRACE_KVM_IRQCHIP_UPDATE_MSI_ROUTE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_IRQCHIP_UPDATE_MSI_ROUTE) || \
    false)

static inline void _nocheck__trace_kvm_irqchip_update_msi_route(int virq)
{
    if (trace_event_get_state(TRACE_KVM_IRQCHIP_UPDATE_MSI_ROUTE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 18 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_irqchip_update_msi_route " "Updating MSI route virq=%d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , virq);
#line 570 "trace/trace-accel_kvm.h"
        } else {
#line 18 "../accel/kvm/trace-events"
            qemu_log("kvm_irqchip_update_msi_route " "Updating MSI route virq=%d" "\n", virq);
#line 574 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_irqchip_update_msi_route(int virq)
{
    if (true) {
        _nocheck__trace_kvm_irqchip_update_msi_route(virq);
    }
}

#define TRACE_KVM_IRQCHIP_RELEASE_VIRQ_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_IRQCHIP_RELEASE_VIRQ) || \
    false)

static inline void _nocheck__trace_kvm_irqchip_release_virq(int virq)
{
    if (trace_event_get_state(TRACE_KVM_IRQCHIP_RELEASE_VIRQ) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 19 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_irqchip_release_virq " "virq %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , virq);
#line 601 "trace/trace-accel_kvm.h"
        } else {
#line 19 "../accel/kvm/trace-events"
            qemu_log("kvm_irqchip_release_virq " "virq %d" "\n", virq);
#line 605 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_irqchip_release_virq(int virq)
{
    if (true) {
        _nocheck__trace_kvm_irqchip_release_virq(virq);
    }
}

#define TRACE_KVM_SET_IOEVENTFD_MMIO_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_SET_IOEVENTFD_MMIO) || \
    false)

static inline void _nocheck__trace_kvm_set_ioeventfd_mmio(int fd, uint64_t addr, uint32_t val, bool assign, uint32_t size, bool datamatch)
{
    if (trace_event_get_state(TRACE_KVM_SET_IOEVENTFD_MMIO) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 20 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_set_ioeventfd_mmio " "fd: %d @0x%" PRIx64 " val=0x%x assign: %d size: %d match: %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , fd, addr, val, assign, size, datamatch);
#line 632 "trace/trace-accel_kvm.h"
        } else {
#line 20 "../accel/kvm/trace-events"
            qemu_log("kvm_set_ioeventfd_mmio " "fd: %d @0x%" PRIx64 " val=0x%x assign: %d size: %d match: %d" "\n", fd, addr, val, assign, size, datamatch);
#line 636 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_set_ioeventfd_mmio(int fd, uint64_t addr, uint32_t val, bool assign, uint32_t size, bool datamatch)
{
    if (true) {
        _nocheck__trace_kvm_set_ioeventfd_mmio(fd, addr, val, assign, size, datamatch);
    }
}

#define TRACE_KVM_SET_IOEVENTFD_PIO_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_SET_IOEVENTFD_PIO) || \
    false)

static inline void _nocheck__trace_kvm_set_ioeventfd_pio(int fd, uint16_t addr, uint32_t val, bool assign, uint32_t size, bool datamatch)
{
    if (trace_event_get_state(TRACE_KVM_SET_IOEVENTFD_PIO) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 21 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_set_ioeventfd_pio " "fd: %d @0x%x val=0x%x assign: %d size: %d match: %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , fd, addr, val, assign, size, datamatch);
#line 663 "trace/trace-accel_kvm.h"
        } else {
#line 21 "../accel/kvm/trace-events"
            qemu_log("kvm_set_ioeventfd_pio " "fd: %d @0x%x val=0x%x assign: %d size: %d match: %d" "\n", fd, addr, val, assign, size, datamatch);
#line 667 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_set_ioeventfd_pio(int fd, uint16_t addr, uint32_t val, bool assign, uint32_t size, bool datamatch)
{
    if (true) {
        _nocheck__trace_kvm_set_ioeventfd_pio(fd, addr, val, assign, size, datamatch);
    }
}

#define TRACE_KVM_SET_USER_MEMORY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_SET_USER_MEMORY) || \
    false)

static inline void _nocheck__trace_kvm_set_user_memory(uint16_t as, uint16_t slot, uint32_t flags, uint64_t guest_phys_addr, uint64_t memory_size, uint64_t userspace_addr, uint32_t fd, uint64_t fd_offset, int ret)
{
    if (trace_event_get_state(TRACE_KVM_SET_USER_MEMORY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 22 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_set_user_memory " "AddrSpace#%d Slot#%d flags=0x%x gpa=0x%"PRIx64 " size=0x%"PRIx64 " ua=0x%"PRIx64 " guest_memfd=%d" " guest_memfd_offset=0x%" PRIx64 " ret=%d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , as, slot, flags, guest_phys_addr, memory_size, userspace_addr, fd, fd_offset, ret);
#line 694 "trace/trace-accel_kvm.h"
        } else {
#line 22 "../accel/kvm/trace-events"
            qemu_log("kvm_set_user_memory " "AddrSpace#%d Slot#%d flags=0x%x gpa=0x%"PRIx64 " size=0x%"PRIx64 " ua=0x%"PRIx64 " guest_memfd=%d" " guest_memfd_offset=0x%" PRIx64 " ret=%d" "\n", as, slot, flags, guest_phys_addr, memory_size, userspace_addr, fd, fd_offset, ret);
#line 698 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_set_user_memory(uint16_t as, uint16_t slot, uint32_t flags, uint64_t guest_phys_addr, uint64_t memory_size, uint64_t userspace_addr, uint32_t fd, uint64_t fd_offset, int ret)
{
    if (true) {
        _nocheck__trace_kvm_set_user_memory(as, slot, flags, guest_phys_addr, memory_size, userspace_addr, fd, fd_offset, ret);
    }
}

#define TRACE_KVM_CLEAR_DIRTY_LOG_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_CLEAR_DIRTY_LOG) || \
    false)

static inline void _nocheck__trace_kvm_clear_dirty_log(uint32_t slot, uint64_t start, uint32_t size)
{
    if (trace_event_get_state(TRACE_KVM_CLEAR_DIRTY_LOG) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 23 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_clear_dirty_log " "slot#%"PRId32" start 0x%"PRIx64" size 0x%"PRIx32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , slot, start, size);
#line 725 "trace/trace-accel_kvm.h"
        } else {
#line 23 "../accel/kvm/trace-events"
            qemu_log("kvm_clear_dirty_log " "slot#%"PRId32" start 0x%"PRIx64" size 0x%"PRIx32 "\n", slot, start, size);
#line 729 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_clear_dirty_log(uint32_t slot, uint64_t start, uint32_t size)
{
    if (true) {
        _nocheck__trace_kvm_clear_dirty_log(slot, start, size);
    }
}

#define TRACE_KVM_RESAMPLE_FD_NOTIFY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_RESAMPLE_FD_NOTIFY) || \
    false)

static inline void _nocheck__trace_kvm_resample_fd_notify(int gsi)
{
    if (trace_event_get_state(TRACE_KVM_RESAMPLE_FD_NOTIFY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 24 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_resample_fd_notify " "gsi %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , gsi);
#line 756 "trace/trace-accel_kvm.h"
        } else {
#line 24 "../accel/kvm/trace-events"
            qemu_log("kvm_resample_fd_notify " "gsi %d" "\n", gsi);
#line 760 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_resample_fd_notify(int gsi)
{
    if (true) {
        _nocheck__trace_kvm_resample_fd_notify(gsi);
    }
}

#define TRACE_KVM_DIRTY_RING_FULL_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_DIRTY_RING_FULL) || \
    false)

static inline void _nocheck__trace_kvm_dirty_ring_full(int id)
{
    if (trace_event_get_state(TRACE_KVM_DIRTY_RING_FULL) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 25 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_dirty_ring_full " "vcpu %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , id);
#line 787 "trace/trace-accel_kvm.h"
        } else {
#line 25 "../accel/kvm/trace-events"
            qemu_log("kvm_dirty_ring_full " "vcpu %d" "\n", id);
#line 791 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_dirty_ring_full(int id)
{
    if (true) {
        _nocheck__trace_kvm_dirty_ring_full(id);
    }
}

#define TRACE_KVM_DIRTY_RING_REAP_VCPU_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_DIRTY_RING_REAP_VCPU) || \
    false)

static inline void _nocheck__trace_kvm_dirty_ring_reap_vcpu(int id)
{
    if (trace_event_get_state(TRACE_KVM_DIRTY_RING_REAP_VCPU) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 26 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_dirty_ring_reap_vcpu " "vcpu %d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , id);
#line 818 "trace/trace-accel_kvm.h"
        } else {
#line 26 "../accel/kvm/trace-events"
            qemu_log("kvm_dirty_ring_reap_vcpu " "vcpu %d" "\n", id);
#line 822 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_dirty_ring_reap_vcpu(int id)
{
    if (true) {
        _nocheck__trace_kvm_dirty_ring_reap_vcpu(id);
    }
}

#define TRACE_KVM_DIRTY_RING_PAGE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_DIRTY_RING_PAGE) || \
    false)

static inline void _nocheck__trace_kvm_dirty_ring_page(int vcpu, uint32_t slot, uint64_t offset)
{
    if (trace_event_get_state(TRACE_KVM_DIRTY_RING_PAGE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 27 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_dirty_ring_page " "vcpu %d fetch %"PRIu32" offset 0x%"PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , vcpu, slot, offset);
#line 849 "trace/trace-accel_kvm.h"
        } else {
#line 27 "../accel/kvm/trace-events"
            qemu_log("kvm_dirty_ring_page " "vcpu %d fetch %"PRIu32" offset 0x%"PRIx64 "\n", vcpu, slot, offset);
#line 853 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_dirty_ring_page(int vcpu, uint32_t slot, uint64_t offset)
{
    if (true) {
        _nocheck__trace_kvm_dirty_ring_page(vcpu, slot, offset);
    }
}

#define TRACE_KVM_DIRTY_RING_REAPER_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_DIRTY_RING_REAPER) || \
    false)

static inline void _nocheck__trace_kvm_dirty_ring_reaper(const char * s)
{
    if (trace_event_get_state(TRACE_KVM_DIRTY_RING_REAPER) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 28 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_dirty_ring_reaper " "%s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , s);
#line 880 "trace/trace-accel_kvm.h"
        } else {
#line 28 "../accel/kvm/trace-events"
            qemu_log("kvm_dirty_ring_reaper " "%s" "\n", s);
#line 884 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_dirty_ring_reaper(const char * s)
{
    if (true) {
        _nocheck__trace_kvm_dirty_ring_reaper(s);
    }
}

#define TRACE_KVM_DIRTY_RING_REAP_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_DIRTY_RING_REAP) || \
    false)

static inline void _nocheck__trace_kvm_dirty_ring_reap(uint64_t count, int64_t t)
{
    if (trace_event_get_state(TRACE_KVM_DIRTY_RING_REAP) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 29 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_dirty_ring_reap " "reaped %"PRIu64" pages (took %"PRIi64" us)" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , count, t);
#line 911 "trace/trace-accel_kvm.h"
        } else {
#line 29 "../accel/kvm/trace-events"
            qemu_log("kvm_dirty_ring_reap " "reaped %"PRIu64" pages (took %"PRIi64" us)" "\n", count, t);
#line 915 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_dirty_ring_reap(uint64_t count, int64_t t)
{
    if (true) {
        _nocheck__trace_kvm_dirty_ring_reap(count, t);
    }
}

#define TRACE_KVM_DIRTY_RING_REAPER_KICK_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_DIRTY_RING_REAPER_KICK) || \
    false)

static inline void _nocheck__trace_kvm_dirty_ring_reaper_kick(const char * reason)
{
    if (trace_event_get_state(TRACE_KVM_DIRTY_RING_REAPER_KICK) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 30 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_dirty_ring_reaper_kick " "%s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , reason);
#line 942 "trace/trace-accel_kvm.h"
        } else {
#line 30 "../accel/kvm/trace-events"
            qemu_log("kvm_dirty_ring_reaper_kick " "%s" "\n", reason);
#line 946 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_dirty_ring_reaper_kick(const char * reason)
{
    if (true) {
        _nocheck__trace_kvm_dirty_ring_reaper_kick(reason);
    }
}

#define TRACE_KVM_DIRTY_RING_FLUSH_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_DIRTY_RING_FLUSH) || \
    false)

static inline void _nocheck__trace_kvm_dirty_ring_flush(int finished)
{
    if (trace_event_get_state(TRACE_KVM_DIRTY_RING_FLUSH) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 31 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_dirty_ring_flush " "%d" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , finished);
#line 973 "trace/trace-accel_kvm.h"
        } else {
#line 31 "../accel/kvm/trace-events"
            qemu_log("kvm_dirty_ring_flush " "%d" "\n", finished);
#line 977 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_dirty_ring_flush(int finished)
{
    if (true) {
        _nocheck__trace_kvm_dirty_ring_flush(finished);
    }
}

#define TRACE_KVM_FAILED_GET_VCPU_MMAP_SIZE_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_FAILED_GET_VCPU_MMAP_SIZE) || \
    false)

static inline void _nocheck__trace_kvm_failed_get_vcpu_mmap_size(void)
{
    if (trace_event_get_state(TRACE_KVM_FAILED_GET_VCPU_MMAP_SIZE) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 32 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_failed_get_vcpu_mmap_size " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1004 "trace/trace-accel_kvm.h"
        } else {
#line 32 "../accel/kvm/trace-events"
            qemu_log("kvm_failed_get_vcpu_mmap_size " "" "\n");
#line 1008 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_failed_get_vcpu_mmap_size(void)
{
    if (true) {
        _nocheck__trace_kvm_failed_get_vcpu_mmap_size();
    }
}

#define TRACE_KVM_CPU_EXEC_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_CPU_EXEC) || \
    false)

static inline void _nocheck__trace_kvm_cpu_exec(void)
{
    if (trace_event_get_state(TRACE_KVM_CPU_EXEC) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 33 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_cpu_exec " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1035 "trace/trace-accel_kvm.h"
        } else {
#line 33 "../accel/kvm/trace-events"
            qemu_log("kvm_cpu_exec " "" "\n");
#line 1039 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_cpu_exec(void)
{
    if (true) {
        _nocheck__trace_kvm_cpu_exec();
    }
}

#define TRACE_KVM_INTERRUPT_EXIT_REQUEST_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_INTERRUPT_EXIT_REQUEST) || \
    false)

static inline void _nocheck__trace_kvm_interrupt_exit_request(void)
{
    if (trace_event_get_state(TRACE_KVM_INTERRUPT_EXIT_REQUEST) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 34 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_interrupt_exit_request " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1066 "trace/trace-accel_kvm.h"
        } else {
#line 34 "../accel/kvm/trace-events"
            qemu_log("kvm_interrupt_exit_request " "" "\n");
#line 1070 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_interrupt_exit_request(void)
{
    if (true) {
        _nocheck__trace_kvm_interrupt_exit_request();
    }
}

#define TRACE_KVM_IO_WINDOW_EXIT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_IO_WINDOW_EXIT) || \
    false)

static inline void _nocheck__trace_kvm_io_window_exit(void)
{
    if (trace_event_get_state(TRACE_KVM_IO_WINDOW_EXIT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 35 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_io_window_exit " "" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     );
#line 1097 "trace/trace-accel_kvm.h"
        } else {
#line 35 "../accel/kvm/trace-events"
            qemu_log("kvm_io_window_exit " "" "\n");
#line 1101 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_io_window_exit(void)
{
    if (true) {
        _nocheck__trace_kvm_io_window_exit();
    }
}

#define TRACE_KVM_RUN_EXIT_SYSTEM_EVENT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_RUN_EXIT_SYSTEM_EVENT) || \
    false)

static inline void _nocheck__trace_kvm_run_exit_system_event(int cpu_index, uint32_t event_type)
{
    if (trace_event_get_state(TRACE_KVM_RUN_EXIT_SYSTEM_EVENT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 36 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_run_exit_system_event " "cpu_index %d, system_even_type %"PRIu32 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , cpu_index, event_type);
#line 1128 "trace/trace-accel_kvm.h"
        } else {
#line 36 "../accel/kvm/trace-events"
            qemu_log("kvm_run_exit_system_event " "cpu_index %d, system_even_type %"PRIu32 "\n", cpu_index, event_type);
#line 1132 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_run_exit_system_event(int cpu_index, uint32_t event_type)
{
    if (true) {
        _nocheck__trace_kvm_run_exit_system_event(cpu_index, event_type);
    }
}

#define TRACE_KVM_CONVERT_MEMORY_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_CONVERT_MEMORY) || \
    false)

static inline void _nocheck__trace_kvm_convert_memory(uint64_t start, uint64_t size, const char * msg)
{
    if (trace_event_get_state(TRACE_KVM_CONVERT_MEMORY) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 37 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_convert_memory " "start 0x%" PRIx64 " size 0x%" PRIx64 " %s" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , start, size, msg);
#line 1159 "trace/trace-accel_kvm.h"
        } else {
#line 37 "../accel/kvm/trace-events"
            qemu_log("kvm_convert_memory " "start 0x%" PRIx64 " size 0x%" PRIx64 " %s" "\n", start, size, msg);
#line 1163 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_convert_memory(uint64_t start, uint64_t size, const char * msg)
{
    if (true) {
        _nocheck__trace_kvm_convert_memory(start, size, msg);
    }
}

#define TRACE_KVM_MEMORY_FAULT_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_MEMORY_FAULT) || \
    false)

static inline void _nocheck__trace_kvm_memory_fault(uint64_t start, uint64_t size, uint64_t flags)
{
    if (trace_event_get_state(TRACE_KVM_MEMORY_FAULT) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 38 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_memory_fault " "start 0x%" PRIx64 " size 0x%" PRIx64 " flags 0x%" PRIx64 "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , start, size, flags);
#line 1190 "trace/trace-accel_kvm.h"
        } else {
#line 38 "../accel/kvm/trace-events"
            qemu_log("kvm_memory_fault " "start 0x%" PRIx64 " size 0x%" PRIx64 " flags 0x%" PRIx64 "\n", start, size, flags);
#line 1194 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_memory_fault(uint64_t start, uint64_t size, uint64_t flags)
{
    if (true) {
        _nocheck__trace_kvm_memory_fault(start, size, flags);
    }
}

#define TRACE_KVM_SLOTS_GROW_BACKEND_DSTATE() ( \
    trace_event_get_state_dynamic_by_id(TRACE_KVM_SLOTS_GROW) || \
    false)

static inline void _nocheck__trace_kvm_slots_grow(unsigned int old, unsigned int new)
{
    if (trace_event_get_state(TRACE_KVM_SLOTS_GROW) && qemu_loglevel_mask(LOG_TRACE)) {
        if (message_with_timestamp) {
            struct timeval _now;
            gettimeofday(&_now, NULL);
#line 39 "../accel/kvm/trace-events"
            qemu_log("%d@%zu.%06zu:kvm_slots_grow " "%u -> %u" "\n",
                     qemu_get_thread_id(),
                     (size_t)_now.tv_sec, (size_t)_now.tv_usec
                     , old, new);
#line 1221 "trace/trace-accel_kvm.h"
        } else {
#line 39 "../accel/kvm/trace-events"
            qemu_log("kvm_slots_grow " "%u -> %u" "\n", old, new);
#line 1225 "trace/trace-accel_kvm.h"
        }
    }
}

static inline void trace_kvm_slots_grow(unsigned int old, unsigned int new)
{
    if (true) {
        _nocheck__trace_kvm_slots_grow(old, new);
    }
}
#endif /* TRACE_ACCEL_KVM_GENERATED_TRACERS_H */
